c2iec

891 lines (776 with data), 19.4 kB

%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token XOR_ASSIGN OR_ASSIGN TYPE_NAME

%token TYPEDEF EXTERN STATIC AUTO REGISTER INLINE RESTRICT
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token BOOL COMPLEX IMAGINARY
%token STRUCT UNION ENUM ELLIPSIS

%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN

%union { char str[4096]; }

%start translation_unit

%{
#include <string.h>
#include <stdio.h>

// get tail of a string
#define TAIL(str) (&str[strlen(str)])


/* fifo to store expression strings */
#define STMT_SIZE 128
#define FIFO_SIZE 20

typedef enum
{
	decl_all,
	decl_inout,
	decl_var,
	fifo_entry_num /* reflects the number of enum entries */
} fifo_entry_t;

typedef struct
{
	char fifo[FIFO_SIZE][STMT_SIZE];
	unsigned int read;
	unsigned int write;
} fifo_t;

static fifo_t s_fifos[fifo_entry_num];
void yyerror(char const *s);

// push an entry (typically a declaration into the fifo
void fifo_push(fifo_entry_t type, const char *psz);

// pop one entry from the specific category
char *fifo_pop(fifo_entry_t type);
char *lifo_pop(fifo_entry_t type);

// tag all from category "all" to new type
// this way we can collect new stuff in all and push
// it to the correct section when we know more about
// our context
void fifo_tag(fifo_entry_t type);

// map c datatype to iec (standard and userdefined)
char *maptype(char *ctype);

// get identifier from payload data
// when used e.g. with the declarator of a struct,
// the name is reproducable
char *genIdentifier(char *szData);

// convert input string to upper case
char *strUpper(char *szStr);

// terminate string after identifier boundary
char *strIdentifier(char *szStr);

// add symbol name to symbol table
#define SYM_SIZE 64
#define SYM_COUNT 64
int s_iSymTabCount = 0;
static char s_szSymTab[SYM_COUNT][SYM_SIZE];
void addSym(char *szSym);
int isSym(char *szSym);

// lex/yacc functions
extern int yylex (void);
%}

%%

primary_expression
	: IDENTIFIER
	| CONSTANT
	| STRING_LITERAL
	| '(' expression ')'
	{ sprintf($<str>$, "( %s )",$<str>2); }
	;

postfix_expression
	: primary_expression
	{ sprintf($<str>$, "%s",$<str>1); }
	| postfix_expression '[' expression ']'
	{ sprintf($<str>$, "[%s]",$<str>2); }
	| postfix_expression '(' ')'
	{ sprintf($<str>$, "%s()",$<str>1); }
	| postfix_expression '(' argument_expression_list ')'
	{ sprintf($<str>$, "%s(%s)",$<str>1, $<str>3); }
	| postfix_expression '.' IDENTIFIER
	{ sprintf($<str>$, "%s.%s",$<str>1,$<str>3); }
	| postfix_expression PTR_OP IDENTIFIER
	{ sprintf($<str>$, "%s %s %s",$<str>1, $<str>2, $<str>3);}
	| postfix_expression INC_OP
	{ sprintf($<str>$, "((%s:=%s+1)-1)",$<str>1, $<str>1); }
	| postfix_expression DEC_OP
	{ sprintf($<str>$, "((%s:=%s-1)+1)",$<str>1, $<str>1); }
	| '(' type_name ')' '{' initializer_list '}'
	| '(' type_name ')' '{' initializer_list ',' '}'
	;

argument_expression_list
	: assignment_expression
	| argument_expression_list ',' assignment_expression
	{ sprintf($<str>$, "%s, %s",$<str>1, $<str>3); }
	;

unary_expression
	: postfix_expression
	| INC_OP unary_expression
	{ sprintf($<str>$, "(%s:=%s+1)",$<str>2, $<str>2); }
	| DEC_OP unary_expression
	{ sprintf($<str>$, "(%s:=%s-1)",$<str>2, $<str>2); }
	| unary_operator cast_expression
	{ sprintf($<str>$, "%s^",$<str>2); }
	| SIZEOF unary_expression
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	| SIZEOF '(' type_name ')'
	{ sprintf($<str>$, "%s (%s)",$<str>1, $<str>3); }
	;

unary_operator
	: '&'
	| '*'
	| '+'
	| '-'
	| '~'
	| '!'
	;

cast_expression
	: unary_expression
	| '(' type_name ')' cast_expression
	{ sprintf($<str>$, "ANY_TO_%s(%s)",$<str>2, $<str>4); }
	;

multiplicative_expression
	: cast_expression
	| multiplicative_expression '*' cast_expression
	{ sprintf($<str>$, "%s * %s",$<str>1, $<str>3); }
	| multiplicative_expression '/' cast_expression
	{ sprintf($<str>$, "%s / %s",$<str>1, $<str>3); }
	| multiplicative_expression '%' cast_expression
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>3); }
	;

additive_expression
	: multiplicative_expression
	| additive_expression '+' multiplicative_expression
	{ sprintf($<str>$, "%s + %s",$<str>1, $<str>3); }
	| additive_expression '-' multiplicative_expression
	{ sprintf($<str>$, "%s - %s",$<str>1, $<str>3); }
	;

shift_expression
	: additive_expression
	| shift_expression LEFT_OP additive_expression
	{ sprintf($<str>$, "SHL(%s, %s)",$<str>1, $<str>3); }
	| shift_expression RIGHT_OP additive_expression
	{ sprintf($<str>$, "SHR(%s, %s)",$<str>1, $<str>3); }
	;

relational_expression	: shift_expression
	| relational_expression '<' shift_expression
	{ sprintf($<str>$, "%s < %s",$<str>1, $<str>3); }
	| relational_expression '>' shift_expression
	{ sprintf($<str>$, "%s > %s",$<str>1, $<str>3); }
	| relational_expression LE_OP shift_expression
	{ sprintf($<str>$, "%s <= %s",$<str>1, $<str>3); }
	| relational_expression GE_OP shift_expression
	{ sprintf($<str>$, "%s >= %s",$<str>1, $<str>3); }
	;

equality_expression
	: relational_expression
	| equality_expression EQ_OP relational_expression
	{ sprintf($<str>$, "%s = %s",$<str>1, $<str>3); }
	| equality_expression NE_OP relational_expression
	{ sprintf($<str>$, "%s <> %s",$<str>1, $<str>3); }
	;

and_expression
	: equality_expression
	| and_expression '&' equality_expression
	{ sprintf($<str>$, "%s AND %s",$<str>1, $<str>3); }
	;

exclusive_or_expression
	: and_expression
	| exclusive_or_expression '^' and_expression
	{ sprintf($<str>$, "%s XOR %s",$<str>1, $<str>3); }
	;

inclusive_or_expression
	: exclusive_or_expression
	| inclusive_or_expression '|' exclusive_or_expression
	{ sprintf($<str>$, "%s OR %s",$<str>1, $<str>3); }
	;

logical_and_expression
	: inclusive_or_expression
	| logical_and_expression AND_OP inclusive_or_expression
	{ sprintf($<str>$, "%s AND %s",$<str>1, $<str>3); }
	;

logical_or_expression
	: logical_and_expression
	| logical_or_expression OR_OP logical_and_expression
	{ sprintf($<str>$, "%s OR %s",$<str>1, $<str>3); }
	;

conditional_expression
	: logical_or_expression
	| logical_or_expression '?' expression ':' conditional_expression
	;

assignment_expression
	: conditional_expression
	| unary_expression assignment_operator assignment_expression
	{ sprintf($<str>$, "%s %s %s",$<str>1, $<str>2, $<str>3); }
	;

assignment_operator
	: '='
	{ sprintf($<str>$, ":="); }
	| MUL_ASSIGN
	| DIV_ASSIGN
	| MOD_ASSIGN
	| ADD_ASSIGN
	| SUB_ASSIGN
	| LEFT_ASSIGN
	| RIGHT_ASSIGN
	| AND_ASSIGN
	| XOR_ASSIGN
	| OR_ASSIGN
	;

expression
	: assignment_expression
	| expression ',' assignment_expression
	;

constant_expression
	: conditional_expression
	;

declaration
	: declaration_specifiers ';'
	{ sprintf($<str>$, "%s %s\n",$<str>1, $<str>2); }
	| TYPEDEF declaration_specifiers init_declarator_list ';'
	{
		char *p;
		while( (p=fifo_pop(decl_all)) != NULL)
			/* noop */;

		printf("TYPE ");
		printf($<str>3, $<str>2);
		addSym(strIdentifier($<str>3));
		printf("END_TYPE\n\n");
		strcpy($<str>$, "");
	}
	| declaration_specifiers init_declarator_list ';'
	{
		char *p;
		while( (p=fifo_pop(decl_all)) != NULL)
		{
//			sprintf(TAIL($<str>$), p, $<str>1);
			printf(p, $<str>1);
			strcpy($<str>$, "");
		}
	}
	;

declaration_specifiers
	: storage_class_specifier
	| storage_class_specifier declaration_specifiers
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	| type_specifier
	{
		sprintf($<str>$, "%s",maptype($<str>1));
	}
	| type_specifier declaration_specifiers
	{
		sprintf($<str>$, "%s %s",$<str>1, $<str>2);
		sprintf($<str>$, "%s",maptype($<str>$));
	}
	| type_qualifier
	| type_qualifier declaration_specifiers
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	| function_specifier
	| function_specifier declaration_specifiers
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	;

init_declarator_list
	: init_declarator
	| init_declarator_list ',' init_declarator
	{ sprintf($<str>$, "%s, %s",$<str>1, $<str>3); }
	;

init_declarator
	: declarator
	| declarator '=' initializer
	{ sprintf($<str>$, "%s = %s",$<str>1, $<str>3); }
	;

storage_class_specifier
	: TYPEDEF
	| EXTERN
	| STATIC
	| AUTO
	| REGISTER
	;

type_specifier
	: VOID
	| CHAR
	| SHORT
	| INT
	| LONG
	| FLOAT
	| DOUBLE
	| SIGNED
	| UNSIGNED
	| BOOL
	| COMPLEX
	| IMAGINARY
	| struct_or_union_specifier
	| enum_specifier
	| TYPE_NAME
	;

struct_or_union_specifier
	: struct_or_union IDENTIFIER '{' struct_declaration_list '}'
	{
		printf("TYPE %s:\n%s\n %s\nEND_STRUCT\nEND_TYPE\n\n", $<str>2, strUpper($<str>1), $<str>4);
		strcpy($<str>$, $<str>2);
	}
	| struct_or_union '{' struct_declaration_list '}'
	{
		char *szTypeName = genIdentifier($<str>3);
		printf("TYPE %s:\n%s\n %s\nEND_STRUCT\nEND_TYPE\n\n", szTypeName, strUpper($<str>1), $<str>3);
		strcpy($<str>$, szTypeName);
	}
	| struct_or_union IDENTIFIER
	;

unnamed_struct_or_union_specifier
	: struct_or_union '{' struct_declaration_list '}'
	{
		strcpy($<str>$, $<str>3);
	}
	;

struct_or_union
	: STRUCT
	| UNION
	;

struct_declaration_list
	: struct_declaration
	| struct_declaration_list struct_declaration
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	;

struct_declaration
	: specifier_qualifier_list struct_declarator_list ';'
	{
		char *p;
		while( (p=fifo_pop(decl_all)) != NULL)
		{
			strcpy($<str>$, "");
			sprintf(TAIL($<str>$), p, $<str>1);
//			printf(p, $<str>1);
//			strcpy($<str>$, "");
		}
	}
	| unnamed_struct_or_union_specifier ';'
	;

// as a lexxer hack, I added a special case for typedefs
// to the declaration rule
specifier_qualifier_list
	: TYPEDEF type_specifier specifier_qualifier_list
	{ sprintf($<str>$, "lexxer hack - typedef found\n"); }

specifier_qualifier_list
	: type_specifier specifier_qualifier_list
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	| type_specifier
	{
		strcpy($<str>$, maptype($<str>1));
	}
	| type_qualifier specifier_qualifier_list
	{
		sprintf($<str>$, "%s %s",$<str>1, $<str>2);
		sprintf($<str>$, "%s",maptype($<str>$));
	}
	| type_qualifier
	;

struct_declarator_list
	: struct_declarator
	| struct_declarator_list ',' struct_declarator
	{ sprintf($<str>$, "%s, %s",$<str>1, $<str>3); }
	;

struct_declarator
	: declarator
	| ':' constant_expression
	| declarator ':' constant_expression
	;

enum_specifier
	: ENUM '{' enumerator_list '}'
	| ENUM IDENTIFIER '{' enumerator_list '}'
	| ENUM '{' enumerator_list ',' '}'
	| ENUM IDENTIFIER '{' enumerator_list ',' '}'
	| ENUM IDENTIFIER
	;

enumerator_list
	: enumerator
	| enumerator_list ',' enumerator
	;

enumerator
	: IDENTIFIER
	| IDENTIFIER '=' constant_expression
	;

type_qualifier
	: CONST
	| RESTRICT
	| VOLATILE
	;

function_specifier	: INLINE
	;

declarator
	: pointer direct_declarator
	{ 
		sprintf($<str>$, "%s: POINTER TO %%s;\n",$<str>2);
		fifo_push(decl_all, $<str>$);
	}
	| direct_declarator
	{
		if (strlen($<str>1) > 0)
		{
			sprintf($<str>$, "%s: %%s;\n",$<str>1);
			fifo_push(decl_all, $<str>$);
		}
	}
	;

direct_declarator
	: IDENTIFIER
//	{ sprintf($<str>$, "%s: %%s;\n",$<str>1); fifo_push($<str>$);}
	| '(' declarator ')'
	| direct_declarator '[' type_qualifier_list assignment_expression ']'
	| direct_declarator '[' type_qualifier_list ']'
	| direct_declarator '[' assignment_expression ']'
	{
		if (strlen($<str>1) > 0)
		{
			sprintf($<str>$, "%s: ARRAY[0..(%s-1)] OF %%s;\n",$<str>1, $<str>3);
		}
		else
		{
			char *p;
			p = lifo_pop(decl_all);
			sprintf($<str>1, ",0..(%s-1)] OF %%s;\n",$<str>3);
			strcpy($<str>$, p);
			strcpy(strchr($<str>$, ']'), $<str>1);
//			sprintf($<str>$, p, $<str>1);
		}
		fifo_push(decl_all, $<str>$);
		strcpy($<str>$, "");
	}
	| direct_declarator '[' STATIC type_qualifier_list assignment_expression ']'
	| direct_declarator '[' type_qualifier_list STATIC assignment_expression ']'
	| direct_declarator '[' type_qualifier_list '*' ']'
	| direct_declarator '[' '*' ']'
	| direct_declarator '[' ']'
	| direct_declarator '(' parameter_type_list ')'
	{
		sprintf($<str>$, "FUNCTION %s:",$<str>1);
		fifo_push(decl_all, $<str>$);
		strcpy($<str>$, "");
	}
	| direct_declarator '(' identifier_list ')'
	{
		sprintf($<str>$, "FUNCTION %s:",$<str>1);
		fifo_push(decl_all, $<str>$);
		strcpy($<str>$, "");
	}
	| direct_declarator '(' ')'
	{
		sprintf($<str>$, "FUNCTION %s:",$<str>1);
		fifo_push(decl_all, $<str>$);
		strcpy($<str>$, "");
	}
	;

pointer
	: '*'
	| '*' type_qualifier_list
	| '*' pointer
	| '*' type_qualifier_list pointer
	;

type_qualifier_list
	: type_qualifier
	| type_qualifier_list type_qualifier
	;


parameter_type_list
	: parameter_list
	| parameter_list ',' ELLIPSIS
	;

parameter_list
	: parameter_declaration
	| parameter_list ',' parameter_declaration
	;

parameter_declaration
	: declaration_specifiers declarator
	| declaration_specifiers abstract_declarator
	| declaration_specifiers
	;

identifier_list
	: IDENTIFIER
	| identifier_list ',' IDENTIFIER
	;

type_name
	: specifier_qualifier_list
	| specifier_qualifier_list abstract_declarator
	;

abstract_declarator
	: pointer
	| direct_abstract_declarator
	| pointer direct_abstract_declarator
	;

direct_abstract_declarator
	: '(' abstract_declarator ')'
	| '[' ']'
	| '[' assignment_expression ']'
	| direct_abstract_declarator '[' ']'
	| direct_abstract_declarator '[' assignment_expression ']'
	| '[' '*' ']'
	| direct_abstract_declarator '[' '*' ']'
	| '(' ')'
	| '(' parameter_type_list ')'
	| direct_abstract_declarator '(' ')'
	| direct_abstract_declarator '(' parameter_type_list ')'
	;

initializer
	: assignment_expression
	| '{' initializer_list '}'
	| '{' initializer_list ',' '}'
	;

initializer_list
	: initializer
	| designation initializer
	| initializer_list ',' initializer
	| initializer_list ',' designation initializer
	;

designation
	: designator_list '='
	;

designator_list
	: designator
	| designator_list designator
	;

designator
	: '[' constant_expression ']'
	| '.' IDENTIFIER
	;

statement
	: labeled_statement
	| compound_statement
	| expression_statement
	| selection_statement
	| iteration_statement
	| jump_statement
	;

labeled_statement
	: IDENTIFIER ':' statement
	| CASE constant_expression ':' statement
	{ sprintf($<str>$, "%s:\n %s",$<str>2, $<str>4); }
	| DEFAULT ':' statement
	{ sprintf($<str>$, "\nELSE:\n %s",$<str>3); }
	;

compound_statement
	: '{' '}'
	| '{' block_item_list '}'
	{ sprintf($<str>$, "%s",$<str>2); }
	;

block_item_list
	: block_item
	| block_item_list block_item
	{ sprintf($<str>$, "%s %s",$<str>1, $<str>2); }
	;

block_item
	: declaration
	| statement
//	{ printf("%s\n",$<str>1); }
	;

expression_statement
	: ';'
	| expression ';'
	{ sprintf($<str>$, "%s;\n",$<str>1); }
	;

selection_statement
	: IF '(' expression ')' statement
	| IF '(' expression ')' statement ELSE statement
	| SWITCH '(' expression ')' statement
	{ sprintf($<str>$, "(*switch*)WHILE TRUE DO\nCASE %s OF\n %s\nEND_CASE\n\n(*switch*)EXIT;\n(*switch*)END_WHILE",$<str>3, $<str>5); }
	;

iteration_statement
	: WHILE '(' expression ')' statement
	{ sprintf($<str>$, "WHILE %s DO\n%s\nEND_WHILE\n",$<str>3, $<str>5); }
	| DO statement WHILE '(' expression ')' ';'
	| FOR '(' expression_statement expression_statement ')' statement
	| FOR '(' expression_statement expression_statement expression ')' statement
	{ sprintf($<str>$, "%s\nWHILE %s DO\n%s\n%s;\nEND_WHILE\n",$<str>3, $<str>4, $<str>7, $<str>5); }
	| FOR '(' declaration expression_statement ')' statement
	| FOR '(' declaration expression_statement expression ')' statement
	;

jump_statement
	: GOTO IDENTIFIER ';'
	| CONTINUE ';'
	| BREAK ';'
	{ sprintf($<str>$, "EXIT;\n"); }
	| RETURN ';'
	| RETURN expression ';'
	;

translation_unit
	: external_declaration
	| translation_unit external_declaration
	;

external_declaration
	: function_definition
	| declaration
	;

function_definition
	: declaration_specifiers declarator declaration_list compound_statement
	{
		printf("%s %s %s %s", $<str>1, $<str>2, $<str>3, $<str>4);
	}
	| declaration_specifiers declarator compound_statement
	{
		char *p;
		while( (p=fifo_pop(decl_all)) != NULL)
		{
			printf("%s", p);
			printf("%s;\n", $<str>1);
		}
		printf("%s", $<str>3);
		strcpy($<str>$, "");
	}
	;

declaration_list
	: declaration
	| declaration_list declaration
	{ sprintf($<str>$, "%s %s\n",$<str>1, $<str>2); }
	;


%%
#include <stdio.h>

extern char yytext[];
extern int column;

void yyerror(char const *s)
{
	fflush(stdout);
	printf("\n%*s\n%*s\n", column, "^", column, s);
}

int main(void)
{
    yyparse();
    return 0;
}


/* fifo implementation */
void fifo_push(fifo_entry_t type, const char *psz)
{
	unsigned int fifow_next = (s_fifos[type].write + 1) % FIFO_SIZE; 
	if (fifow_next != s_fifos[type].read)
	{
		//s_fifo[s_fifow] = psz;
		strcpy(s_fifos[type].fifo[s_fifos[type].write], psz);
		s_fifos[type].write = fifow_next;
	}
}

char *lifo_pop(fifo_entry_t type)
{
	if (s_fifos[type].read != s_fifos[type].write)
	{
		s_fifos[type].write = (s_fifos[type].write + FIFO_SIZE - 1) % FIFO_SIZE;
		return s_fifos[type].fifo[s_fifos[type].write];
	}
	return NULL;
}

char *fifo_pop(fifo_entry_t type)
{
	unsigned int fifor_prev;
	if (s_fifos[type].read != s_fifos[type].write)
	{
		fifor_prev = s_fifos[type].read;
		s_fifos[type].read = (s_fifos[type].read + 1) % FIFO_SIZE;
		return s_fifos[type].fifo[fifor_prev];
	}
	return NULL;
}

void fifo_tag(fifo_entry_t type)
{
	char *p;
	while ((p = fifo_pop(decl_all)) != NULL)
		fifo_push(type, p);
}

char *maptype(char *ctype)
{
	if (!strcmp(ctype, "void"))
		return "BOOL";

	if (!strcmp(ctype, "char") || !strcmp(ctype, "signed BYTE"))
		return "BYTE";
	if (!strcmp(ctype, "short") || !strcmp(ctype, "signed INT"))
		return "INT";
	if (!strcmp(ctype, "int") || !strcmp(ctype, "signed DINT"))
		return "DINT";
	if (!strcmp(ctype, "long") || !strcmp(ctype, "signed DINT"))
		return "DINT";
	if (!strcmp(ctype, "long DINT"))
		return "LINT";

	if (!strcmp(ctype, "unsigned BYTE"))
		return "UBYTE";
	if (!strcmp(ctype, "unsigned INT"))
		return "UINT";
	if (!strcmp(ctype, "unsigned DINT"))
		return "UDINT";
	if (!strcmp(ctype, "unsigned DINT"))
		return "UDINT";
	if (!strcmp(ctype, "unsigned LINT"))
		return "ULINT";
	if (!strcmp(ctype, "struct"))
		return "STRUCT";
	if (!strcmp(ctype, ""))
		return "";
//	printf("maptype: not found: %s\n", ctype);
	return ctype;
}

unsigned int genCRC(char *szData)
{
	char *p;
	unsigned int i;
	unsigned int v;
	unsigned int crc;

	i = 0;
	crc = 42; // start value
	p = szData;
	while (*p != 0)
	{
		v = crc & 0xf8000000;
		crc = crc << 5;
		crc = crc ^ (v >> 27);
		crc ^= i;
		i++;
		p++;
	}
	return crc;
}

char *genIdentifier(char *szData)
{
	static char szId[8];
	unsigned int crc;
	crc = genCRC(szData);
	sprintf(szId, "Id%u", crc);
	return szId;
}

char *strUpper(char *szStr)
{
	char *p;
	p = szStr;
	while (*p != 0)
	{
		if (*p >= 'a' && *p <= 'z')
			*p = *p - ('a' - 'A');
		p++;
	}
	return szStr;
}

char *strIdentifier(char *szStr)
{
	char *p;
	p = szStr;
	while (*p != 0)
	{
		if ( (*p >= 'a' && *p <= 'z')
		  || (*p >= 'A' && *p <= 'Z')
		  || (*p >= '0' && *p <= '9')
		  || (*p == '_') )
		{
			p++;
		}
		else
		{
			*p = '\0';
			return szStr;
		}
	}
	return szStr;
}

void addSym(char *szSym)
{
	int i;
	i = s_iSymTabCount++;
	strcpy(s_szSymTab[i], szSym);
}

int isSym(char *szSym)
{
	int i;
	for (i=0; i < s_iSymTabCount; i++)
	{
		if (!strcmp(s_szSymTab[i], szSym))
		{
			return 1;
		}
	}
	return 0;
}