grammar SimanticsData;

options {
    language = C;
    output = AST;
    ASTLabelType=pANTLR3_BASE_TREE;
}

tokens {
    TYPE_DEFINITIONS;
    TYPE_DEFINITION;    

    UNION_TYPE;    
    RECORD_TYPE;
    TUPLE_TYPE;
    ARRAY_TYPE;
    TYPE_REFERENCE;
    TYPE_ANNOTATION;    
    TYPE_COMPONENT;
    
    VALUE_DEFINITIONS;
    VALUE_DEFINITION;

    NO_VALUE;    
    VARIANT;
    ARRAY;
    TUPLE;
    TAGGED_VALUE;
    RECORD;
    MAP;
    ASSIGNMENT;
}

ID  :	('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
    ;

INT :	'-'? '0'..'9'+
    ;

FLOAT
    :   '-'? ('0'..'9')+ '.' ('0'..'9')+ EXPONENT?
    //|   '-'? '.' ('0'..'9')+ EXPONENT?
    |   '-'? ('0'..'9')+ EXPONENT
    ;

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

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

STRING
    :  '"' ( ESC_SEQ | ~('\\'|'"') )* '"'
    |  '"""' ( ~('"') | '"' ~('"') | '""' ~('"') )* '"""'
    ;

fragment
EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;

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

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

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

fragment
UNICODE_ESC
    :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
    ;
    
/* -----------------------------------------------------------
   TYPE DEFINITIONS    
   ----------------------------------------------------------- */
 
    
typeDefinitions : typeDefinition* -> ^(TYPE_DEFINITIONS typeDefinition*);

typeDefinition 
    : 'type' ID '=' unionType -> ^(TYPE_DEFINITION ID unionType)
    ;
    
unionType 
    : type
    | ('|' unionComponent)+
    -> ^(UNION_TYPE unionComponent+)
    ;
   
unionComponent : ID type? -> ^(TYPE_COMPONENT ID type?) ;

type 
    : (basicType -> basicType)
      ('[' arrayLength? ']' -> ^(ARRAY_TYPE $type arrayLength?))* ;

arrayLength 
    : INT
    | INT '..'
    | '..' INT 
    | INT '..' INT
    ;

basicType 
    : tupleType
    | recordType
    | typeReference
    ;
    
tupleType 
    : '(' (unionType (',' unionType)*)? ')' 
    -> ^(TUPLE_TYPE unionType*) 
    ;

recordType 
    : '{' (component (',' component)*)? '}' 
    -> ^(RECORD_TYPE component*)
    ;

component 
    : ID ':' unionType 
    -> ^(TYPE_COMPONENT ID unionType) 
    ;

typeReference 
    : ID ('(' parameter (',' parameter)* ')')? 
    -> ^(TYPE_REFERENCE ID parameter*)
    ;

parameter 
    : ID '=' parameterValue -> ^(TYPE_ANNOTATION ID parameterValue)
    | unionType 
    ;

parameterValue 
    : string
    | boolean
    | number
    | ('[' | '(') range (']' | ')')
    ;
    
range
    : number
    | number '..'
    | '..' number 
    | number '..' number
    ;    
    
number
    : INT
    | FLOAT
    ;

string
    : STRING
    ;
    
boolean
    : 'true'
    | 'false'
    ;

/* -----------------------------------------------------------
   VALUE DEFINITIONS    
   ----------------------------------------------------------- */

valueDefinitions : valueDefinition* -> ^(VALUE_DEFINITIONS valueDefinition*);

valueDefinition 
    : ID ':' unionType '=' value
    -> ^(VALUE_DEFINITION ID unionType value) 
    ;

value 
    : (basicValue -> basicValue)
      (':' type -> ^(VARIANT type $value))* 
    ;

basicValue 
    : 'null' -> NO_VALUE
    | string
    | number
    | boolean
    | array
    | tuple
    | taggedValue
    | map
    | record
    ;

array 
    : '[' (value (',' value)*)? ']'
    -> ^(ARRAY value*) 
    ;

tuple 
    : '(' (value (',' value)*)? ')'
    -> ^(TUPLE value*) 
    ;

taggedValue 
    : ID basicValue
    -> ^(TAGGED_VALUE ID basicValue) 
    ;

record 
    : '{' (recordAssignment (',' recordAssignment)*)? '}'
    -> ^(RECORD recordAssignment*) 
    ;

recordAssignment 
    : ID '=' value
    -> ^(ASSIGNMENT ID value)
    ;

map : 'map' '{' (mapAssignment (',' mapAssignment)*)? '}'
    -> ^(MAP mapAssignment*) 
    ;

mapAssignment 
    : value '=' value
    -> ^(ASSIGNMENT value*) 
    ;