Finish support for semantic verification of IL paranthesised expressions.
(* Test whether the keyword XXXX may be used as an identifier for:
* variable name/identifier
*
* The XXXX names in the following code are merely a placeholder.
* They will be replaced by several identifiers before actual testing
* of the compiler.
*)
(* The identifiers that will replace the XXXX
* must be placed on a line starting with #
* All identifiers preceded by # are ignored!
* The identifier list must be placed inside an IEC 61131-3 comment.
*)
(* This file is specific for identifiers NOT identical to IL operators.
* See the note following the identifier list
*)
(*
#IL_operators #ANDN #CAL #CALC #CALCN #CD #CLK #CU #IN #JMP #JMPC #JMPCN #LD #LDN #ORN
#IL_operators #PT #PV #R #R1 #RET #RETC #RETCN #S #S1 #ST #STN #XORN
NOTE: R and S are identical to IL operators!!
#SFC_qualifiers D DS L N P #R #S SD SL
#Task_initialisers PRIORITY SINGLE INTERVAL
*)
(* NOTE: The identifier as a variable test has some special cases.
* Namely, when using IL operators as variable names.
* Even though the syntax of the IL language would not result
* in ambiguities in the above case, our parser does not currently
* allow the use of variables (with names identical to IL
* operators) within IL code.
*
* The following test code must therefore consider two possibilities:
* - if the identifier under test is an IL operator
* - if the identifier under test is not an IL operator
*)
(* A helper FUNCTION BLOCK declaration *)
function_block foo_fb
var_input
a_1, b_1: int;
end_var
var_output
c_1, d_1: int;
end_var
c_1 := 10 + b_1;
end_function_block
(* A helper FUNCTION declaration *)
function foo_f1 : int
var_input
a_1, b_1: int;
end_var
var_output
c_1, d_1: int;
end_var
c_1 := 10 + b_1;
end_function
(* Another helper FUNCTION declaration *)
function foo_f2 : int
var_input
a_1, b_1: foo_fb;
end_var
var_output
c_1, d_1: int;
end_var
c_1 := 10;
end_function
(* Another helper FUNCTION declaration *)
function bar01 : int
var_input
XXXX, a_1, b_1: int;
end_var
a_1 := 1;
end_function
(* Another helper FUNCTION_BLOCK declaration *)
function_block bar91
var
e_1, f_1 : int;
XXXX : foo_fb;
end_var
e_1 := 0;
end_function_block
(* Using XXXX as a standard variable name in IL *)
(* NOTE: Currently not supported for identifiers identical to IL operators.
* We therefore have two versions of this file, one with the following code
* commented out (used to test the identifiers that clash with IL operators)
* and a second with the following code included (used to test identifiers
* that do not clash with IL operators, such as PRIORITY, SINGLE, etc...)
*)
function_block bar92
var
e_1, f_1 : int;
XXXX : bool;
fb : foo_fb;
fb2 : bar91;
end_var
(* IL operators that - acording to the standard - are not keywords *)
LD XXXX
LDN XXXX
ANDN XXXX
ORN XXXX
XORN XXXX
R XXXX
S XXXX
ST XXXX
STN XXXX
(* IL operators that - acording to the standard - are also keywords *)
AND XXXX
OR XXXX
XOR XXXX
NOT XXXX
end_function_block
function_block bar93
var
e_1, f_1 : int;
XXXX : int;
end_var
(* IL operators that - acording to the standard - are also keywords *)
ADD XXXX
SUB XXXX
MUL XXXX
DIV XXXX
MOD XXXX
GE XXXX
GT XXXX
LE XXXX
LT XXXX
EQ XXXX
NE XXXX
(* Calling function with input parameter named XXXX *)
bar01 (
XXXX := 10
)
bar01 (
a_1 := XXXX
)
bar01 (
XXXX := XXXX
)
end_function_block
(* a helper function block *)
function_block bar94
var_input
e_1, f_1 : int;
XXXX : foo_fb;
end_var
e_1 := XXXX.c_1;
end_function_block
function_block bar95
var
e_1, f_1 : int;
XXXX : foo_fb;
fb_1 : bar93;
end_var
CAL XXXX(10)
CAL XXXX (e_1)
CAL XXXX (10, e_1, e_1, f_1)
CAL XXXX (
a_1 := 10,
b_1 := e_1,
c_1 => e_1,
d_1 => f_1
)
CAL XXXX (
a_1 := 10,
c_1 => e_1
)
CALC XXXX(10)
CALC XXXX (e_1)
CALC XXXX (10, e_1, e_1, f_1)
CALC XXXX (
a_1 := 10,
b_1 := e_1,
c_1 => e_1,
d_1 => f_1
)
CALC XXXX (
a_1 := 10,
c_1 => e_1
)
CALCN XXXX(10)
CALCN XXXX (e_1)
CALCN XXXX (10, e_1, e_1, f_1)
CALCN XXXX (
a_1 := 10,
b_1 := e_1,
c_1 => e_1,
d_1 => f_1
)
CALCN XXXX (
a_1 := 10,
c_1 => e_1
)
LD XXXX.a_1
ST XXXX.b_1
LD fb_1.XXXX
ST fb_1.XXXX
LD fb_1.XXXX.a_1
ST fb_1.XXXX.a_1
LD XXXX
foo_f2 XXXX, e_1, f_1
foo_f2 (
a_1 := XXXX,
b_1 := XXXX,
c_1 => e_1,
d_1 => f_1
)
(* Calling function with input parameter named XXXX *)
bar01 (
XXXX := 10
)
bar01 (
a_1 := XXXX.a_1
)
bar01 (
XXXX := XXXX.a_1
)
end_function_block
function_block bar96
var
e_1, f_1 : int;
XXXX : CTUD;
end_var
CU XXXX
CD XXXX
PV XXXX
end_function_block
function_block bar97
var
e_1, f_1 : int;
XXXX : R_TRIG;
end_var
CLK XXXX
end_function_block
function_block bar98
var
e_1, f_1 : int;
XXXX : TP;
end_var
IN XXXX
PT XXXX
end_function_block
function_block bar99
var
e_1, f_1 : int;
XXXX : SR;
end_var
R1 XXXX
S1 XXXX
end_function_block
(* Checking whether the use of XXXX will confuse any other
* normal and correct IL or ST code.
*)
{#include "basic_code.test" }