Other Language - Writing a Structured Text IEC 61131-3 Compiler

TYPE
    MY_ARRAY : ARRAY[1..10] OF INT;
END_TYPE

PROGRAM TEST
	VAR
		B: MY_ARRAY;  // THIS IS THE PROBLEM
		I,J,K: INT;
		A: INT;
	END_VAR
A:=B[I+J];
END_PROGRAM

var1_init_decl:
    var1_list ':' spec_init_opt
		{ $$ = opr(VAR1_INIT_DECL,2,$1,$3);
		printf("\nAllocate Here!\n\n"); }
	;

// in the Flex file
{identifier}	    {	yylval.sIndex = HashId(yytext,&used);
			if ( SymTbl[yylval.sIndex].type >= TYP_LAST )
				switch ( TypTbl[SymTbl[yylval.sIndex].type].GenType )
				{
				case SimpleEnum:
					return ID_SIMPLE;
				break;
				case SubRngEnum:
					return ID_SUBRNG;
				break;
				case EnumEnum:
					return ID_ENUM;
				break;
				case ArrayEnum:
					return ID_ARRAY;
				break;
				case StructEnum:
					return ID_STRUCT;
				break;	
				case FCEnum:
					return ID_FC;
				break;
				case FBEnum:
				return ID_FB;
				break;
			        }
			else
				return IDENTIFIER;
		}

// in the Bison file				
				
single_element_type_name:				// <nPtr>
		simple_type_name				{ $$ = $1; }
	|	subrange_type_name				{ $$ = $1; }
	|	enumerated_type_declaration		{ $$ = $1; }
	;

simple_type_name:						// <nPtr>
		IDENTIFIER						{ $$ = opr(SIMPLE_TYPE_NAME,1,id($1)); }
	|	ID_SIMPLE						{ $$ = opr(SIMPLE_TYPE_NAME,1,id($1)); }
	;
	
subrange_type_name:						// <nPtr>
		IDENTIFIER						{ $$ = opr(SUBRANGE_TYPE_NAME,1,id($1)); }
	|	ID_SUBRNG						{ $$ = opr(SUBRANGE_TYPE_NAME,1,id($1)); }
	;
	
enumerated_type_name:					// <nPtr>
		IDENTIFIER						{ $$ = opr(ENUMERATED_TYPE_NAME,1,id($1)); }	
	|	ID_ENUM							{ $$ = opr(ENUMERATED_TYPE_NAME,1,id($1)); }	
	; 	
		
array_type_name:						// <nPtr>
		IDENTIFIER						{ $$ = opr(ARRAY_TYPE_NAME,1,id($1)); }
	|	ID_ARRAY						{ $$ = opr(ARRAY_TYPE_NAME,1,id($1)); }
	;
		
structure_type_name:					// <nPtr>
		IDENTIFIER						{ $$ = opr(STRUCTURE_TYPE_NAME,1,id($1)); }
	|	ID_STRUCT						{ $$ = opr(STRUCTURE_TYPE_NAME,1,id($1)); }
	;

var1_init_decl:
	var1_list ':' spec_init_opt
										{ $$ = opr(VAR1_INIT_DECL,2,$1,$3);
											printf("\nAllocate Here!\n\n"); }
	;

var1_list:
		variable_name					{ $$ = $1; }
	|	var1_list ',' variable_name		{ $$ = opr(VAR1_LIST,2,$1,$3); }
	;

array_var_init_decl:
		var1_list ':' array_spec_init	{ $$ = opr(ARRAY_VAR_INIT_DECL,2,$1,$3); }
	;
	
spec_init_opt:
		simple_spec_init				{ $$ = $1; }
	|	subrange_spec_init				{ $$ = $1; }
	|	enumerated_spec_init			{ $$ = $1; }
	;		

Lexer:

Treat names of data types like "INT" as "INDENTIFIER".


Parser:

data-type
    = IDENTIFIER
      { SimpleType( $1 ) }
    | ARRAY [ INTEGER .. INTEGER ] OF IDENTIFIER
      { ArrayType( $3, $1, $2 ) }


Semantic Analyser:

make-variable( symbol, data-type )
    case data-type of
        SimpleType( id ):
            if built-in-data-types contains id
                allocate( symbol, built-in-data-type(id) )
            else if user-data-types contains id
                make-variable( symbol, user-data-type(id) )
            else
                error "Undefined data type"
        ArrayType( base-type, start, end ):
            if built-in-data-types contains base-type
                allocate-array( symbol, built-in-data-type(id), start, end )
            else if user-data-types contains base-type
                make-variable( symbol, ArrayType( base-type, start, end ) )
            else
                error "Undefined data type"