matiec: comparison stage1

equal deleted inserted replaced

-:de518eb7bc74
+:2b6e9eeeff2c
 	/******************************************************/
 	/******************************************************/
 	/******************************************************/
-EN	return EN;
+EN	return EN;			/* Keyword */
-ENO	return ENO;
+ENO	return ENO;			/* Keyword */
 	/******************************/
 	/* B 1.2.1 - Numeric Literals */
 	/******************************/
-TRUE		return TRUE;
+TRUE		return TRUE;		/* Keyword */
-BOOL#1  	return TRUE;
+BOOL#1  	return TRUE;		/* Keyword (Data Type) + Delimiter */
-BOOL#TRUE	return TRUE;
+BOOL#TRUE	return TRUE;		/* Keyword (Data Type) + Delimiter + Keyword */
-FALSE		return FALSE;
+FALSE		return FALSE;		/* Keyword */
-BOOL#0  	return FALSE;
+BOOL#0  	return FALSE;		/* Keyword (Data Type) + Delimiter */
-BOOL#FALSE  	return FALSE;
+BOOL#FALSE  	return FALSE;		/* Keyword (Data Type) + Delimiter + Keyword */
 	/************************/
 	/* B 1.2.3.1 - Duration */
 	/************************/
-t#		return T_SHARP;
+t#		return T_SHARP;		/* Delimiter */
-T#		return T_SHARP;
+T#		return T_SHARP;		/* Delimiter */
-TIME		return TIME;
+TIME		return TIME;		/* Keyword (Data Type) */
 	/************************************/
 	/* B 1.2.3.2 - Time of day and Date */
 	/************************************/
-TIME_OF_DAY	return TIME_OF_DAY;
+TIME_OF_DAY	return TIME_OF_DAY;	/* Keyword (Data Type) */
-TOD		return TIME_OF_DAY;
+TOD		return TIME_OF_DAY;	/* Keyword (Data Type) */
-DATE		return DATE;
+DATE		return DATE;		/* Keyword (Data Type) */
-d#		return D_SHARP;
+d#		return D_SHARP;		/* Delimiter */
-D#		return D_SHARP;
+D#		return D_SHARP;		/* Delimiter */
-DATE_AND_TIME	return DATE_AND_TIME;
+DATE_AND_TIME	return DATE_AND_TIME;	/* Keyword (Data Type) */
-DT		return DATE_AND_TIME;
+DT		return DATE_AND_TIME;	/* Keyword (Data Type) */
 	/***********************************/
 	/* B 1.3.1 - Elementary Data Types */
 	/***********************************/
-BYTE		return BYTE;
+BYTE		return BYTE;		/* Keyword (Data Type) */
-WORD		return WORD;
+WORD		return WORD;		/* Keyword (Data Type) */
-DWORD		return DWORD;
+DWORD		return DWORD;		/* Keyword (Data Type) */
-LWORD		return LWORD;
+LWORD		return LWORD;		/* Keyword (Data Type) */
 	/********************************/
 	/* B 1.3.2 - Generic data types */
 	/********************************/
 	/* Strangely, the following symbols do not seem to be required! */
 	/* But we include them so they become reserved words, and do not
 	 * get passed up to bison as an identifier...
 	 */
-ANY		return ANY;
+ANY		return ANY;		/* Keyword (Data Type) */
-ANY_DERIVED	return ANY_DERIVED;
+ANY_DERIVED	return ANY_DERIVED;	/* Keyword (Data Type) */
-ANY_ELEMENTARY	return ANY_ELEMENTARY;
+ANY_ELEMENTARY	return ANY_ELEMENTARY;	/* Keyword (Data Type) */
-ANY_MAGNITUDE	return ANY_MAGNITUDE;
+ANY_MAGNITUDE	return ANY_MAGNITUDE;	/* Keyword (Data Type) */
-ANY_NUM		return ANY_NUM;
+ANY_NUM		return ANY_NUM;		/* Keyword (Data Type) */
-ANY_REAL	return ANY_REAL;
+ANY_REAL	return ANY_REAL;	/* Keyword (Data Type) */
-ANY_INT		return ANY_INT;
+ANY_INT		return ANY_INT;		/* Keyword (Data Type) */
-ANY_BIT		return ANY_BIT;
+ANY_BIT		return ANY_BIT;		/* Keyword (Data Type) */
-ANY_STRING	return ANY_STRING;
+ANY_STRING	return ANY_STRING;	/* Keyword (Data Type) */
-ANY_DATE	return ANY_DATE;
+ANY_DATE	return ANY_DATE;	/* Keyword (Data Type) */
 	/********************************/
 	/* B 1.3.3 - Derived data types */
 	/********************************/
-":="		return ASSIGN;
+":="		return ASSIGN;		/* Delimiter */
-".."		return DOTDOT;
+".."		return DOTDOT;		/* Delimiter */
-TYPE		return TYPE;
+TYPE		return TYPE;		/* Keyword */
-END_TYPE	return END_TYPE;
+END_TYPE	return END_TYPE;	/* Keyword */
-ARRAY		return ARRAY;
+ARRAY		return ARRAY;		/* Keyword */
-OF		return OF;
+OF		return OF;		/* Keyword */
-STRUCT		return STRUCT;
+STRUCT		return STRUCT;		/* Keyword */
-END_STRUCT	return END_STRUCT;
+END_STRUCT	return END_STRUCT;	/* Keyword */
 	/*********************/
 	/* B 1.4 - Variables */
 	/*********************/
-REAL		return REAL;
+REAL		return REAL;		/* Keyword (Data Type) */
-LREAL		return LREAL;
+LREAL		return LREAL;		/* Keyword (Data Type) */
-SINT		return SINT;
+SINT		return SINT;		/* Keyword (Data Type) */
-INT		return INT;
+INT		return INT;		/* Keyword (Data Type) */
-DINT		return DINT;
+DINT		return DINT;		/* Keyword (Data Type) */
-LINT		return LINT;
+LINT		return LINT;		/* Keyword (Data Type) */
-USINT		return USINT;
+USINT		return USINT;		/* Keyword (Data Type) */
-UINT		return UINT;
+UINT		return UINT;		/* Keyword (Data Type) */
-UDINT		return UDINT;
+UDINT		return UDINT;		/* Keyword (Data Type) */
-ULINT		return ULINT;
+ULINT		return ULINT;		/* Keyword (Data Type) */
-WSTRING		return WSTRING;
+WSTRING		return WSTRING;		/* Keyword (Data Type) */
-STRING		return STRING;
+STRING		return STRING;		/* Keyword (Data Type) */
-BOOL		return BOOL;
+BOOL		return BOOL;		/* Keyword (Data Type) */
-TIME		return TIME;
+TIME		return TIME;		/* Keyword (Data Type) */
-DATE		return DATE;
+DATE		return DATE;		/* Keyword (Data Type) */
-DT		return DT;
+DT		return DT;		/* Keyword (Data Type) */
-TOD		return TOD;
+TOD		return TOD;		/* Keyword (Data Type) */
-DATE_AND_TIME	return DATE_AND_TIME;
+DATE_AND_TIME	return DATE_AND_TIME;	/* Keyword (Data Type) */
-TIME_OF_DAY	return TIME_OF_DAY;
+TIME_OF_DAY	return TIME_OF_DAY;	/* Keyword (Data Type) */
 	/******************************************/
 	/* B 1.4.3 - Declaration & Initialisation */
 	/******************************************/
-VAR_INPUT	return VAR_INPUT;
+VAR_INPUT	return VAR_INPUT;	/* Keyword */
-VAR_OUTPUT	return VAR_OUTPUT;
+VAR_OUTPUT	return VAR_OUTPUT;	/* Keyword */
-VAR_IN_OUT	return VAR_IN_OUT;
+VAR_IN_OUT	return VAR_IN_OUT;	/* Keyword */
-VAR_EXTERNAL	return VAR_EXTERNAL;
+VAR_EXTERNAL	return VAR_EXTERNAL;	/* Keyword */
-VAR_GLOBAL	return VAR_GLOBAL;
+VAR_GLOBAL	return VAR_GLOBAL;	/* Keyword */
-END_VAR		return END_VAR;
+END_VAR		return END_VAR;		/* Keyword */
-RETAIN		return RETAIN;
+RETAIN		return RETAIN;		/* Keyword */
-NON_RETAIN	return NON_RETAIN;
+NON_RETAIN	return NON_RETAIN;	/* Keyword */
-R_EDGE		return R_EDGE;
+R_EDGE		return R_EDGE;		/* Keyword */
-F_EDGE		return F_EDGE;
+F_EDGE		return F_EDGE;		/* Keyword */
-AT		return AT;
+AT		return AT;		/* Keyword */
 	/***********************/
 	/* B 1.5.1 - Functions */
 	/***********************/
-FUNCTION	return FUNCTION;
+FUNCTION	return FUNCTION;	/* Keyword */
-END_FUNCTION	return END_FUNCTION;
+END_FUNCTION	return END_FUNCTION;	/* Keyword */
-VAR		return VAR;
+VAR		return VAR;		/* Keyword */
-CONSTANT	return CONSTANT;
+CONSTANT	return CONSTANT;	/* Keyword */
 	/*****************************/
 	/* B 1.5.2 - Function Blocks */
 	/*****************************/
-FUNCTION_BLOCK		return FUNCTION_BLOCK;
+FUNCTION_BLOCK		return FUNCTION_BLOCK;		/* Keyword */
-END_FUNCTION_BLOCK	return END_FUNCTION_BLOCK;
+END_FUNCTION_BLOCK	return END_FUNCTION_BLOCK;	/* Keyword */
-VAR_TEMP		return VAR_TEMP;
+VAR_TEMP		return VAR_TEMP;		/* Keyword */
-VAR			return VAR;
+VAR			return VAR;			/* Keyword */
-NON_RETAIN		return NON_RETAIN;
+NON_RETAIN		return NON_RETAIN;		/* Keyword */
-END_VAR			return END_VAR;
+END_VAR			return END_VAR;			/* Keyword */
 	/**********************/
 	/* B 1.5.3 - Programs */
 	/**********************/
-PROGRAM		return PROGRAM;
+PROGRAM		return PROGRAM;			/* Keyword */
-END_PROGRAM	return END_PROGRAM;
+END_PROGRAM	return END_PROGRAM;		/* Keyword */
 	/********************************************/
 	/* B 1.6 Sequential Function Chart elements */
 	/********************************************/
 	.* as other identifiers that may be used as variable names inside IL and ST programs.
 	 * They will have to be handled when we include parsing of SFC... For now, simply
 	 * ignore them!
 	 */
-ACTION		return ACTION;
+ACTION		return ACTION;			/* Keyword */
-END_ACTION	return END_ACTION;
+END_ACTION	return END_ACTION;		/* Keyword */
-TRANSITION	return TRANSITION;
+TRANSITION	return TRANSITION;		/* Keyword */
-END_TRANSITION	return END_TRANSITION;
+END_TRANSITION	return END_TRANSITION;		/* Keyword */
-FROM		return FROM;
+FROM		return FROM;			/* Keyword */
-TO		return TO;
+TO		return TO;			/* Keyword */
-INITIAL_STEP	return INITIAL_STEP;
+INITIAL_STEP	return INITIAL_STEP;		/* Keyword */
-STEP		return STEP;
+STEP		return STEP;			/* Keyword */
-END_STEP	return END_STEP;
+END_STEP	return END_STEP;		/* Keyword */
 	/* PRIORITY is not a keyword, so we only return it when
 	 * it is explicitly required and we are not expecting any identifiers
 	 * that could also use the same letter sequence (i.e. an identifier: piority)
 	 */
 	/********************************/
 	/* B 1.7 Configuration elements */
 	/********************************/
-CONFIGURATION		return CONFIGURATION;
+CONFIGURATION		return CONFIGURATION;		/* Keyword */
-END_CONFIGURATION	return END_CONFIGURATION;
+END_CONFIGURATION	return END_CONFIGURATION;	/* Keyword */
-TASK			return TASK;
+TASK			return TASK;			/* Keyword */
-RESOURCE		return RESOURCE;
+RESOURCE		return RESOURCE;		/* Keyword */
-ON			return ON;
+ON			return ON;			/* Keyword */
-END_RESOURCE		return END_RESOURCE;
+END_RESOURCE		return END_RESOURCE;		/* Keyword */
-VAR_CONFIG		return VAR_CONFIG;
+VAR_CONFIG		return VAR_CONFIG;		/* Keyword */
-VAR_ACCESS		return VAR_ACCESS;
+VAR_ACCESS		return VAR_ACCESS;		/* Keyword */
-END_VAR			return END_VAR;
+END_VAR			return END_VAR;			/* Keyword */
-WITH			return WITH;
+WITH			return WITH;			/* Keyword */
-PROGRAM			return PROGRAM;
+PROGRAM			return PROGRAM;			/* Keyword */
-RETAIN			return RETAIN;
+RETAIN			return RETAIN;			/* Keyword */
-NON_RETAIN		return NON_RETAIN;
+NON_RETAIN		return NON_RETAIN;		/* Keyword */
-READ_WRITE		return READ_WRITE;
+READ_WRITE		return READ_WRITE;		/* Keyword */
-READ_ONLY		return READ_ONLY;
+READ_ONLY		return READ_ONLY;		/* Keyword */
 	/* PRIORITY, SINGLE and INTERVAL are not a keywords, so we only return them when
 	 * it is explicitly required and we are not expecting any identifiers
 	 * that could also use the same letter sequence (i.e. an identifier: piority, ...)
 	 */
 	 *       different tokens for & and AND (and similarly
 	 *       ANDN and &N)!
 	 */
 /* The following tokens clash with ST expression operators and Standard Functions */
 /* They are also keywords! */
-AND		return AND;
+AND		return AND;		/* Keyword */
-MOD		return MOD;
+MOD		return MOD;		/* Keyword */
-OR		return OR;
+OR		return OR;		/* Keyword */
-XOR		return XOR;
+XOR		return XOR;		/* Keyword */
-NOT		return NOT;
+NOT		return NOT;		/* Keyword */
 /* The following tokens clash with Standard Functions */
+/* They are keywords because they are a function name */
 <il_state>{
-ADD		return ADD;
+ADD		return ADD;		/* Keyword (Standard Function) */
-DIV		return DIV;
+DIV		return DIV;		/* Keyword (Standard Function) */
-EQ		return EQ;
+EQ		return EQ;		/* Keyword (Standard Function) */
-GE		return GE;
+GE		return GE;		/* Keyword (Standard Function) */
-GT		return GT;
+GT		return GT;		/* Keyword (Standard Function) */
-LE		return LE;
+LE		return LE;		/* Keyword (Standard Function) */
-LT		return LT;
+LT		return LT;		/* Keyword (Standard Function) */
-MUL		return MUL;
+MUL		return MUL;		/* Keyword (Standard Function) */
-NE		return NE;
+NE		return NE;		/* Keyword (Standard Function) */
-SUB		return SUB;
+SUB		return SUB;		/* Keyword (Standard Function) */
 }
 /* The following tokens clash with SFC action qualifiers */
+/* They are not keywords! */
 <il_state>{
 S		return S;
 R		return R;
 }
 /* The following tokens clash with ST expression operators */
-&		return AND2;
+&		return AND2;		/* NOT a Delimiter! */
 /* The following tokens have no clashes */
+/* They are not keywords! */
 <il_state>{
 LD		return LD;
 LDN		return LDN;
 ST		return ST;
 STN		return STN;
 }
 	/***********************/
 	/* B 3.1 - Expressions */
 	/***********************/
-"**"		return OPER_EXP;
+"**"		return OPER_EXP;	/* NOT a Delimiter! */
-"<>"		return OPER_NE;
+"<>"		return OPER_NE;		/* NOT a Delimiter! */
-">="		return OPER_GE;
+">="		return OPER_GE;		/* NOT a Delimiter! */
-"<="		return OPER_LE;
+"<="		return OPER_LE;		/* NOT a Delimiter! */
-AND		return AND;
+&		return AND2;		/* NOT a Delimiter! */
-XOR		return XOR;
+AND		return AND;		/* Keyword */
-OR		return OR;
+XOR		return XOR;		/* Keyword */
-NOT		return NOT;
+OR		return OR;		/* Keyword */
-MOD		return MOD;
+NOT		return NOT;		/* Keyword */
+MOD		return MOD;		/* Keyword */
 	/*****************************************/
 	/* B 3.2.2 Subprogram Control Statements */
 	/*****************************************/
-:=		return ASSIGN;
+:=		return ASSIGN;		/* Delimiter */
-=>		return SENDTO;
+=>		return SENDTO;		/* Delimiter */
-RETURN		return RETURN;
+RETURN		return RETURN;		/* Keyword */
 	/********************************/
 	/* B 3.2.3 Selection Statements */
 	/********************************/
-IF		return IF;
+IF		return IF;		/* Keyword */
-THEN		return THEN;
+THEN		return THEN;		/* Keyword */
-ELSIF		return ELSIF;
+ELSIF		return ELSIF;		/* Keyword */
-ELSE		return ELSE;
+ELSE		return ELSE;		/* Keyword */
-END_IF		return END_IF;
+END_IF		return END_IF;		/* Keyword */
-CASE		return CASE;
+CASE		return CASE;		/* Keyword */
-OF		return OF;
+OF		return OF;		/* Keyword */
-ELSE		return ELSE;
+ELSE		return ELSE;		/* Keyword */
-END_CASE	return END_CASE;
+END_CASE	return END_CASE;	/* Keyword */
 	/********************************/
 	/* B 3.2.4 Iteration Statements */
 	/********************************/
-FOR		return FOR;
+FOR		return FOR;		/* Keyword */
-TO		return TO;
+TO		return TO;		/* Keyword */
-BY		return BY;
+BY		return BY;		/* Keyword */
-DO		return DO;
+DO		return DO;		/* Keyword */
-END_FOR		return END_FOR;
+END_FOR		return END_FOR;		/* Keyword */
-WHILE		return WHILE;
+WHILE		return WHILE;		/* Keyword */
-DO		return DO;
+DO		return DO;		/* Keyword */
-END_WHILE	return END_WHILE;
+END_WHILE	return END_WHILE;	/* Keyword */
-REPEAT		return REPEAT;
+REPEAT		return REPEAT;		/* Keyword */
-UNTIL		return UNTIL;
+UNTIL		return UNTIL;		/* Keyword */
-END_REPEAT	return END_REPEAT;
+END_REPEAT	return END_REPEAT;	/* Keyword */
-EXIT		return EXIT;
+EXIT		return EXIT;		/* Keyword */

changeset 82	2b6e9eeeff2c
parent 81	de518eb7bc74
child 83	aeb7e0e53855