why can not i match it correctly

[zrwsmd]

demo.txt
why can not i match it correctly,langium file is seen above demo.txt 。thanks a lot ,actually it st language langium file

PROGRAM r_333

VAR
a: BYTE;
b: BOOL;
c:WORD;
END_VAR

Entry rule simply this can work out well

[msujew]

What is the parser error you're seeing? Also, can you please attach more of your grammar? It looks like the Statement_list rule is in conflict with the Definition rule.

[zrwsmd]

whole grammar can be seen in above demo.txt

[msujew]

I see. Can you try removing the ? at the end of the Statement rule? Empty rules are invalid.

Also add a | between the Definition and Statement_list rule calls. Right now, a definition requires a list of statements to follow.

Note that I'm on my phone on vacation right now, so I can't help too much right now.

[zrwsmd]

seems did not work out well

[msujew]

@montymxb care to take a look at the grammar?

[montymxb]

Seems I was a bit slow to catch up to this one, thanks @ballcoach12 for lending a hand here!

[ballcoach12]

Here are some grammar changes to get you started. I broke inputs and outputs into separate lists and rules, but hopefully you can see the pattern I implemented here.

grammar StructuredText

entry StructuredTextRoot:
    'PROGRAM' name=Identifier
     inputs=Inputs_List
     outputs=Outputs_List*
     
;

Inputs_List infers InputsList: 
	'VAR_INPUT'
		((items += Var_Decl_Init))+
	'END_VAR'	
;

Outputs_List infers OutputsList:
	'VAR_OUTPUT'
		((items += Output_Var_Decl_Init))+
	'END_VAR'	
;

Output_Var_Decl_Init infers VarDeclarationInit:
	variables+=Variable_Primary (',' variables+=Variable_Primary)* ':'
	typeName=Native_Type_Name
	(':=' initialValue= (Constant | Variable_Reference))? ';'
;

Variable_Reference infers VariableReference:
	variable=[PrimaryVariable] | name=Identifier
;

Var_Decl_Init infers VarDeclarationInit: 
	variables+=Variable_Primary (',' variables+=Variable_Primary)* ':'
	typeName=Native_Type_Name 
	(':=' initialValue=Constant)? ';'
;

Variable_Primary infers PrimaryVariable:
	name=Identifier 
;

Native_Type_Name:
	NUMERIC="NUMERIC" | BOOL="BOOL" | STRING="STRING" | BYTE="BYTE" | WORD="WORD"
;

Definition:
    definition=DefinitionKeyword declarations+=Declaration (',' declarations+=Declaration)*  
;

DefinitionKeyword returns string:
    'VAR' | 'VAR_INPUT' | 'VAR_OUTPUT' | 'VAR_IN_OUT' | 'VAR_TEMP' | 'VAR_EXTERNAL' | 'VAR_GLOBAL'
;

Modifier returns string:
    'CONSTANT' | 'RETAIN'
;


Declaration:
	name=Identifier ':' datatype=DataType ';'
;

DataType returns string:
 'INT' | 'BOOL' | 'WORD' | 'BYTE'

;

Constant:
    constant= (Prefixed_integer_literal | Prefixed_bit_string_literal | Real_literal_or_signed_int | Nonprefix_integer_literal | Boolean_literal | Character_string | Time_literal);

/* Numeric constants declarations */
Signed_Integer returns number:
('+'|'-')? Integer;

Unsigned_Integer returns number:
Integer;

Nonprefix_integer_literal returns number:
(Binary_integer | Octal_integer | Hex_integer);

Prefixed_integer_literal returns number:
(Integer_type_name '#') (Signed_Integer | Binary_integer | Octal_integer | Hex_integer);

Prefixed_bit_string_literal returns number:
(Bit_string_type_name '#') (Unsigned_Integer | Binary_integer | Octal_integer | Hex_integer);

Integer_type_name returns number:
Unsigned_integer_type_name| Signed_integer_type_name ;

Signed_integer_type_name returns number:
'SINT'|'INT'|'DINT'|'LINT';

Unsigned_integer_type_name returns number:
'USINT'|'UINT'|'UDINT'|'ULINT';

Bit_string_type_name returns number:
'BYTE'|'WORD'|'DWORD'|'LWORD';

Real_type_name returns number:
'LREAL' | 'REAL';

Real_literal_or_signed_int returns number:
(Real_type_name '#')? Signed_Integer ('.' Integer (Exponent)?)?;

/* Boolean literals */
Boolean_literal returns boolean:
// should be ((BOOL '#')? ( 1 | 0)) | 'TRUE' | 'FALSE'
// FIXME how to prevent parsing 0 and 1 as digits?
('BOOL#0' | 'BOOL#1') | "TRUE" | "FALSE";

/* Character string literals  */
Character_string returns string:
Single_byte_character_string | Double_byte_character_string;

/* Time literals */
Time_literal returns string:
Duration | Time_of_day | Date_and_time | Date_type;

/* Time literals - duration  */
Duration returns string:
 ('T' | 'TIME') '#' ('-')? Interval;

Interval returns string:
Days | Hours | Minutes | Seconds | Milliseconds;

Milliseconds returns string:
(TMilliseconds);

Seconds returns string:
(TSeconds) (Milliseconds)?;

Minutes returns string:
(TMinutes) (Seconds)?;

Hours returns string:
(THours) (Minutes)?;

Days returns string:
(TDays) (Hours)?;

/* Time literals - time of the day */
Time_of_day returns string:
('TIME_OF_DAY' | 'TOD') '#' Daytime;

Daytime returns string:
Day_hour ':' Day_minute ':' Day_second;

Day_hour returns string:
Integer;

Day_minute returns string:
Integer;

Day_second returns string:
Integer ('.' Integer)?; // This is a verbose fixed point rule

Date_type returns string:
('DATE' | 'D') '#' Date_literal;

Date_literal returns string:
Year '-' Month '-' Day;

Year returns string:
Integer;

Month returns string:
Integer;

Day returns string:
Integer;

Date_and_time returns string:
('DATE_AND_TIME' | 'DT') '#' Date_literal ('-' Daytime)?;

/* Data types - elementary types */
Data_type_name returns string:
Non_generic_type_name | Generic_type_name;

Non_generic_type_name returns string:
Elementary_type_name;

/* Data types - elementary types */
Elementary_type_name returns string:
Numeric_type_name | Date_type_name | ('BOOL' | Bit_string_type_name) | 'STRING' | 'WSTRING' | 'TIME';

Numeric_type_name returns string:
Integer_type_name | Real_type_name;

Date_type_name returns string:
"DATE" | "TIME_OF_DAY" | "TOD" | "DATE_AND_TIME" | "DT";

/* Generic typename */
Generic_type_name returns string:
 'ANY' | 'ANY_DERIVED' | 'ANY_ELEMENTARY' | 'ANY_MAGNITUDE' | 'ANY_NUM' | 'ANY_REAL' | 'ANY_INT' | 'ANY_BIT' | 'ANY_STRING' | 'ANY_DATE';

/* Structured Text */
/* Expressions */
Expression:
    Or_expression;

Or_expression infers Expression:
    Xor_expression ({infer BinaryExpression.left=current} operator=('OR') right=Xor_expression)*;

Xor_expression infers Expression:
    And_expression ({infer BinaryExpression.left=current} operator=('XOR') right=And_expression)*;

And_expression infers Expression:
    Comparison_expression ({infer BinaryExpression.left=current} operator=('AND' | '&') right=Comparison_expression)*;

Comparison_expression infers Expression:
    Equ_expression ({infer BinaryExpression.left=current} operator=( '<>' | '=') right=Equ_expression)*;

Equ_expression infers Expression:
    Add_expression ({infer BinaryExpression.left=current} operator=('<=' | '>=' | '<' | '>')  right=Add_expression)*;

Add_expression infers Expression:
    Term ({infer BinaryExpression.left=current} operator=('+' | '-')  right=Term)*;

Term infers Expression:
    Power_expression ({infer BinaryExpression.left=current} operator=('*' | '/' | 'MOD' )  right=Power_expression)*;

Power_expression infers Expression:
    Unary_expression ({infer BinaryExpression.left=current} operator=('**')  right=Unary_expression)*;

Unary_expression infers Expression:
    {infer BinaryExpression.left=current}  operator=('-' | 'NOT')? right=Primary_Expression;

// primary_expression = constant | enumerated_value | variable | "(" expression ")" | function_name "(" param_assignment {"," param_assignment} ")";
Primary_Expression infers Expression:
value =  Constant
| '(' Expression=Expression ')'
| (name=Function_name params=Invoke_subrule)
| variable=Variable;

/* ST statements */
Statement_list:
statements+=Statement (statements+=Statement)*;

Statement:
((Selection_statement | Function_invoke_or_assign_statement | Action_call_statement | Iteration_statement) ';' )? ;

Action_call_statement:
actionName=Identifier;

Function_name returns string:
Identifier;

Function_invoke_or_assign_statement:
statement=(Function_invoke_or_assign | 'RETURN');

Function_invoke_or_assign:
id=Variable (assign=Assignment_subrule | params+=Invoke_subrule);

Assignment_statement:
statement=Variable ':=' expression=Expression ';';

Assignment_subrule:
':=' expression=Expression;

Invoke_subrule:
'(' (parameters+=Param_assignment (',' parameters+=Param_assignment)*)?  ')';

Param_assignment:
(ParamName=Variable_name ':=')? ParamValue=Expression;

/* Selection statements */
//selection_statement = if_statement | case_statement;
Selection_statement:
if=If_statement| case=Case_statement;

//if_statement = "IF" expression "THEN" statement_list {"ELSIF" expression "THEN" statement_list} ["ELSE" statement_list] "END_IF";
If_statement:
'IF' ifCondition=Expression 'THEN' ifStatement=Statement_list ('ELSIF' elsifConditions+=Expression 'THEN' elsifStatements=Statement_list)* ('ELSE' elseStatement=Statement_list)? 'END_IF';

//case_statement = "CASE" expression "OF" case_element {case_element} ["ELSE" statement_list] "END_CASE";
Case_statement:
'CASE' caseExpression=Expression 'OF' caseElements+=Case_element (caseElements+=Case_element)* ('ELSE' elseStatements=Statement_list)? 'END_CASE';

//case_element = case_list ":" statement_list;
Case_element:
caseList=Case_list ':' statements=Statement_list;

//case_list = case_list_element {"," case_list_element};
Case_list:
caseListElement+=Case_list_element (',' caseListElement+=Case_list_element)*;

//case_list_element = subrange | signed_integer | enumerated_value;
Case_list_element:
(numCaseStart=Signed_Integer ('..' numericCaseEnd+=Signed_Integer)?) | (enumCase=IdentifierEnumeratedCase);

/* Iteration statements */
Iteration_statement:
statement=(For_statement | While_statement | Repeat_statement | 'EXIT');

For_statement:
'FOR' controlVariable=Identifier ':=' forList=For_list 'DO' statementList=Statement_list 'END_FOR';

For_list:
forExpr=Expression 'TO' toExpr=Expression ('BY' byExpr=Expression)?;

While_statement:
'WHILE' whileExpr=Expression 'DO' statementList=Statement_list 'END_WHILE';

Repeat_statement:
'REPEAT' statementList=Statement_list 'UNTIL' untilExpr=Expression 'END_REPEAT';


/* Derived typename */

//variable = direct_variable | symbolic_variable;
Variable:
variable=(Direct_variable | Variable_any_symbolic);

//location_prefix = "I" | "Q" | "M";
//size_prefix = NIL | "X" | "B" | "W" | "D" | "L";
//direct_variable = "%" location_prefix size_prefix integer {"." integer};
Direct_variable returns string:
Direct_variable_prefix Integer ('.' Integer)?;

// symbolic_variable = variable_name | multi_element_variable;
// Variable_any_symbolic parses Multi-element variables and variable_name
Variable_any_symbolic:
variable=Variable_basic ('.' structureMember=Variable_basic)*;

Variable_basic:
variable=Identifier (subscript=Subscript_list)?;

//variable_name = identifier;
Variable_name returns string:
Identifier;

//subscript_list = "[" subscript {"," subscript} "]";
Subscript_list:
'[' Subscript (',' Subscript)* ']';

//subscript = expression;
Subscript infers Expression:
Expression;

terminal Identifier: /[_a-zA-Z][\w_]*/;


// numeric tokens
terminal fragment Exponent_prefix : /[Ee]/;
terminal Exponent: Exponent_prefix ('+'|'-')? Integer;
terminal Binary_integer: /\b2#(0|1)(0|1|(_))*\b/;
terminal Hex_integer: /\b16#([0-9aAbBcCdDeEfF])([0-9aAbBcCdDeEfF]|(_))*\b/;
terminal Octal_integer: /\b8#([0-7])([0-7]|(_))*\b/;
// string tokens
terminal Single_byte_character_string: /(')(\\.|[^'])*(')/;
terminal Double_byte_character_string: /(")(\\.|[^"])*(")/;
// time tokens
terminal TMilliseconds: (Underscore)? Fixed_point /[mM][sS]/;
terminal TMinutes: (Underscore)? Fixed_point /[mM]/;
terminal TSeconds: (Underscore)? Fixed_point /[sS]/;
terminal TDays: (Underscore)? Fixed_point /[dD]/;
terminal THours: Fixed_point /[hH]/;

// identifier characters
terminal fragment Underscore: /_/;
terminal fragment Letters: /[a-zA-Z]+/;
terminal fragment Digits: /[0-9]+/;
terminal fragment Fixed_point : Integer ('.' Integer)?;
terminal fragment Location_prefix: ('I' | 'Q' | 'M');
terminal fragment Size_prefix: ('X' | 'B' | 'W' | 'D' | 'L');
terminal Direct_variable_prefix: '%' Location_prefix Size_prefix;
terminal Integer: Digits ((Underscore)? Digits)*;
// hack - IdentifierEnumeratedCase uses positive lookahead for "," and ":"
terminal IdentifierEnumeratedCase: ((Underscore (Digits | Letters))| Letters) ((Underscore)? (Digits | Letters))*
/(?=(,\s*([_A-Za-z]\w*|([+\-]?[0-9][0-9_]*\s*(\.\.\s*[+\-]?[0-9][0-9_]*)?))\s*)*\:\s+)/;

// hidden
hidden terminal WS: /\s+/;
hidden terminal ML_COMMENT: /\/\*[\s\S]*?\*\//;
hidden terminal ML_COMMENT_ST: /\(\*[\s\S]*?\*\)/;
hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;