/// -*- coding: windows-1251 -*-

grammar C1c;

options {
    output = AST;
    backtrack = true;
    memoize = true;
    k   = 2;
}

tokens	{
VARDECL;
VARDEF;
VARDEF_SET;
VARDEF_ARRAY;
SETVAR;
CALLPROC;
INDEX;

//// KEYWORDS. 
R_VAR = 'Перем';
E_VAR = 'Var';
R_DIM = 'Разм';
E_DIM = 'Dim';

R_PROCEDURE = 'Процедура';
E_PROCEDURE = 'Procedure'; 
R_ENDPROC  = 'КонецПроцедуры';
E_ENDPROC  = 'EndProcedure'; 
R_FUNCTION  = 'Функция';
E_FUNCTION  = 'Function'; 
R_ENDFUNC  = 'КонецФункции';
E_ENDFUNC  = 'EndFunction'; 

R_RETURN  = 'Возврат';
E_RETURN  =  'Return';

R_NOT = 'НЕ';
E_NOT = 'NOT';
R_AND = 'И';
E_AND = 'AND';
R_OR = 'ИЛИ';
E_OR = 'OR';

R_XOR = 'ХИЛИ';
E_XOR = 'XOR';

MOD   = '%'; 

R_GOTO= 'Перейти';
E_GOTO= 'GoTo'; 

R_BREAK = 'Прервать';  
E_BREAK = 'Break' ;

R_CONTINUE  = 'Продолжить'  ;
E_CONTINUE  = 'Continue' ;

R_RETURN  = 'Возврат' ;
E_RETURN  = 'Return'  ;

R_IF  = 'Если' ;
E_IF  = 'If';
R_THEN  = 'Тогда' ;
E_THEN  = 'Then' ;
R_ELSE  = 'Иначе' ;
E_ELSE  = 'Else' ;
R_ELSEIF  = 'ИначеЕсли';
E_ELSEIF  = 'ElseIf'; 
R_ENDIF   = 'КонецЕсли' ;
E_ENDIF   = 'EndIf'  ;
  
R_FOR   =  'Для';
E_FOR   =  'For';

R_TO    =  'По'; 
E_TO    =  'To';

R_LOOP  = 'Цикл' ;
E_LOOP  =  'Do';
           
R_ENDLOOP = 'КонецЦикла' ;
E_ENDLOOP = 'EndDo';
  
R_WHILE   = 'Пока' ;
E_WHILE   = 'While';


R_RAISE   = 'ВызватьИсключение'  ;
E_RAISE   = 'Raise';

R_TRY     = 'Попытка' ;
E_TRY     = 'Try'   ;

R_EXCEPT  = 'Исключение' ;
E_EXCEPT  = 'Except';

E_ENDTRY  = 'EndTry' ;
R_ENDTRY  = 'КонецПопытки';
R_ENDTRY1 = 'НеПытка';
// Попытка ВызватьИсключение; Исключение ОписаниеОшибки(); НеПытка;
//LOL, not in spec

R_MESSAGE = 'Сообщить';
E_MESSAGE = 'Message';
/// XXX FIXME Убрать MESSAGE. Обрабатывать как обычную функцию в assignmentOrProcCall   

//FIXME TODO: многоязычные ключевые слова без учёта регистра через синтаксические предикаты

} //tokens

//// LEXER GRAMMAR
fragment VAR : R_VAR | E_VAR;
fragment DIM : R_DIM | E_DIM;
fragment PROCEDURE   : R_PROCEDURE | E_PROCEDURE;
fragment ENDPROC     : R_ENDPROC   | E_ENDPROC;
fragment FUNCTION    : R_FUNCTION  | E_FUNCTION;
fragment ENDFUNC     : R_ENDFUNC   | E_ENDFUNC;
fragment RETURN      : R_RETURN    | E_RETURN;
fragment NOT         : R_NOT | E_NOT;
fragment AND         : R_AND | E_AND;
fragment OR          : R_OR | E_OR;
fragment XOR         : R_XOR | E_XOR;
fragment DIV         : '\\' | 'DIV' ; // FIXME : DIV not in spec
fragment GOTO        : R_GOTO | E_GOTO;
fragment BREAK       : R_BREAK | E_BREAK;
fragment CONTINUE    : R_CONTINUE | E_CONTINUE;
fragment IF          : R_IF | E_IF;
fragment THEN        : R_THEN    | E_THEN;
fragment ELSE        : R_ELSE    | E_ELSE;
fragment ELSEIF      : R_ELSEIF  | E_ELSEIF;
fragment ENDIF       : R_ENDIF   | E_ENDIF;
fragment FOR         : R_FOR     | E_FOR;
fragment TO          : R_TO      | E_TO;
fragment LOOP        : R_LOOP    | E_LOOP;
fragment ENDLOOP     : R_ENDLOOP | E_ENDLOOP;
fragment WHILE       : R_WHILE   | E_WHILE;
fragment RAISE       : R_RAISE   | E_RAISE;
fragment TRY         : R_TRY     | E_TRY;
fragment EXCEPT      : R_EXCEPT  | E_EXCEPT;
fragment ENDTRY      : R_ENDTRY  | E_ENDTRY | R_ENDTRY1;
fragment MESSAGE     : R_MESSAGE | E_MESSAGE;
  
 
IDENT  
  : LETTER_RUS (LETTER_RUS|DIGIT)*
  ;

fragment
LETTER_RUS
  :
  'a'..'z'|'A'..'Z'|'а'..'я'|'А'..'Я'|'_'
  ;

fragment
OCTAL_DIGIT :
              '0' .. '7' ;
            

fragment
DIGIT :
        OCTAL_DIGIT | '8' | '9'
        {} // make ANTLRworks display separate branches 
        ;

INT : DIGIT+
// TODO MAYBE | '0o' OCTAL_DIGIT+ | '0x' DIGIT (HEX_DIGIT)*  
    ;

REAL
    :   DIGIT+ '.' DIGIT* EXPONENT?
    |   DIGIT+ EXPONENT?
    ;

COMMENT
    :   '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
    |   '/*' ( options {greedy=false;} : . )* '*/' {$channel=HIDDEN;}
    ;

WS  :   ( ' '
        | '\t'
        | '\r'
        | '\n'
        ) {$channel=HIDDEN;}
    ;


// TODO FIXME Multiline strings, strings with quotes
STRING
    :  '"' ( ESC_SEQ | ~('\\'|'"') | '"' '"')* '"'
    ;

CHARACTER:  '\'' ( ESC_SEQ | ~('\''|'\\') | '\'' '\'' )* '\''
    ;

fragment
EXPONENT : ('e'|'E') ('+'|'-' {})? DIGIT+ ;

fragment
HEX_DIGIT : (DIGIT|'a'..'f'|'A'..'F') ;

fragment
ESC_SEQ
    :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
    |   UNICODE_ESC
    |   OCTAL_ESC
    ;

fragment
OCTAL_ESC
    :   '\\' ('0'..'3') OCTAL_DIGIT OCTAL_DIGIT
    |   '\\' OCTAL_DIGIT OCTAL_DIGIT
    |   '\\' OCTAL_DIGIT
    ;

fragment
UNICODE_ESC
    :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
    ;

//// PARSER GRAMMAR. 
/// ***** Weird stuff, huh? Why do we need it at all

ident   : IDENT ;         // see lexer
number  : INT | REAL ;
integer : INT ;
real   : REAL ;
exponent  : EXPONENT  ;
hexDigit  : HEX_DIGIT ;
digit     : DIGIT ;
octalDigit: OCTAL_DIGIT ;
string    : STRING  ;
character : CHARACTER ;


/// FIXME TODO: Попробовать токен-правила вида
// fragment VAR: R_VAR|E_VAR;
// fragment R_VAR: 'Перем'; fragment E_VAR: 'Var';


dim_: 'Разм' | 'Dim' ;

var:  'Перем' | 'Var';
// if_: IF;           //??? doesn't work
if_: 'Если'| 'If';   //??? does work
then_: 'Тогда'|'Then';
else_: 'Иначе'|'Else';
elseif_: 'ИначеЕсли'|'ElseIf';
endif_: 'КонецЕсли'|'EndIf';

for_: 'Для'|'For';
to_ : 'По' | 'To';
loop_:'Цикл' | 'Do';
endloop_: 'КонецЦикла'|'EndDo';

while_: 'Пока'| 'While';
break_: 'Прервать'|'Break';
continue_: 'Продолжить'|'Continue';

try_:     'Попытка'|'Try';
except_:  'Исключение'|'Except';
endtry_:  'КонецПопытки' | 'EndTry'
       | 'НеПытка'
       ;
raise_ : 'ВызватьИсключение' | 'Raise'
       ;

goto_  :  'Перейти' | 'GoTo'
       ;
not_   : 'NOT' | 'НЕ' ;      

qualID  :
          ident ( '.' ident )*
          ;

constDecl :
          ident '='^ constExpr
          ;
          

constExpr  : 
			  ternaryConstExpr 
			;

ternaryConstExpr : 
			boolLorConstExpr ('?'^ constExpr ':'! ternaryConstExpr )?
			;

boolLorConstExpr :
			regularConstExpr
			;			


regularConstExpr :
          simpleConstExpr ( relation^ simpleConstExpr )?
          ;

relation  :
          '=' 
          | '==' | '!=' 
          | '<>' | '<' | '<=' | '>' | '>=' 
//        'IN' | 'В'
          {}
           ;
          
simpleConstExpr :
      ( '+'^ | '-'^ {})? constTerm ( addOp constTerm )*
      ;

addOp :
      ( '+' | '-' | OR )^
      {} // make ANTLRworks display separate branches 
      ;


constTerm 	:
		  	constMulTerm (mulOp^ constMulTerm )*
		  	;

constMulTerm	:

          constFactor (  powerOp^ constFactor )*
          ;

powerOp		:
			'**' | 'SQROOT'
            {} // make ANTLRworks display separate branches 
            ;



          
mulOp       :
            '*' | '/' | DIV | MOD | AND  
//          | '&'
            {} // make ANTLRworks display separate branches 
            ;
            
constFactor :
            number  | string | setOrQualID |
            '('! constExpr ')'! | ( not_ {} ) constFactor
            ; 
            

setOrQualID : qualID
//NOTES: MAYBE Modula-2/Pascal-like set syntax?
//      set | qualID set? 
      ; 

identList :
          ident ( ',' ident )*
          ;
identInitList :
          identInit ( ',' identInit )*
          ;
identInit :
        identOrArray  ( '=' expression)?
        ;
identOrArray  :
      ident ('['! constExpr ']'!)?
      // TODO check type constExpr = INT number
      ;

varDeclaration  :
          identInitList
          ;

designator  :
            qualID  ( designatorTail )?
            ;
            
designatorTail  :
                ( ( '['! exprList ']'! ) ( '.' ident )* )+
                ;

exprList  :
          expression ( ','! expression )*
          ;

aexprList  :
          ae ( ','! ae )*
          ;

ae 			:
			expression?
			;          

expression  : 
			  ternaryExpr 
			;

ternaryExpr : 
			boolLorExpr ('?'^ expression ':'! ternaryExpr )?
			;

boolLorExpr :
			regularExpr
			;			


regularExpr :
            simpleExpr  ( relation^ simpleExpr )?
            ;

simpleExpr  :
			dim_ ident
			|
			'SQRT' term
			|
            ( '+'^ | '-'^ {})? term ( addOp^ term )*
            ;

term  :
      mulTerm  ( mulOp^ mulTerm )*
      ;

mulTerm  :
      factor  ( powerOp^ factor )*
      ;

          
factor :
        number |
        string |
        character   |
        designatorOrProcCall |
        '('! expression ')'! 
        | (not_ {}) factor
        ;

designatorOrProcCall  :
    qualID
    ( designatorTail? actualParams? )
    ;
    
actualParams  :
       '('! aexprList? ')'!
       ;

commonStatement :
      assignmentOrProcCall 
      | ifStmt 
      | whileStmt 
      | forStmt 
      | gotoStmt 
      | xcptnStmt
// XXX FIXME       
      | messageStmt
      ;




messageStmt :
    // XXX FIXME Shouldn't require any, but ATM stub 
    /// Message(FOO) should be handled not by 'messageStmt' rule, but with common assignmentOrProcCall  rule
    ('Сообщить'|'Message')^ actualParams
    ;

loopStatement :
              forStmt | whileStmt 
              ;

loopInsideStatement :
            commonStatement |
            breakStatement  |
            continueStatement
            ;

// MAYBE break label/ continue label ?
breakStatement  :
                break_
                ;

continueStatement :
                  continue_
                  ;
                  

xcptnInsideStatement :
            commonStatement |
            raiseStatement
            ;

raiseStatement  :
                raise_
                ;

funcOrProcInsideStatement :
            commonStatement |
            RETURN expression?
            ;            
            
       
statement :
          label?
          ( commonStatement 
          )?
          ;

loopBodyStmt :
          label?
          ( loopInsideStatement )?
          ;
          
xcptnBodyStmt :
          label?
          ( xcptnInsideStatement )?
          ;
//  Доступно только в xcptBody:
//    ОписаниеОшибки();
//    GetErrorDescription();
// в других местах возвращает пустую строку

          
funcOrProcBodyStmt  :
          label?
          ( funcOrProcInsideStatement )?
          ;


assignmentOrProcCall  :
      designator
      ( '=' expression 
      -> ^(SETVAR designator expression )
      | actualParams? 
      -> ^(CALLPROC designator actualParams )
      )
      ;

statementList :
        ( statement ';'!)*
           ;

loopStatementList :
           ( loopBodyStmt ';'! )*
           ;

xcptnStatementList :
           ( xcptnBodyStmt ';'! )*
           ;

funcOrProcStatementList :
           ( funcOrProcBodyStmt ';'! )*
           ;

ifStmt  :
        if_ ifExpr=condExpr then_ thenClause+=statementList
        ( options {k=1; backtrack=false;}: 
        elseif_ elsifExpr=condExpr then_ elseifClause+=statementList )* 
        ( options {k=1; backtrack=false;}: 
        else_ elseClause+=statementList )?
        endif_
        ;

condExpr  :
    expression
        /// TODO FIXME check semantic, that expression is boolean
    ;

      
whileStmt :
          while_ whileLoopExpr=condExpr  loop_ whileLoopBody+=loopStatementList endloop_
          ;

forStmt :
        for_   forLoopVar=ident '=' forLoopInit=expression to_ forLoopUntil=expression
// Loop step:
//      ( BY constExpr )?         
        loop_ forLoopBody+=loopStatementList 
        endloop_
        ; 

labelID :
        IDENT | INT
        ;

label   :
        '~'! labelID ':'!
        ;

gotoStmt  :
          goto_ labelID
          ;
          
xcptnStmt  :
           try_ tryBody+=xcptnStatementList
           ( except_ xcptBody+=xcptnStatementList )?
           endtry_
           ;
           

procedureDeclaration  :
        procedureHeading blockFuncOrProc endProcedureHeading
        ;

procedureHeading  :
        PROCEDURE ident formalParams?
        ;
endProcedureHeading :
        ENDPROC
        ;
        

functionDeclaration  :
        functionHeading blockFuncOrProc endFunctionHeading
        ;
        
functionHeading  :
        FUNCTION ident formalParams?
        ;
endFunctionHeading :
        ENDFUNC
        ;

block :
          variableDeclaration*
          statementList
          ;

variableDeclaration :
      variable
      ;

variableDeclarations:
      variableDeclaration+
      ;
      
variable  :      
      var  varDeclaration 
      ';'
       -> ^(VARDEF varDeclaration)+
      ;  

blockFuncOrProc :
          variableDeclaration*
          funcOrProcStatementList
          ;

          
formalParams  :
              '('! ( fpSection ( ','! fpSection )* )? ')'! 
              ;

fpSection :
          var? ident ('='! defaultFormalParameterValue )?
          ;

defaultFormalParameterValue  :
    expression
    ;          
          
           
program : 
     variableDeclaration*
     functionOrProcedureDeclaration*
     statementList
    ;

functionOrProcedureDeclaration :
    functionDeclaration | procedureDeclaration
    ;

import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;

public class Main {
	public static void main(String[] args) throws Exception {

		if (1 != args.length) {
			System.err.println("Usage: java Main input.1s "+
								"\n"+
								"	Print out source input.1s as Sexprs list	");
				return;
		}
		// TODO: more options, pretty printing more beautifully indent, other output formars, error handling, ignore case keywords

		String sourceFilename = args[0];

		CharStream input = new ANTLRFileStream(sourceFilename);
		C1cLexer lex = new C1cLexer(input);
		CommonTokenStream tokens = new CommonTokenStream(lex);
		C1cParser parser = new C1cParser(tokens);

		C1cParser.program_return r = parser.program(); // main rule
		System.out.println("\n;tree("+sourceFilename+")=");
		System.out.println( ((Tree)r.tree).toStringTree() ); //FIXME
		System.out.println(";EOF("+sourceFilename+")");

		if ( parser.getNumberOfSyntaxErrors()>0 ) {
			// don't tree parse if has errors
			System.err.println(" Syntax error in parsing "+sourceFilename );
			// FIXME: error where in file?
			// TODO : error handling
			return;
		}
/*  TODO: more beautiful pretty printing with indent -- via codewalker
    
		CommonTreeNodeStream nodes = new CommonTreeNodeStream((Tree)r.tree);
		nodes.setTokenStream(tokens);
		SimpleCWalker walker = new SimpleCWalker(nodes);
		walker.program();
*/
	}
}

Перем А;     //так работает
//пЕРЕМ Д; //так не работает
//Обработки ошибок пока нет.  Ignorecase для ключевых слов -- тоже пока нет. 
//Контроля семантики, типов -- тоже пока нет.

Б=123*А+564-30/(40-50);
Сообщить("Мы тут посчитали, что Б="+Б);

export PROJ_JDK_PATH=/dev/java/jdk1.7.0_02
export PROJ_ANTLR_PATH=/dev/src/parsers/ANTLR/antlr-3.4-complete.jar
export PROJ_MAVEN_PATH=/dev/src/parsers/ANTLR/apache-maven-3.0.4-bin/apache-maven-3.0.4
export CLASSPATH=${PROJ_ANTLR_PATH}:${PROJ_JDK_PATH}/lib:.:${CLASSPATH}
export PATH=${PROJ_JDK_PATH}/bin:${PROJ_MAVEN_PATH}/bin:${PATH}
export JAVA_HOME=${PROJ_JDK_PATH}
export M2_HOME=${PROJ_MAVEN_PATH}

java org.antlr.Tool  -verbose  -print  C1c.g
rm -rf classes
mkdir classes
javac *.java -d classes
( cd classes; java Main ../input.1s )

;tree(../input.1s)=
(VARDEF А) (SETVAR Б (- (+ (* 123 А) 564) (/ 30 (- 40 50)))) (Сообщить (+ "Мы тут посчитали, что Б=" Б))
;EOF(../input.1s)

;tree(../input.1s)=
(VARDEF А) (SETVAR Б (- (+ (* 123 А) 564) (/ 30 (- 40 50)))) (Сообщить (+ "Мы тут посчитали, что Б=" Б))
;EOF(../input.1s)

функция->число умножение(число a, число б)
{
   если(а > МАКСИМАЛЬНОЕ_ЦЕЛОЕ_ЧИСЛО ||
       б > МАКСИМАЛЬНОЕ_ЦЕЛОЕ_ЧИСЛО )
   { 
       печать("число слишком большое");
   };


 переменнея->число результат = 0;
 результат = а + б;
 вернуть результат;

}

goto - перейти
end - конец
begin - начало
let - пусть
void - пустая
mode - режим

goto  - перейти - скок|прыг[нуть]
end   - конец   - всё
begin - начало  - так|вот
let   - пусть   - при|здесь|на|в|тут
void  - пустая  - ничё|без|это слово вообще можно не писать
mode  - режим   - мода

begin - начало  - итак
function - функция - дело