Jan Breuer
2018-07-14 007889b4128e8656c55ba31404a698e98719c262
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
grammar scpi;
 
terminatedProgramMessage 
    :    programMessage NL? EOF
    ;
    
programMessage
    :    programMessageUnit (SEMICOLON programMessageUnit)*
    ;
    
    
programMessageUnit 
    :    WS* programHeader (WS programData (COMMA programData)*)?
    ;
 
programHeader
    :    compoundProgramHeader
    |    commonProgramHeader
    ;
 
compoundProgramHeader
    :    COLON? PROGRAM_MNEMONIC (COLON PROGRAM_MNEMONIC)* QUESTION?
    ;
    
commonProgramHeader 
    :    STAR PROGRAM_MNEMONIC QUESTION?
    ;
    
programDataSeparator 
    :      WS*
    ;
 
programData
    :    WS* programDataType WS*
    ;
    
programDataType
    :    nondecimalNumericProgramData
    |    characterProgramData
    |    decimalNumericProgramData
    |    stringProgramData
    |    arbitraryBlockProgramData
    |    expressionProgramData
//    |    suffixProgramData
    ;
 
nondecimalNumericProgramData
    :    HEXNUM
    |    OCTNUM
    |    BINNUM
    ;
    
characterProgramData
    :    PROGRAM_MNEMONIC
    ;
 
decimalNumericProgramData
    :    DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX
    ;
    
//suffixProgramData
//    :    PROGRAM_MNEMONIC//SUFFIX_PROGRAM_DATA
//    ;
    
stringProgramData
    :    SINGLE_QUOTE_PROGRAM_DATA
    |    DOUBLE_QUOTE_PROGRAM_DATA
    ;    
 
expressionProgramData
    :     PROGRAM_EXPRESSION
    ;
 
// support only nonzero prefix
arbitraryBlockProgramData
    :    SHARP NONZERO_DIGIT NUMBER .*
    ;
        
PROGRAM_MNEMONIC    :     ALPHA (ALPHA | DIGIT | UNDERSCORE)*;
HEXNUM            :    SHARP H HEXDIGIT*;
BINNUM            :    SHARP Q OCTDIGIT*;
OCTNUM            :    SHARP B BINDIGIT*;
UNDERSCORE        :    '_';
SEMICOLON         :    ';';
QUESTION        :    '?';
COLON             :    ':';
COMMA            :    ',';
STAR            :    '*';
NL            :    '\r'? '\n' ;
WS              :       (SPACE | TAB);
 
DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX    :    DECIMAL_NUMERIC_PROGRAM_DATA WS* (SUFFIX_PROGRAM_DATA)?;
fragment DECIMAL_NUMERIC_PROGRAM_DATA    :    MANTISA WS* (EXPONENT)?;
SINGLE_QUOTE_PROGRAM_DATA    :    SINGLE_QUOTE ( (NON_SINGLE_QUOTE) | (SINGLE_QUOTE SINGLE_QUOTE))* SINGLE_QUOTE;
DOUBLE_QUOTE_PROGRAM_DATA    :    DOUBLE_QUOTE ( (NON_DOUBLE_QUOTE) | (DOUBLE_QUOTE DOUBLE_QUOTE))* DOUBLE_QUOTE;
//SUFFIX_PROGRAM_DATA    :    SLASH? (ALPHA+ (MINUS? DIGIT)?) ((SLASH | DOT) (ALPHA+ (MINUS? DIGIT)?))*;    
fragment SUFFIX_PROGRAM_DATA    :    SLASH? ALPHA+ ((SLASH | DOT) ALPHA+)*;    
//fragment SUFFIX_PROGRAM_DATA    :    ALPHA+;    
 
fragment PROGRAM_EXPRESSION_CHARACTER    :     (SPACE | '!' | '$'..'&' | '*'..':' | '<' ..'~');
PROGRAM_EXPRESSION    :    LBRACKET PROGRAM_EXPRESSION_CHARACTER RBRACKET;
    
fragment PLUSMN        :    (PLUS | MINUS);
fragment MANTISA    :    PLUSMN? ( (NUMBER) | (NUMBER DOT NUMBER?) | (DOT NUMBER));
    
//fragment EXPONENT    :    WS* E WS* PLUSMN? NUMBER;
fragment EXPONENT    :    E WS* PLUSMN? NUMBER;
 
fragment NUMBER        :    DIGIT+;
 
fragment LBRACKET        :    '(';
fragment RBRACKET        :    ')';
 
fragment ALPHA        :    ('a'..'z'|'A'..'Z');
fragment DIGIT        :    ('0'..'9');
fragment NONZERO_DIGIT    :    ('1'..'9');
 
fragment HEXDIGIT    :    (DIGIT | 'a'..'f' | 'A'..'F');
fragment OCTDIGIT    :    ('0'..'7');
fragment BINDIGIT    :    ('0' | '1');
 
fragment SHARP            :    '#';
 
fragment E        :    ('E'|'e');
fragment H        :    ('H'|'h');
fragment Q        :    ('Q'|'q');
fragment B        :    ('B'|'b');
 
fragment SPACE        :    ' ';
fragment TAB        :    '\t';
 
fragment PLUS        :    '+';
fragment MINUS        :    '-';
fragment DOT        :    '.';
fragment SLASH        :    '/';
fragment SINGLE_QUOTE    :    '\'';
fragment DOUBLE_QUOTE    :    '"';
fragment NON_SINGLE_QUOTE     :    ~SINGLE_QUOTE;
fragment NON_DOUBLE_QUOTE     :    ~DOUBLE_QUOTE;