sdl92.g

/*
    OpenGEODE
    ANTLR 3.1.3 grammar for the SDL92 langage
    Includes the following features from SDL2000+:
    - FOR loops in TASKs
    - Composite states (nested and agreggation/parallel states)

    author: Maxime Perrotin
    with contributions from Diego Barbera, Laurent Meyer
*/

grammar sdl92;

options {
    language=Python;
    output=AST;
    ASTLabelType=CommonTree;
    backtrack=true;
}

tokens {
        ACTION;
        ALL;
        ALTERNATIVE;
        ANSWER;
        ARRAY;
        ASN1;
        ASSIGN;
        BITSTR;
        BLOCK;
        CHANNEL;
        CHOICE;
        CIF;
        CLOSED_RANGE;
        COMMENT;
        COMPOSITE_STATE;
        CONDITIONAL;
        CONNECT;
        CONNECTION;
        CONSTANT;
        CONSTANTS;
        DCL;
        DECISION;
        DIGITS;
        ELSE;
        EMPTYSTR;
        ENDNEWTYPE;
        ENDSYNTYPE;
        ENDTEXT;
        ENTRY_POINT;
        EXPORT;
        EXPRESSION;
        EXTERNAL;
        FI;
        FIELD;
        FIELD_NAME;
        FIELDS;
        FLOAT2;
        FLOAT;
        FLOATING_LABEL;
        FOR;
        FPAR;
        GROUND;
        HYPERLINK;
        IF;
        IFTHENELSE;
        IN;
        INFORMAL_TEXT;
        INOUT;
        INPUT;
        INPUT_NONE;
        INPUTLIST;
        JOIN;
        LABEL;
        LITERAL;
        NEG;
        NEWTYPE;
        NEXTSTATE;
        NUMBER_OF_INSTANCES;
        OCTSTR;
        OPEN_RANGE;
        OUTPUT;
        OUTPUT_BODY;
        PARAM;
        PARAMNAMES;
        PARAMS;
        PAREN;
        PFPAR;
        POINT;
        PRIMARY;
        PROCEDURE;
        PROCEDURE_CALL;
        PROCEDURE_NAME;
        PROCESS;
        PROVIDED;
        QUESTION;
        RANGE;
        RESET;
        RETURN;
        ROUTE;
        SAVE;
        SELECTOR;
        SEQOF;
        SEQUENCE;
        SET;
        SIGNAL;
        SIGNAL_LIST;
        SORT;
        STATE;
        STATE_AGGREGATION;
        STATE_PARTITION_CONNECTION;
        STATELIST;
        STIMULUS;
        STOP;
        STOPIF;
        STRING;
        STRUCT;
        SYNONYM;
        SYNONYM_LIST;
        SYNTYPE;
        SYSTEM;
        TASK;
        TASK_BODY;
        TERMINATOR;
        TEXT;
        TEXTAREA;
        TEXTAREA_CONTENT;
        THEN;
        TIMER;
        TO;
        TRANSITION;
        TYPE_INSTANCE;
        USE;
        VALUE;
        VARIABLE;
        VARIABLES;
        VIA;
        VIAPATH;
}


/*
    Top level: any .pr file
*/
pr_file
        :       (use_clause
                | system_definition
                | process_definition)+
        ;


system_definition
        :       SYSTEM system_name end
                entity_in_system*
                ENDSYSTEM system_name? end
        ->      ^(SYSTEM system_name entity_in_system*)
        ;


use_clause
        :       use_asn1?
                USE package_name
                ('/' def_selection_list )?
                end
        ->      ^(USE use_asn1? end? package_name def_selection_list?)
        ;


/*
    In USE clause: USE package/X, Y, Z;
*/
def_selection_list
        :       ID (','! ID)*
        ;


/* Entity in system:
   Declare signals, external procedures, connections and blocks
*/
entity_in_system
        :       signal_declaration
                | text_area
                | procedure
                | channel
                | block_definition
        ;

/* signal_declaration:
   e.g. SIGNAL open_door(typeA, typeB);
*/
signal_declaration
        :       paramnames?
                SIGNAL signal_id input_params? end
        ->      ^(SIGNAL paramnames? signal_id input_params?)
        ;


channel
        :       CHANNEL channel_id
                route+
                ENDCHANNEL end
        ->      ^(CHANNEL channel_id route+)
        ;


route
        :       FROM source_id TO dest_id WITH signal_id (',' signal_id)* end
        ->      ^(ROUTE source_id dest_id signal_id+)
        ;


block_definition
        :       BLOCK block_id end
                entity_in_block*
                ENDBLOCK end
        ->      ^(BLOCK block_id entity_in_block*)
        ;


/* Inside a SDL block:
   there can be nested blocks, processes, signalroutes and connections
   to above channels
*/
entity_in_block
        :       signal_declaration
                | signalroute
                | connection
                | block_definition
                | process_definition
        ;


signalroute
        :       SIGNALROUTE route_id
                route+
        ->      ^(SIGNALROUTE route_id route+)
        ;


connection
        :       CONNECT channel_id AND route_id end
        ->      ^(CONNECTION channel_id route_id)
        ;


process_definition
        :       PROCESS process_id number_of_instances? REFERENCED end
        ->      ^(PROCESS process_id number_of_instances? REFERENCED)
                | cif? PROCESS process_id number_of_instances? end
                pfpar?
                (text_area | procedure | composite_state)*
                processBody? ENDPROCESS process_id?
                end
        ->      ^(PROCESS cif? process_id number_of_instances? end?
                pfpar? text_area* procedure* composite_state* processBody?)
                | cif? PROCESS process_id number_of_instances? (':' type_inst)?
                end
        ->      ^(PROCESS cif? process_id type_inst? number_of_instances? end?)
        ;


// Process formal parameters
pfpar
        :       FPAR parameters_of_sort
                (',' parameters_of_sort)*
                end
        ->      ^(PFPAR parameters_of_sort+)
        ;


parameters_of_sort
        :       variable_id (',' variable_id)* sort
        ->      ^(PARAM variable_id+ sort)
        ;


// procedure: missing the RETURNS statement
// (TODO - but check new SDL2000 syntax that has no RETURNS token)
procedure
        :       cif?
                PROCEDURE procedure_id e1=end
                fpar?
                (text_area | procedure)*
                ((processBody? ENDPROCEDURE procedure_id?) | EXTERNAL)
                e2=end
        ->      ^(PROCEDURE cif? procedure_id $e1? $e2? fpar?
                text_area* procedure* processBody? EXTERNAL?)
        ;


// Procedure formal parameters
fpar
        :       FPAR formal_variable_param
                (',' formal_variable_param)*
                end
        ->      ^(FPAR formal_variable_param+)
        ;


formal_variable_param
        :       (INOUT | IN | OUT)?
                variable_id (',' variable_id)* sort
        ->      ^(PARAM INOUT? IN? OUT? variable_id+ sort)
        ;


// text_area: TODO add operator description in content
text_area
        :       cif
                content?
                cif_end_text
        ->      ^(TEXTAREA cif content? cif_end_text)
        ;


// Text areas can contain textual procedures, FPAR declarations,
// and variable or timer declarations
content
        :        (procedure
                 | use_clause
                 | signal_declaration
                 | fpar
                 | timer_declaration
                 | syntype_definition
                 | newtype_definition
                 | variable_definition
                 | synonym_definition)*
        ->       ^(TEXTAREA_CONTENT fpar* procedure* variable_definition*
                   syntype_definition* newtype_definition* timer_declaration*
                   signal_declaration* use_clause* synonym_definition*)
        ;


timer_declaration
        :       TIMER timer_id
                (',' timer_id)*
                end
        ->      ^(TIMER timer_id+)
        ;


syntype_definition
        :       SYNTYPE syntype_name '=' parent_sort
                (CONSTANTS (range_condition (',' range_condition)* ))?
                ENDSYNTYPE syntype_name? end
        ->      ^(SYNTYPE syntype_name parent_sort range_condition*)
        ;


syntype_name
        :       sort
        ;


parent_sort
        :       sort
        ;


newtype_definition
        :       NEWTYPE type_name (array_definition|structure_definition)?
                ENDNEWTYPE type_name? end
        ->      ^(NEWTYPE type_name array_definition* structure_definition*)
        ;


type_name
        :       sort
        ;


array_definition
        :       ARRAY '(' sort ',' sort ')'
        ->      ^(ARRAY sort sort)
        ;


structure_definition
        :       STRUCT field_list end
        ->      ^(STRUCT field_list)
        ;


field_list
        :       field_definition (end field_definition)*
        ->      ^(FIELDS field_definition+)
        ;


field_definition
        :       field_name (',' field_name)* sort
        ->      ^(FIELD field_name+ sort)
        ;


variable_definition
        :       DCL variables_of_sort
                (',' variables_of_sort)*
                end
        ->      ^(DCL variables_of_sort+)
        ;


synonym_definition
        :       internal_synonym_definition
        ;


internal_synonym_definition
        :       SYNONYM synonym_definition_item (',' synonym_definition_item)*
                end
        ->      ^(SYNONYM_LIST synonym_definition_item+)
        ;


synonym_definition_item
        :       sort sort '=' ground_expression
        ->      ^(SYNONYM sort sort ground_expression)
        ;


variables_of_sort
        :       variable_id (',' variable_id)* sort (':=' ground_expression)?
        ->      ^(VARIABLES variable_id+ sort ground_expression?)
        ;


ground_expression
        :       expression
        ->      ^(GROUND expression)
        ;


number_of_instances
        :       '(' initial_number=INT ',' maximum_number=INT ')'
        ->      ^(NUMBER_OF_INSTANCES $initial_number $maximum_number)
        ;


processBody
        :       start? (state | floating_label)*
        ;


start
        :       cif?
                hyperlink?
                START name=state_entry_point_name? end
                transition?
        ->      ^(START cif? hyperlink? $name? end? transition?)
        ;


floating_label
        :       cif?
                hyperlink?
                CONNECTION connector_name ':'
                transition?
                cif_end_label?
                ENDCONNECTION SEMI
        ->      ^(FLOATING_LABEL cif? hyperlink? connector_name transition?)
        ;


state
        :       cif?
                hyperlink?
                STATE statelist e=end
                (state_part)*
                ENDSTATE statename? f=end
        ->      ^(STATE cif? hyperlink? $e? statelist state_part*)
        ;


statelist
        :       ((statename)(',' statename)*)
        ->      ^(STATELIST statename+)
                | ASTERISK exception_state?
        ->      ^(ASTERISK exception_state?)
        ;


exception_state
        :       '(' statename (',' statename)* ')'
        ->      statename+
        ;


// 11.11 State Machine and Composite State (SDL2000)
composite_state
        :       composite_state_graph
                | state_aggregation
        ;


composite_state_graph
        :       STATE statename e=end
                SUBSTRUCTURE
                connection_points*
                body=composite_state_body
                ENDSUBSTRUCTURE statename? f=end
        ->      ^(COMPOSITE_STATE statename connection_points* $body $e?)
        ;


// 11.11.2 State Aggregation (SDL2000)
state_aggregation
        :       STATE AGGREGATION statename e=end
                SUBSTRUCTURE
                connection_points*
                entities=entity_in_composite_state*
                body=state_aggregation_body
                ENDSUBSTRUCTURE statename? f=end
        ->      ^(STATE_AGGREGATION statename connection_points*
                                    $entities* $body $e?)
        ;


// 11.11.2 State Aggregation (SDL2000)
entity_in_composite_state
        :       (text_area | procedure)
        ;


// 11.11.2 State Aggregation (SDL2000)
state_aggregation_body
        :       (state_partitioning | state_partition_connection)+
                state*
        ;


// 11.11.2 State Aggregation (SDL2000)
state_partitioning
        :       composite_state
        ;


// 11.11.2 State Aggregation (SDL2000)
state_partition_connection
        :       CONNECT outer=entry_point AND inner=entry_point end
        ->      ^(STATE_PARTITION_CONNECTION $outer $inner end?)
        ;


// 11.11.2 State Aggregation (SDL2000)
entry_point
        :       state_part_id=ID VIA point
        ->      ^(ENTRY_POINT $state_part_id point)
        ;


// 11.11.2 State Aggregation (SDL2000)
point
        :       (state_point=ID | DEFAULT)
        ->      ^(POINT $state_point? DEFAULT?)
        ;


// 11.11.1 and 11.11.2 Composite State (SDL2000)
connection_points
        :       IN state_entry_exit_points end
        ->      ^(IN state_entry_exit_points end?)
                | OUT state_entry_exit_points end
        ->      ^(OUT state_entry_exit_points end?)
        ;


// 11.11.1 and 11.11.2 Composite State (SDL2000)
state_entry_exit_points
        :       '(' statename (',' statename)* ')'
        ->      statename+
        ;


// 11.11.1 Composite State graph content (SDL2000)
composite_state_body
        :       (text_area | procedure | composite_state)*
                start* (state | floating_label)*
        ;


state_part
        :       input_part
                //| priority_input        // Not supported
                | save_part               // Not supported in openGEODE
                | spontaneous_transition
                | continuous_signal
                | connect_part
        ;


// connect part is used to connect nested state exit points to a transition
connect_part
        :       cif?
                hyperlink?
                CONNECT connect_list? end
                transition?
        ->      ^(CONNECT cif? hyperlink? connect_list? end? transition?)
        ;


connect_list
        :       state_exit_point_name (',' state_exit_point_name)*
                -> state_exit_point_name+
                | ASTERISK
        ;


spontaneous_transition
        :       cif?
                hyperlink?
                INPUT NONE end
                enabling_condition?
                transition
        ->      ^(INPUT_NONE cif? hyperlink? transition)
        ;


enabling_condition
        :       PROVIDED expression end
        ->      ^(PROVIDED expression)
        ;


continuous_signal
        :       cif?
                hyperlink?
                PROVIDED expression e=end
                (PRIORITY p=INT end)?
                transition?
        ->      ^(PROVIDED expression cif? hyperlink? $p? $e? transition?)
        ;


save_part
        :       SAVE save_list
                end
        ->      ^(SAVE save_list)
        ;


save_list
        :       signal_list
                | asterisk_save_list
        ;


asterisk_save_list
        :       ASTERISK;


signal_list
        :       signal_item (',' signal_item)*
        ->      ^(SIGNAL_LIST signal_item+)
        ;



// Signal_item alternatives are all of the same ID type.
// Should be resolved at semantic analysis.
signal_item
        :       signal_id; /* |
                priority_signal_id |
                signal_list_id |
                timer_id;*/

/*   Not considered for the moment
     (irrelevant in the scope of the generation of code for a single process)
priority_input
        :       PRIORITY INPUT priority_input_list end transition;


priority_input_list
        :       priority_stimulus (',' priority_stimulus)*;

priority_stimulus
        :       priority_signal_id ( '(' variable_id (',' variable_id)* ')');
*/


// this is only the "basic input part" from SDL92
input_part
        :       cif?
                hyperlink?
                INPUT inputlist end
                enabling_condition?
                transition?
        ->      ^(INPUT cif? hyperlink? end?
                inputlist enabling_condition? transition?)
        ;


// asterisk means: all signals not excplicitely specified
// (semantic is different from asterisk state)
inputlist
        :       ASTERISK
                | (stimulus (',' stimulus)*)
        ->      ^(INPUTLIST stimulus+)
        ;


stimulus
        :       stimulus_id input_params?
        ;


input_params
        :       L_PAREN variable_id (',' variable_id)* R_PAREN
        ->      ^(PARAMS variable_id+)
        ;


transition
        :       action+ label? terminator_statement?
        ->      ^(TRANSITION action+ label? terminator_statement?)
                | terminator_statement
        ->      ^(TRANSITION terminator_statement)
        ;


action
        :       label?
                (task
                | task_body
                | output
                | create_request
                | decision
                | transition_option
                | set_timer
                | reset_timer
                | export     // Not supported in OpenGEODE
                | procedure_call)
        ;


export
        :       EXPORT
                L_PAREN variable_id (COMMA variable_id)* R_PAREN
                end
        ->      ^(EXPORT variable_id+)
        ;


/*
remote_procedure_call
        :       CALL remote_procedure_call_body;

remote_procedure_call_body
        :       remote_procedure_id actual_parameters? (TO destination)?;
*/
procedure_call
        :       cif?
                hyperlink?
                CALL procedure_call_body end
        ->      ^(PROCEDURE_CALL cif? hyperlink? end? procedure_call_body)
        ;


procedure_call_body
        :       procedure_id actual_parameters?
        ->      ^(OUTPUT_BODY procedure_id actual_parameters?)
        ;


set_timer
        :       SET set_statement (COMMA set_statement)*
                end
        ->      set_statement+
        ;


set_statement
        :       L_PAREN (expression COMMA)? timer_id R_PAREN
        ->      ^(SET expression? timer_id)
        ;
        // ('('expression_list')')? ')'; (removed because of non-LL(*) problem)


reset_timer
        :       RESET reset_statement (',' reset_statement)*
                end
        ->      reset_statement+
        ;


reset_statement
        :       timer_id ('(' expression_list ')')?
        ->      ^(RESET timer_id expression_list?)
        ;


transition_option
        :       ALTERNATIVE alternative_question e=end
                answer_part
                alternative_part
                ENDALTERNATIVE f=end
        ->      ^(ALTERNATIVE answer_part alternative_part)
        ;


alternative_part
        :       (answer_part+ else_part?)
        ->      answer_part+ else_part?
                | else_part
        ->      else_part
        ;


alternative_question
        :       expression
                | informal_text
        ;


decision
        :       cif?
                hyperlink?
                DECISION question e=end
                answer_part?
                alternative_part?
                ENDDECISION f=end
        ->      ^(DECISION cif? hyperlink? $e? question
                answer_part? alternative_part?)
        ;


answer_part
        :       cif?
                hyperlink?
                L_PAREN answer R_PAREN ':' transition?
        ->      ^(ANSWER cif? hyperlink? answer transition?)
        ;


answer
        :       range_condition
                | informal_text
        ;


else_part
        :       cif?
                hyperlink?
                ELSE ':' transition?
        ->      ^(ELSE cif? hyperlink? transition?)
        ;


question
        :       informal_text
                | expression
        ->      ^(QUESTION expression)
                | ANY
        ->      ^(ANY)
        ;


range_condition
        :       (closed_range | open_range)
        ;
                //(',' (closed_range|open_range))*;


closed_range
        :       a=expression ':' b=expression
        ->      ^(CLOSED_RANGE $a $b)
        ;


open_range
        :       constant
        ->      constant
                | ( (EQ|NEQ|GT|LT|LE|GE) constant)
        ->      ^(OPEN_RANGE EQ? NEQ? GT? LT? LE? GE? constant)
        ;


constant
        :       expression
        ->      ^(CONSTANT expression)
        ;


create_request
        :       CREATE
                createbody
                actual_parameters?
                end
        ->      ^(CREATE createbody actual_parameters?)
        ;


createbody
        :       process_id
                | THIS
        ;


output
        :       cif?
                hyperlink?
                OUTPUT outputbody end
        ->      ^(OUTPUT cif? hyperlink? end? outputbody)
        ;


outputbody
        :       outputstmt (',' outputstmt)* to_part?
        ->      ^(OUTPUT_BODY outputstmt+ to_part?)
        ;
 //               via_part?
 //     -> (signal_id actual_parameters?)+ to_part? via_part?;


outputstmt
        :       signal_id
                actual_parameters?
        ;

to_part
        :       (TO destination)
        ->      ^(TO destination)
        ;

via_part
        :       VIA viabody
        ->      ^(VIA viabody)
        ;


// ambiguous in SDL92, added OR between ALL and via_path
viabody
        :       ALL
        ->      ^(ALL)
                | via_path
        ->      ^(VIAPATH via_path)
        ;


destination
        :       pid_expression
                | process_id
                | THIS
        ;


via_path
        :       via_path_element (',' via_path_element)*
        ->      via_path_element+
        ;


via_path_element
        :       ID
        ; // signal_route_id | channel_id | gate_id;


actual_parameters
        :      '(' expression (',' expression)* ')'
        ->     ^(PARAMS expression+)
        ;


task
        :       cif?
                hyperlink?
                TASK task_body? end
        ->      ^(TASK cif? hyperlink? end? task_body?)
        ;


task_body
        :       (assignement_statement (',' assignement_statement)*)
        ->      ^(TASK_BODY assignement_statement+)
                | (informal_text (',' informal_text)*)
        ->      ^(TASK_BODY informal_text+)
                | (forloop (',' forloop)*)
        ->      ^(TASK_BODY forloop+)
        ;


// SDL extension - FOR loop in TASKs
forloop
        :       FOR variable_id IN (range | variable) ':'
                transition?
                ENDFOR
        ->      ^(FOR variable_id variable? range? transition?);

range
        :       RANGE
                L_PAREN a=ground_expression
                (COMMA b=ground_expression)? (COMMA step=INT)?
                R_PAREN
        ->      ^(RANGE $a $b? $step?);

assignement_statement
        :       variable ':=' expression
        ->      ^(ASSIGN variable expression);


// Variable: covers eg. toto(5)(4)!titi(3)!tutu!yoyo
variable
        :       postfix_expression
        |       ID                     ->  ^(VARIABLE ID);


field_selection
        :       (('!'|'.') field_name);


expression
        :       binary_expression;


binary_expression
        :       binary_expression_0 ( IMPLIES^ binary_expression_0)*;
binary_expression_0
        :       binary_expression_1 (( (OR^ ELSE?) | XOR^ ) binary_expression_1)*;
binary_expression_1
        :       binary_expression_2 ( AND^ THEN? binary_expression_2)*;
binary_expression_2
        :       binary_expression_3 (( EQ^ | NEQ^ | GT^ | GE^ | LT^ | LE^ | IN^ ) binary_expression_3)*;
binary_expression_3
        :       binary_expression_4 (( PLUS^ | DASH^ | APPEND^ ) binary_expression_4)*;
binary_expression_4
        :       unary_expression (( ASTERISK^ | DIV^ | MOD^ | REM^ ) unary_expression)*;


unary_expression
        :       postfix_expression
        |       primary_expression
        |       NOT^ unary_expression
        |       DASH unary_expression -> ^(NEG unary_expression)
        ;


postfix_expression
        :       (ID -> ^(PRIMARY ^(VARIABLE ID)))
                (   '(' params=expression_list ')' -> ^(CALL $postfix_expression ^(PARAMS $params))
                |   '!' field_name  -> ^(SELECTOR $postfix_expression field_name)
                )+
        ;


primary_expression
        :       primary                       -> ^(PRIMARY primary)
        |       '(' expression ')'            -> ^(PAREN expression)
        |       conditional_expression
        ;


primary
        :       TRUE^
        |       FALSE^
        |       STRING
        |       NULL^
        |       PLUS_INFINITY^
        |       MINUS_INFINITY^
        |       INT^
        |       FLOAT^
        |       ID ':' expression           -> ^(CHOICE ID expression)
        |       ID                          -> ^(VARIABLE ID)
        |       '{' '}'                     -> ^(EMPTYSTR)
        |       '{'
                MANTISSA mant=INT COMMA
                BASE bas=INT COMMA
                EXPONENT exp=INT
                '}'                         -> ^(FLOAT2 $mant $bas $exp)
        |       '{'
                named_value (COMMA named_value)*
                '}'                         -> ^(SEQUENCE named_value+)
        |       '{'
                primary (COMMA primary)*
                '}'                         -> ^(SEQOF primary+)
        |       STATE^
        ;


informal_text
        :        STRING
        ->       ^(INFORMAL_TEXT STRING)
        ;


// { a 5 } (SEQUENCE field value)
named_value
        :       ID expression
        ;


primary_params
        :      '(' expression_list ')'
        ->     ^(PARAMS expression_list)
               | '!' literal_id
        ->     ^(FIELD_NAME literal_id)
        ;


/* All cases are covered by the ground primary
   above (Except structure primary, but we favour ASN.1 notation)
extended_primary
        :       synonym         |
                indexed_primary |
                field_primary   |
                structure_primary
        ;
*/


indexed_primary
        :       primary '(' expression_list ')'
        ;


field_primary
        :       primary field_selection
        ;


structure_primary
        :       '(.' expression_list '.)'
        ;
// Removed "qualifier" from the standard
// (to be put later, but never used in practice)


active_expression
        :       active_primary
        ;


active_primary
        :       variable_access
                | operator_application
                | conditional_expression
                | imperative_operator
                | '(' active_expression ')'
                | 'ERROR'
        ;
   // active_extended_primary removed because not defined in the standard


imperative_operator
        :       now_expression
                | import_expression
                | pid_expression
                | view_expression
                | timer_active_expression
                | anyvalue_expression
        ;


timer_active_expression
        :       ACTIVE '(' timer_id ('(' expression_list ')')? ')'
        ;


anyvalue_expression
        :       ANY '(' sort ')'
        ;


sort    :       sort_id
        ->      ^(SORT sort_id)
        ;


type_inst
        :       type_id
        ->      ^(TYPE_INSTANCE type_id)
        ;


syntype :       syntype_id
        ;


import_expression
        :       IMPORT '(' remote_variable_id (',' destination)? ')'
        ;


view_expression
        :       VIEW '(' view_id (',' pid_expression)? ')'
        ;


variable_access
        :       variable_id
        ;


operator_application
        :       operator_id '('active_expression_list ')'
        ;


active_expression_list
        :       active_expression (',' expression_list)?
        ;
/* |
                ground_expression ',' active_expression_list;*/   // Will not work (recursion)


//synonym :       ID; // synonym_id | external_synonym;

external_synonym
        :       external_synonym_id
        ;


conditional_expression
        :       IF ifexpr=expression
                THEN thenexpr=expression
                ELSE elseexpr=expression FI
        ->      ^(CONDITIONAL $ifexpr $thenexpr $elseexpr)
        ;


expression_list
        :       expression (',' expression)*
        ->      expression+
        ;


terminator_statement
        :       label?
                cif?
                hyperlink?
                terminator
                end
        ->      ^(TERMINATOR label? cif? hyperlink? end? terminator)
        ;

label
        :       cif? connector_name ':'
        ->      ^(LABEL cif? connector_name)
        ;


terminator
        :       nextstate | join | stop | return_stmt
        ;


join
        :        JOIN connector_name
        ->       ^(JOIN connector_name)
        ;


stop    :       STOP
        ;


return_stmt
        :       RETURN expression?
        ->      ^(RETURN expression?)
        ;


nextstate
        :       NEXTSTATE nextstatebody
        ->      ^(NEXTSTATE nextstatebody)
        ;


nextstatebody
        :       statename via?
                | dash_nextstate
        ;


via     :       VIA state_entry_point_name
        ->      ^(VIA state_entry_point_name)
        ;


end
        :   (cif? hyperlink? COMMENT STRING)? SEMI+
        -> ^(COMMENT cif? hyperlink? STRING)?
        ;


cif
        :       cif_decl symbolname
                L_PAREN x=INT COMMA y=INT R_PAREN
                COMMA
                L_PAREN width=INT COMMA height=INT R_PAREN
                cif_end
        ->      ^(CIF $x $y $width $height)
        ;


hyperlink
        :       cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING
                cif_end
        ->      ^(HYPERLINK STRING)
        ;

/* OpenGEODE specific: SDL does not allow specifying the name
   of signal parameters, but it is needed to generate function signatures
   when generating code (in particular in Ada, where the name in the
   body must comply with the one of the source
   Extension is using CIF comment so it is invisible to other SDL parsers
   (This is valid SDL code - see ITU-T Z106)
*/
paramnames
        :       cif_decl KEEP SPECIFIC GEODE PARAMNAMES field_name+ cif_end
        ->      ^(PARAMNAMES field_name+)
        ;


/* OpenGEODE specific: Allow specifying the name of an ASN.1 file
   as a CIF extension linked to a USE clause.
   CIF Extensions are valid SDL constructs (ITU-T Z106)
*/
use_asn1
        :       cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end
        ->      ^(ASN1 STRING)
        ;


/* OpenGEODE specific: Boolean condition that can be used in simulators
*/
stop_if
        :       (STOP IF expression end)+
        ->      ^(STOPIF expression+)
        ;