api.chapi-ast-csharp.1.3.1.source-code.CSharpLexer.g4 Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of chapi-ast-csharp Show documentation
Show all versions of chapi-ast-csharp Show documentation
Chapi is A common language meta information convertor, convert different languages to same meta-data model
// Eclipse Public License - v 1.0, http://www.eclipse.org/legal/epl-v10.html
// Copyright (c) 2013, Christian Wulf ([email protected])
// Copyright (c) 2016-2017, Ivan Kochurkin ([email protected]), Positive Technologies.
lexer grammar CSharpLexer;
channels { COMMENTS_CHANNEL, DIRECTIVE }
options { superClass = chapi.ast.antlr.CSharpLexerBase; }
BYTE_ORDER_MARK: '\u00EF\u00BB\u00BF';
SINGLE_LINE_DOC_COMMENT: '///' InputCharacter* -> channel(COMMENTS_CHANNEL);
EMPTY_DELIMITED_DOC_COMMENT: '/***/' -> channel(COMMENTS_CHANNEL);
DELIMITED_DOC_COMMENT: '/**' ~'/' .*? '*/' -> channel(COMMENTS_CHANNEL);
SINGLE_LINE_COMMENT: '//' InputCharacter* -> channel(COMMENTS_CHANNEL);
DELIMITED_COMMENT: '/*' .*? '*/' -> channel(COMMENTS_CHANNEL);
WHITESPACES: (Whitespace | NewLine)+ -> channel(HIDDEN);
SHARP: '#' -> mode(DIRECTIVE_MODE), skip;
ABSTRACT: 'abstract';
ADD: 'add';
ALIAS: 'alias';
ARGLIST: '__arglist';
AS: 'as';
ASCENDING: 'ascending';
ASYNC: 'async';
AWAIT: 'await';
BASE: 'base';
BOOL: 'bool';
BREAK: 'break';
BY: 'by';
BYTE: 'byte';
CASE: 'case';
CATCH: 'catch';
CHAR: 'char';
CHECKED: 'checked';
CLASS: 'class';
CONST: 'const';
CONTINUE: 'continue';
DECIMAL: 'decimal';
DEFAULT: 'default';
DELEGATE: 'delegate';
DESCENDING: 'descending';
DO: 'do';
DOUBLE: 'double';
DYNAMIC: 'dynamic';
ELSE: 'else';
ENUM: 'enum';
EQUALS: 'equals';
EVENT: 'event';
EXPLICIT: 'explicit';
EXTERN: 'extern';
FALSE: 'false';
FINALLY: 'finally';
FIXED: 'fixed';
FLOAT: 'float';
FOR: 'for';
FOREACH: 'foreach';
FROM: 'from';
GET: 'get';
GOTO: 'goto';
GROUP: 'group';
IF: 'if';
IMPLICIT: 'implicit';
IN: 'in';
INT: 'int';
INTERFACE: 'interface';
INTERNAL: 'internal';
INTO: 'into';
IS: 'is';
JOIN: 'join';
LET: 'let';
LOCK: 'lock';
LONG: 'long';
NAMEOF: 'nameof';
NAMESPACE: 'namespace';
NEW: 'new';
NULL_: 'null';
OBJECT: 'object';
ON: 'on';
OPERATOR: 'operator';
ORDERBY: 'orderby';
OUT: 'out';
OVERRIDE: 'override';
PARAMS: 'params';
PARTIAL: 'partial';
PRIVATE: 'private';
PROTECTED: 'protected';
PUBLIC: 'public';
READONLY: 'readonly';
REF: 'ref';
REMOVE: 'remove';
RETURN: 'return';
SBYTE: 'sbyte';
SEALED: 'sealed';
SELECT: 'select';
SET: 'set';
SHORT: 'short';
SIZEOF: 'sizeof';
STACKALLOC: 'stackalloc';
STATIC: 'static';
STRING: 'string';
STRUCT: 'struct';
SWITCH: 'switch';
THIS: 'this';
THROW: 'throw';
TRUE: 'true';
TRY: 'try';
TYPEOF: 'typeof';
UINT: 'uint';
ULONG: 'ulong';
UNCHECKED: 'unchecked';
UNMANAGED: 'unmanaged';
UNSAFE: 'unsafe';
USHORT: 'ushort';
USING: 'using';
VAR: 'var';
VIRTUAL: 'virtual';
VOID: 'void';
VOLATILE: 'volatile';
WHEN: 'when';
WHERE: 'where';
WHILE: 'while';
YIELD: 'yield';
//B.1.6 Identifiers
// must be defined after all keywords so the first branch (Available_identifier) does not match keywords
// https://msdn.microsoft.com/en-us/library/aa664670(v=vs.71).aspx
IDENTIFIER: '@'? IdentifierOrKeyword;
//B.1.8 Literals
// 0.Equals() would be parsed as an invalid real (1. branch) causing a lexer error
LITERAL_ACCESS: [0-9] ('_'* [0-9])* IntegerTypeSuffix? '.' '@'? IdentifierOrKeyword;
INTEGER_LITERAL: [0-9] ('_'* [0-9])* IntegerTypeSuffix?;
HEX_INTEGER_LITERAL: '0' [xX] ('_'* HexDigit)+ IntegerTypeSuffix?;
BIN_INTEGER_LITERAL: '0' [bB] ('_'* [01])+ IntegerTypeSuffix?;
REAL_LITERAL: ([0-9] ('_'* [0-9])*)? '.' [0-9] ('_'* [0-9])* ExponentPart? [FfDdMm]? | [0-9] ('_'* [0-9])* ([FfDdMm] | ExponentPart [FfDdMm]?);
CHARACTER_LITERAL: '\'' (~['\\\r\n\u0085\u2028\u2029] | CommonCharacter) '\'';
REGULAR_STRING: '"' (~["\\\r\n\u0085\u2028\u2029] | CommonCharacter)* '"';
VERBATIUM_STRING: '@"' (~'"' | '""')* '"';
INTERPOLATED_REGULAR_STRING_START: '$"' { this.OnInterpolatedRegularStringStart(); } -> pushMode(INTERPOLATION_STRING);
INTERPOLATED_VERBATIUM_STRING_START: '$@"' { this.OnInterpolatedVerbatiumStringStart(); } -> pushMode(INTERPOLATION_STRING);
//B.1.9 Operators And Punctuators
OPEN_BRACE: '{' { this.OnOpenBrace(); };
CLOSE_BRACE: '}' { this.OnCloseBrace(); };
OPEN_BRACKET: '[';
CLOSE_BRACKET: ']';
OPEN_PARENS: '(';
CLOSE_PARENS: ')';
DOT: '.';
COMMA: ',';
COLON: ':' { this.OnColon(); };
SEMICOLON: ';';
PLUS: '+';
MINUS: '-';
STAR: '*';
DIV: '/';
PERCENT: '%';
AMP: '&';
BITWISE_OR: '|';
CARET: '^';
BANG: '!';
TILDE: '~';
ASSIGNMENT: '=';
LT: '<';
GT: '>';
INTERR: '?';
DOUBLE_COLON: '::';
OP_COALESCING: '??';
OP_INC: '++';
OP_DEC: '--';
OP_AND: '&&';
OP_OR: '||';
OP_PTR: '->';
OP_EQ: '==';
OP_NE: '!=';
OP_LE: '<=';
OP_GE: '>=';
OP_ADD_ASSIGNMENT: '+=';
OP_SUB_ASSIGNMENT: '-=';
OP_MULT_ASSIGNMENT: '*=';
OP_DIV_ASSIGNMENT: '/=';
OP_MOD_ASSIGNMENT: '%=';
OP_AND_ASSIGNMENT: '&=';
OP_OR_ASSIGNMENT: '|=';
OP_XOR_ASSIGNMENT: '^=';
OP_LEFT_SHIFT: '<<';
OP_LEFT_SHIFT_ASSIGNMENT: '<<=';
OP_COALESCING_ASSIGNMENT: '??=';
OP_RANGE: '..';
// https://msdn.microsoft.com/en-us/library/dn961160.aspx
mode INTERPOLATION_STRING;
DOUBLE_CURLY_INSIDE: '{{';
OPEN_BRACE_INSIDE: '{' { this.OpenBraceInside(); } -> skip, pushMode(DEFAULT_MODE);
REGULAR_CHAR_INSIDE: { this.IsRegularCharInside() }? SimpleEscapeSequence;
VERBATIUM_DOUBLE_QUOTE_INSIDE: { this.IsVerbatiumDoubleQuoteInside() }? '""';
DOUBLE_QUOTE_INSIDE: '"' { this.OnDoubleQuoteInside(); } -> popMode;
REGULAR_STRING_INSIDE: { this.IsRegularCharInside() }? ~('{' | '\\' | '"')+;
VERBATIUM_INSIDE_STRING: { this.IsVerbatiumDoubleQuoteInside() }? ~('{' | '"')+;
mode INTERPOLATION_FORMAT;
DOUBLE_CURLY_CLOSE_INSIDE: '}}' -> type(FORMAT_STRING);
CLOSE_BRACE_INSIDE: '}' { this.OnCloseBraceInside(); } -> skip, popMode;
FORMAT_STRING: ~'}'+;
mode DIRECTIVE_MODE;
DIRECTIVE_WHITESPACES: Whitespace+ -> channel(HIDDEN);
DIGITS: [0-9]+ -> channel(DIRECTIVE);
DIRECTIVE_TRUE: 'true' -> channel(DIRECTIVE), type(TRUE);
DIRECTIVE_FALSE: 'false' -> channel(DIRECTIVE), type(FALSE);
DEFINE: 'define' -> channel(DIRECTIVE);
UNDEF: 'undef' -> channel(DIRECTIVE);
DIRECTIVE_IF: 'if' -> channel(DIRECTIVE), type(IF);
ELIF: 'elif' -> channel(DIRECTIVE);
DIRECTIVE_ELSE: 'else' -> channel(DIRECTIVE), type(ELSE);
ENDIF: 'endif' -> channel(DIRECTIVE);
LINE: 'line' -> channel(DIRECTIVE);
ERROR: 'error' Whitespace+ -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
WARNING: 'warning' Whitespace+ -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
REGION: 'region' Whitespace* -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
ENDREGION: 'endregion' Whitespace* -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
PRAGMA: 'pragma' Whitespace+ -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
NULLABLE: 'nullable' Whitespace+ -> channel(DIRECTIVE), mode(DIRECTIVE_TEXT);
DIRECTIVE_DEFAULT: 'default' -> channel(DIRECTIVE), type(DEFAULT);
DIRECTIVE_HIDDEN: 'hidden' -> channel(DIRECTIVE);
DIRECTIVE_OPEN_PARENS: '(' -> channel(DIRECTIVE), type(OPEN_PARENS);
DIRECTIVE_CLOSE_PARENS: ')' -> channel(DIRECTIVE), type(CLOSE_PARENS);
DIRECTIVE_BANG: '!' -> channel(DIRECTIVE), type(BANG);
DIRECTIVE_OP_EQ: '==' -> channel(DIRECTIVE), type(OP_EQ);
DIRECTIVE_OP_NE: '!=' -> channel(DIRECTIVE), type(OP_NE);
DIRECTIVE_OP_AND: '&&' -> channel(DIRECTIVE), type(OP_AND);
DIRECTIVE_OP_OR: '||' -> channel(DIRECTIVE), type(OP_OR);
DIRECTIVE_STRING: '"' ~('"' | [\r\n\u0085\u2028\u2029])* '"' -> channel(DIRECTIVE), type(STRING);
CONDITIONAL_SYMBOL: IdentifierOrKeyword -> channel(DIRECTIVE);
DIRECTIVE_SINGLE_LINE_COMMENT: '//' ~[\r\n\u0085\u2028\u2029]* -> channel(COMMENTS_CHANNEL), type(SINGLE_LINE_COMMENT);
DIRECTIVE_NEW_LINE: NewLine -> channel(DIRECTIVE), mode(DEFAULT_MODE);
mode DIRECTIVE_TEXT;
TEXT: ~[\r\n\u0085\u2028\u2029]+ -> channel(DIRECTIVE);
TEXT_NEW_LINE: NewLine -> channel(DIRECTIVE), type(DIRECTIVE_NEW_LINE), mode(DEFAULT_MODE);
// Fragments
fragment InputCharacter: ~[\r\n\u0085\u2028\u2029];
fragment NewLineCharacter
: '\u000D' //''
| '\u000A' //''
| '\u0085' //''
| '\u2028' //''
| '\u2029' //''
;
fragment IntegerTypeSuffix: [lL]? [uU] | [uU]? [lL];
fragment ExponentPart: [eE] ('+' | '-')? [0-9] ('_'* [0-9])*;
fragment CommonCharacter
: SimpleEscapeSequence
| HexEscapeSequence
| UnicodeEscapeSequence
;
fragment SimpleEscapeSequence
: '\\\''
| '\\"'
| '\\\\'
| '\\0'
| '\\a'
| '\\b'
| '\\f'
| '\\n'
| '\\r'
| '\\t'
| '\\v'
;
fragment HexEscapeSequence
: '\\x' HexDigit
| '\\x' HexDigit HexDigit
| '\\x' HexDigit HexDigit HexDigit
| '\\x' HexDigit HexDigit HexDigit HexDigit
;
fragment NewLine
: '\r\n' | '\r' | '\n'
| '\u0085' // '
| '\u2028' //''
| '\u2029' //''
;
fragment Whitespace
: UnicodeClassZS //''
| '\u0009' //''
| '\u000B' //''
| '\u000C' //' © 2015 - 2025 Weber Informatics LLC | Privacy Policy