--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/syntax/identifier/identifier_as_variable2.test Sat Feb 09 08:57:14 2008 +0100
@@ -0,0 +1,303 @@
+(* 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" }
+