version01.g

基于ANTLR的简单编译器源码version0.1

options{
  language="Cpp";
}

class Datalexer extends Lexer;
options
{                                                    
   charVocabulary = '\0'..'\377';                                 
   testLiterals=false;    
   defaultErrorHandler = false;
   k=4;                          
} 


APOSTROPHE  :'\'';
SMEI        :';';
COLON       :':';

protected DIGIT                   
  : '0'..'9';                                                    
                                                              
INT                                                               
options {                                                         
  paraphrase = "an integer value";                                
}                                                                 
	:    (DIGIT)+                  // base-10                       
             (  '.' (DIGIT)*                      	{$setType(DOUBLE);}
	         (('e' | 'E') ('+' | '-')? (DIGIT)+)?                   
	     |   ('e' | 'E') ('+' | '-')? (DIGIT)+   	{$setType(DOUBLE);}
             )?                                                   
	;                                                               

HEX
options {                                                         
  paraphrase = "a hexadecimal integer value";                                
}
   :'0' ('X'|'x')('a'..'f'|DIGIT|'A'..'F')+
   ;
	
DOUBLE                                                             
options {                                                         
  paraphrase = "an floating point value";                         
}
	:    '.' (DIGIT)+ (('e' | 'E') ('+' | '-')? (DIGIT)+)?          
    ; 

WS	:	(	' '
		|	'\t'
		|	'\f'
		// handle newlines
		|	(	"\r\n"  // Evil DOS
			|	'\r'    // Macintosh
			|	'\n'    // Unix (the right way)
			)
			{ newline(); }
		)
		{ _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; }
	;
	
IDENT
options {
  testLiterals = true;
  paraphrase = "an identifer";
}

	:	('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
	;
	
BIT: 'b' APOSTROPHE ('0'|'1');

BITS:'B' APOSTROPHE ('0'|'1')+;

SL_COMMENT :                                     
	"//"                                           
	(~'\n')* '\n'                                  
	{ _ttype = antlr::Token::SKIP; newline(); }    
	;                                              
                                                 
ML_COMMENT                                       
	:	"/*"                                         
		(	{ LA(2)!='/' }? '*'                        
		|	'\n' { newline(); }                        
		|	~('*'|'\n')                                
		)*                                           
		"*/"                                         
			{ $setType(antlr::Token::SKIP); }          
	; 

CHAR
options {
  paraphrase = "a character literal";
}
	:
	'\''
	( ESC | ~'\'' )
	'\''
	;

STRING
options {
  paraphrase = "a string literal";
}
	:
	'"'
	(ESC|~'"')*
	'"'
	;

protected
ESC	:	'\\'
		(	'n'
		|	'r'
		|	't'
		|	'b'
		|	'f'
		|	'"'
		|	'\''
		|	'\\'
		|	'0'..'3'
			(
				options {
					warnWhenFollowAmbig = false;
				}
			:	DIGIT
				(
					options {
						warnWhenFollowAmbig = false;
					}
				:	DIGIT
				)?
			)?
		|	'4'..'7'
			(
				options {
					warnWhenFollowAmbig = false;
				}
			:	DIGIT
			)?
		)
	;
	
//#############################################################################
//#############################################################################
		
class DataParser extends Parser;
options
 {
	genHashLines = true;		// include line number information
	buildAST = true;			// uses CommonAST by default   
	defaultErrorHandler = false;
	exportVocab=myScript;
	k=3;
} 
tokens
{
 BLOCK;
 PROGRAM;
 DEFASSIGN;
}	

program        
    :(statement)*
	{## =#([PROGRAM, "PROGRAM"], ##);}
    ;

definition
    :var_def
    ;

var_def
    :type_name COLON!
	(
	  IDENT (ASSIGN! expression ) {## =#([DEFASSIGN, "DEFASSIGN"], ##);}
	  |IDENT  (COMMA! IDENT)*
	) SEMI!
	;	
	
const_value
   :BIT
   |BITS
   |INT 
   |HEX
   |DOUBLE  
   |CHAR
   |STRING
   |"true"
   |"false"
   ;

type_name
   :"bit"
   |"bits"
   |"uint8"
   |"char"
   |"string"
   |"uint16"
   |"int16"
   |"int"
   |"uint"
   |"float"
   |"double"
   |"bool"
   ;

block
  :LCURLY!
  (statement)*
  RCURLY!
  {## = #([BLOCK, "BLOCK"], ##);}
  ;
  
statement
  :definition
  |assign_statement
  |block
  ;   

expression
  :const_value
  |IDENT;  


assign_statement
   :IDENT  ASSIGN^ expression SEMI!
   ;   

//#############################################################################
//#############################################################################
class DataASTParser extends TreeParser;
options {
	defaultErrorHandler = false;
}

program        
    :#(PROGRAM (statement)*)
    ;

definition
    :var_def
    ;

var_def
    :#(DEFASSIGN type_name IDENT expression)
	 |(type_name (IDENT)*)	
	;	
	
const_value
   :BIT
   |BITS
   |INT 
   |HEX
   |DOUBLE  
   |CHAR
   |STRING
   |"true"
   |"false"
   ;

type_name
   :"bit"
   |"bits"
   |"uint8"
   |"char"
   |"string"
   |"uint16"
   |"int16"
   |"int"
   |"uint"
   |"float"
   |"double"
   |"bool"
   ;

block
  :#(BLOCK (statement)*)
  ;
  
statement
  :definition
  |assign_statement
  |block
  ;   

expression
  :const_value
  |IDENT;  


assign_statement
   :#(ASSIGN IDENT  expression)
   ;