Размещено на http://www.allbest.ru/

Министерство образования и науки Российской Федерации

Санкт-Петербургский государственный политехнический университет

Факультет технической кибернетики

Кафедра «Информационная безопасность компьютерных систем»

КУРСОВАЯ РАБОТА

по дисциплине «Формальные грамматики»

Распознавание языка программирования MASM

Выполнили

студенты гр. 3088/2

Е.В. Жуковский

М.В. Глейм

Руководитель П. В. Семьянов

Санкт-Петербург 2012



Формулировка задания

В данной курсовой работе необходимо составить грамматику языка программирования MASM.

Результаты работы

В результате выполнения курсовой работы была разработана программа, осуществляющая разбор языка программирования MASM.

Использовались такие средства как bison и flex.

Созданная программа не поддерживает распознавание XMM и SMM инструкций, директивы сопроцессора.

В ходе выполнения работы возникли следующие проблемы и найдены соответствующие их решения:

1. большое количество ошибок reduce/reduce (402)

Проверена грамматика на равнозначные правила

2. ошибка переполнения стека

Правая рекурсия заменена левой.

язык программирование грамматика распознавание

Исходные тексты программ

1. Файл masmparser.l

%{

#include "y.tab.h"

extern int Line;

extern int debug;

#define PRINT(str) { if(debug) printf("%d: [%s] '%s'\n", Line, str, yytext); }

%}

%%".186"|".286"[pP]*|".287"|".386"[pP]*|".387"|".486"[pP]*|".586"|".686"[pP]*|".8086"|".8087" { PRINT("processor"); yylval.dirval = strdup(yytext); return PROCESSOR; }

^[ \t]*".data"|".DATA" { PRINT("segment"); yylval.dirval = strdup(yytext); return DATA_SEG; }

^[ \t]*".code"|".CODE" { PRINT("segment"); yylval.dirval = strdup(yytext); return CODE_SEG; }

^[ \t]*".const"|".CONST" { PRINT("segment"); yylval.dirval = strdup(yytext); return CONST_SEG; }

^[ \t]*".stack"|".STACK" { PRINT("segment"); yylval.dirval = strdup(yytext); return STACK_SEG; }

^[ \t]*".data?"|".DATA?" { PRINT("segment"); yylval.dirval = strdup(yytext); return DATA_SEGN; }

^[ \t]*".fardata"|".FARDATA?" { PRINT("segment"); yylval.dirval = strdup(yytext); return FARDATA_SEG; }

^[ \t]*".fardata?"|".FARDATA?" { PRINT("segment"); yylval.dirval = strdup(yytext); return FARDATA_SEGN; }

^[ \t]*".startup"|".STARTUP" { PRINT("startup"); yylval.dirval = strdup(yytext); return _STARTUP; }

".xmm"|".XMM" { PRINT("segment"); yylval.dirval = strdup(yytext); return _XMM; }

".model"|".MODEL" { yylval.dirval = strdup(yytext); return _MODEL; }

"tiny"|"TINY" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _TINY; }

"small"|"SMALL" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _SMALL; }

"medium"|"MEDIUM" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _MEDIUM; }

"compact"|"COMPACT" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _COMPACT; }

"large"|"LARGE" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _LARGE; }

"huge"|"HUGE" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _HUGE; }

"flat"|"FLAT" { PRINT("memorymodel"); yylval.dirval = strdup(yytext); return _FLAT; }

/*"stdcall"|"STDCALL" { PRINT("model"); yylval.dirval = strdup(yytext); return MODEL_TYPE; }

*/

"basic"|"BASIC" { PRINT("langtype"); yylval.dirval = strdup(yytext); return _BASIC; }

"fortran"|"FORTRAN" { PRINT("langtype"); yylval.dirval = strdup(yytext); return _FORTRAN; }

"pascal"|"PASCAL" { PRINT("langtype"); yylval.dirval = strdup(yytext); return _PASCAL; }

"syscall"|"SYSCALL" { PRINT("langtype"); yylval.dirval = strdup(yytext); return _SYSCALL; }

"stdcall"|"STDCALL" { PRINT("langtype"); yylval.dirval = strdup(yytext); return _STDCALL; }

"nearstack"|"NEARSTACK" { PRINT("stackoption"); yylval.dirval = strdup(yytext); return _NEARSTACK; }

"farstack"|"FARSTACK" { PRINT("stackoption"); yylval.dirval = strdup(yytext); return _FARSTACK; }

"extern"|"EXTERN" { PRINT("extern"); yylval.dirval = strdup(yytext); return _EXTERN; }

"externdef"|"EXTERNDEF" { PRINT("extern"); yylval.dirval = strdup(yytext); return _EXTERNDEF; }

"extrn"|"EXTRN" { PRINT("extern"); yylval.dirval = strdup(yytext); return _EXTRN; }

"assume"|"ASSUME" { PRINT("assume"); yylval.dirval = strdup(yytext); return _ASSUME; }

"error"|"ERROR" { PRINT("assume"); yylval.dirval = strdup(yytext); return _ERROR; }

"nothing"|"NOTHING" { PRINT("assume"); yylval.dirval = strdup(yytext); return _NOTHING; }

"proto"|"PROTO" { PRINT("proto"); yylval.dirval = strdup(yytext); return _PROTO; }

^[ \t]*"option"|"OPTION" { PRINT("option"); yylval.dirval = strdup(yytext); return _OPTION; }

"casemap"|"CASEMAP" { PRINT("options"); yylval.dirval = strdup(yytext); return _CASEMAP; }

"dotname"|"DOTNAME" { PRINT("options"); yylval.dirval = strdup(yytext); return _DOTNAME; }

"nodotname"|"NODOTNAME" { PRINT("options"); yylval.dirval = strdup(yytext); return _NODOTNAME; }

"emulator"|"EMULATOR" { PRINT("options"); yylval.dirval = strdup(yytext); return _EMULATOR; }

"noemulator"|"NOEMULATOR" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOEMULATOR; }

"epilogue"|"EPILOGUE" { PRINT("options"); yylval.dirval = strdup(yytext); return _EPILOGUE; }

"expr16"|"EXPR16" { PRINT("options"); yylval.dirval = strdup(yytext); return _EXPR16; }

"expr32"|"EXPR32" { PRINT("options"); yylval.dirval = strdup(yytext); return _EXPR32; }

"language"|"LANGUAGE" { PRINT("options"); yylval.dirval = strdup(yytext); return _LANGUAGE ; }

"lgmp"|"LJMP" { PRINT("options"); yylval.dirval = strdup(yytext); return _LJMP; }

"nolgmp"|"NOLJMP" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOLJMP; }

"m510"|"M510" { PRINT("options"); yylval.dirval = strdup(yytext); return _M510; }

"nom510"|"NOM510" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOM510; }

"nokeyword"|"NOKEYWORD" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOKEYWORD; }

"nosignextend"|"NOSIGNEXTEND" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOSIGNEXTEND; }

"offset"|"OFFSET" { PRINT("options"); yylval.dirval = strdup(yytext); return _OFFSET; }

"oldmacros"|"OLDMACROS" { PRINT("options"); yylval.dirval = strdup(yytext); return _OLDMACROS; }

"nooldmacros"|"NOOLDMACROS" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOOLDMACROS; }

"oldstructs"|"OLDSTRUCTS" { PRINT("options"); yylval.dirval = strdup(yytext); return _OLDSTRUCTS; }

"nooldstructs"|"NOOLDSTRUCTS" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOOLDSTRUCTS; }

"prologue"|"PROLOGUE" { PRINT("options"); yylval.dirval = strdup(yytext); return _PROLOGUE; }

"readonly"|"READONLY" { PRINT("options"); yylval.dirval = strdup(yytext); return _READONLY; }

"noreadonly"|"NOREADONLY" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOREADONLY; }

"scoped"|"SCOPED" { PRINT("options"); yylval.dirval = strdup(yytext); return _SCOPED; }

"noscoped"|"NOSCOPED" { PRINT("options"); yylval.dirval = strdup(yytext); return _NOSCOPED; }

"segment"|"SEGMENT" { PRINT("options"); yylval.dirval = strdup(yytext); return _SEGMENT; }

"setif2"|"SETIF2" { PRINT("options"); yylval.dirval = strdup(yytext); return _SETIF2; }

"high"|"HIGH" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _HIGH; }

"high32"|"HIGH32" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _HIGH32; }

"highword"|"HIGHWORD" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _HIGHWORD; }

"low"|"LOW" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LOW; }

"low32"|"LOW32" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LOW32; }

"lowword"|"LOWWORD" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LOWWORD; }

"opattr"|"OPATTR" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _OPATTR; }

"seg"|"SEG" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _SEG; }

"imagerel"|"IMAGEREL" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _IMAGEREL; }

"lroffset"|"LROFFSET" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LROFFSET; }

"sectionrel"|"SECTIONREL" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _SECTIONREL; }

"length"|"LENGTH" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LENGTH; }

"lengthof"|"LENGTHOF" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _LENGTHOF; }

"size"|"SIZE" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _SIZE; }

"sizeof"|"SIZEOF" { PRINT("type_op"); yylval.dirval = strdup(yytext); return _SIZEOF; }

"byte"|"BYTE" { PRINT("type"); yylval.dirval = strdup(yytext); return _BYTE; }

"word"|"WORD" { PRINT("type"); yylval.dirval = strdup(yytext); return _WORD; }

"dword"|"DWORD" { PRINT("type"); yylval.dirval = strdup(yytext); return _DWORD; }

"qword"|"QWORD" { PRINT("type"); yylval.dirval = strdup(yytext); return _QWORD; }

"tbyte"|"TBYTE" { PRINT("type"); yylval.dirval = strdup(yytext); return _TBYTE; }

"near"|"NEAR" { PRINT("type"); yylval.dirval = strdup(yytext); return _NEAR; }

"far"|"FAR" { PRINT("type"); yylval.dirval = strdup(yytext); return _FAR; }

"short"|"SHORT" { PRINT("label_type"); yylval.dirval = strdup(yytext); return _SHORT; }

"ptr"|"PTR" { PRINT("ptr"); yylval.dirval = strdup(yytext); return _PTR; }

"struct"|"STRUCT" { PRINT("struct"); yylval.dirval = strdup(yytext); return _STRUCT; }

"union"|"UNION" { PRINT("struct"); yylval.dirval = strdup(yytext); return _UNION; }

"ends"|"ENDS" { PRINT("struct_end"); yylval.dirval = strdup(yytext); return _ENDS; }

""|"" { PRINT(""); yylval.dirval = strdup(yytext); return ; }

/*"type"|"TYPE" { PRINT("type"); yylval.dirval = strdup(yytext); return TYPE; }*/

/* MACROS */

"equ"|"EQU" { PRINT("macro"); yylval.dirval = strdup(yytext); return _EQU; }

"=" { PRINT("="); yylval.dirval = strdup(yytext); return '='; }

".break"|".BREAK" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __BREAK; }

".continue"|".CONTINUE" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __CONTINUE; }

".else"|".ELSE" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __ELSE; }

".elseif"|".ELSEIF" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __ELSEIF; }

".endif"|".ENDIF" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __ENDIF; }

".endw"|".ENDW" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __ENDW; }

".if"|".IF" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __IF; }

".repeat"|".REPEAT" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __REPEAT; }

".until"|".UNTIL" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __UNTIL; }

".untilcxz"|".UNTILCXZ" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __UNTILCXZ; }

".while"|".WHILE" { PRINT("cond_flow"); yylval.dirval = strdup(yytext); return __WHILE; }

"if"|"IF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _IF; }

"ife"|"IFE" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _IFE; }

"ifdef"|"IFDEF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _IFDEF; }

"ifndef"|"IFNDEF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _IFNDEF; }

_assembly

"else"|"ELSE" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSE; }

"elseif"|"ELSEIF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIF; }

"elseifb"|"ELSEIFB" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFB; }

"elseifdef"|"ELSEIFDEF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFDEF; }

"elseifdif"|"ELSEIFDIF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFDIF; }

"elseifdifi"|"ELSEIFDIFI" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFDIFI; }

"elseife"|"ELSEIFE" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFE; }

"elseifidn"|"ELSEIFIDN" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFIDN; }

"elseifidni"|"ELSEIFIDNI" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFIDNI; }

"elseifnb"|"ELSEIFNB" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFNB; }

"elseifdef"|"ELSEIFNDEF" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ELSEIFNDEF; }

"while"|"WHILE" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _WHILE; }

"endm"|"ENDM" { PRINT("cond_assembly"); yylval.dirval = strdup(yytext); return _ENDM; }

"macro"|"MACRO" { PRINT("macro"); yylval.dirval = strdup(yytext); return _MACRO; }

"req"|"REQ" { PRINT("macro_arg"); yylval.dirval = strdup(yytext); return MACRO_ARG; }

"default"|"DEFAULT" { PRINT("macro_arg"); yylval.dirval = strdup(yytext); return MACRO_ARG; }

"vararg"|"VARARG" { PRINT("macro_arg"); yylval.dirval = strdup(yytext); return MACRO_ARG; }

"endif"|"ENDIF" { PRINT("condition"); yylval.dirval = strdup(yytext); return _ENDIF; }

"exitm"|"EXITM" { PRINT("exit"); yylval.dirval = strdup(yytext); return _EXITM; }

">" { PRINT("comparison"); yylval.dirval = strdup(yytext); return '>'; }

"<" { PRINT("comparison"); yylval.dirval = strdup(yytext); return '<'; }

"<=" { PRINT("comparison"); yylval.dirval = strdup(yytext); return "<="; }

"&" { PRINT("comparison"); yylval.dirval = strdup(yytext); return '&'; }

"!" { PRINT("comparison"); yylval.dirval = strdup(yytext); return '!'; }

"|" { PRINT("comparison"); yylval.dirval = strdup(yytext); return '|'; }

/*"==" { PRINT("comparison"); yylval.dirval = strdup(yytext); return "=="; }

"!=" { PRINT("comparison"); yylval.dirval = strdup(yytext); return "!="; }

">=" { PRINT("comparison"); yylval.dirval = strdup(yytext); return ">="; }

"&&" { PRINT("comparison"); yylval.dirval = strdup(yytext); return "&&"; }

"||" { PRINT("comparison"); yylval.dirval = strdup(yytext); return "||"; }

*/

"carry?"|"CARRY?" { PRINT("comparison"); yylval.dirval = strdup(yytext); return _CARRY; }

"overflow?"|"OVERFLOW?" { PRINT("comparison"); yylval.dirval = strdup(yytext); return _OVERFLOW; }

"parity?"|"PARITY?" { PRINT("comparison"); yylval.dirval = strdup(yytext); return _PARITY; }

"sign?"|"SIGN?" { PRINT("comparison"); yylval.dirval = strdup(yytext); return _SIGN; }

"zero?"|"ZERO?" { PRINT("comparison"); yylval.dirval = strdup(yytext); return _ZERO; }

"@Date" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Time" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Cpu" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Environ" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Interface" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Version" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@FileCur" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@FileName" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Line" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@CatStr" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@InStr" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@SizeStr" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@SubStr" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@@:" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@B" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@F" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@code" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@CodeSize" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@CurSeg" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@data" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@DataSize" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@fardata" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@fardata?" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@Model" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@stack" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

"@WordSize" { PRINT("symbol reference"); yylval.dirval = strdup(yytext); return SYMBOL_REF; }

/*

""|"" { PRINT(""); yylval.dirval = strdup(yytext); return ; }

""|"" { PRINT("type"); yylval.dirval = strdup(yytext); return TYPE; }

SHORT

THIS

TYPE

*/

"invoke"|"INVOKE" { PRINT("invoke"); yylval.dirval = strdup(yytext); return _INVOKE; }

^[ \t]*"include" { PRINT("include"); yylval.dirval = strdup(yytext); return _INCLUDE; }

^[ \t]*"includelib" { PRINT("includelib"); yylval.dirval = strdup(yytext); return _INCLUDELIB; }

^[ \t]*"INCLUDELIB"[ \t].*$ { PRINT("INCLUDELIB"); yylval.dirval = strdup(yytext); return INCLUDELIB; }

[ ].*".inc"|[ ].*".lib" { PRINT("path"); yylval.strval = strdup(yytext); return PATH; }

"public"|"PUBLIC" { PRINT("public"); yylval.dirval = strdup(yytext); return _PUBLIC; }

"proc"|"PROC" { PRINT("proc"); yylval.dirval = strdup(yytext); return _PROC; }

"uses"|"USES" { PRINT("proc arg"); yylval.dirval = strdup(yytext); return _USES; }

"frame"|"FRAME" { PRINT("proc arg"); yylval.dirval = strdup(yytext); return _FRAME; }

"align"|"ALIGN" { PRINT("align"); yylval.dirval = strdup(yytext); return _ALIGN; }

"even"|"EVEN" { PRINT("even"); yylval.dirval = strdup(yytext); return _EVEN; }

"label"|"LABEL" { PRINT("label"); yylval.dirval = strdup(yytext); return _LABEL; }

"org"|"ORG" { PRINT("org"); yylval.dirval = strdup(yytext); return _ORG; }

"none"|"NONE" { PRINT("none"); yylval.dirval = strdup(yytext); return _NONE; }

"end"|"END" { PRINT("end"); yylval.dirval = strdup(yytext); return _END; }

"endp"|"ENDP" { PRINT("end"); yylval.dirval = strdup(yytext); return _ENDP; }

"para"|"PARA" { PRINT("align_type"); yylval.dirval = strdup(yytext); return _PARA; }

"page"|"PAGE" { PRINT("align_type"); yylval.dirval = strdup(yytext); return _PAGE; }

"ddd"|"DDD" yylval.regval = strdup(yytext); return DDD;

[0-9]+ { PRINT("num"); yylval.lval = strtol(yytext, NULL, 0); return NUM; }

[0][a-fA-F][0-9a-fA-F]+[hH]|[0-9][0-9a-fA-F]+[hH] PRINT("hex"); yylval.strval = strdup(yytext); return HEX;

[01]+[bB] { PRINT("bin"); yylval.cval = strdup(yytext); return BIN; }

^[ \t]*[_?@$a-zA-Z].*[:]$ PRINT("label"); yylval.strval = strdup(yytext); return LABEL;

['].*[']|["].*["]|[<].*[>] PRINT("string"); yylval.strval = strdup(yytext); return STRING;

[\n] Line++; return '\n';

[ \t]+ ;

[;].*$ { PRINT("comment"); return COMMENT; }

"eax"|"EAX" { PRINT("data_reg"); yylval.regval = strdup("eax"); return EAX; }

"ebx"|"EBX" { PRINT("data_reg"); yylval.regval = strdup("ebx"); return EBX; }

"ecx"|"ECX" { PRINT("data_reg"); yylval.regval = strdup("ecx"); return ECX; }

"edx"|"EDX" { PRINT("data_reg"); yylval.regval = strdup("edx"); return EDX; }

"ebp"|"EBP" { PRINT("cntrl_reg"); yylval.regval = strdup("ebp"); return EBP; }

"esi"|"ESI" { PRINT("cntrl_reg"); yylval.regval = strdup("esi"); return ESI; }

"edi"|"EDI" { PRINT("cntrl_reg"); yylval.regval = strdup("edi"); return EDI; }

"esp"|"ESP" { PRINT("cntrl_reg"); yylval.regval = strdup("esp"); return ESP; }

"ax"|"AX" { PRINT("data_reg"); yylval.regval = strdup("ax"); return AX; }

"bx"|"BX" { PRINT("data_reg"); yylval.regval = strdup("bx"); return BX; }

"cx"|"CX" { PRINT("data_reg"); yylval.regval = strdup("cx"); return CX; }

"dx"|"DX" { PRINT("data_reg"); yylval.regval = strdup("dx"); return DX; }

"al"|"AL" { PRINT("data_reg"); yylval.regval = strdup("al"); return AL; }

"bl"|"BL" { PRINT("data_reg"); yylval.regval = strdup("bl"); return BL; }

"cl"|"CL" { PRINT("data_reg"); yylval.regval = strdup("cl"); return CL; }

"dl"|"DL" { PRINT("data_reg"); yylval.regval = strdup("dl"); return DL; }

"ah"|"AH" { PRINT("data_reg"); yylval.regval = strdup("ah"); return AH; }

"bh"|"BH" { PRINT("data_reg"); yylval.regval = strdup("bh"); return BH; }

"ch"|"CH" { PRINT("data_reg"); yylval.regval = strdup("ch"); return CH; }

"dh"|"DH" { PRINT("data_reg"); yylval.regval = strdup("dh"); return DH; }

"eflags"|"EFLAGS" { PRINT("cntrl_reg"); yylval.regval = strdup("eflags"); return EFLAGS; }

"eip"|"EIP" { PRINT("cntrl_reg"); yylval.regval = strdup("eip"); return EIP; }

"flags"|"FLAGS" { PRINT("cntrl_reg"); yylval.regval = strdup("flags"); return FLAGS; }

"ip"|"IP" { PRINT("cntrl_reg"); yylval.regval = strdup("ip"); return IP; }

"bp"|"BP" { PRINT("cntrl_reg"); yylval.regval = strdup(yytext); return BP; }

"si"|"SI" { PRINT("cntrl_reg"); yylval.regval = strdup(yytext); return SI; }

"di"|"DI" { PRINT("cntrl_reg"); yylval.regval = strdup(yytext); return DI; }

"cs"|"CS" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return CS; }

"ds"|"DS" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return DS; }

"ss"|"SS" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return SS; }

"es"|"ES" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return ES; }

"fs"|"FS" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return FS; }

"gs"|"GS" { PRINT("seg_reg"); yylval.regval = strdup(yytext); return GS; }

[ \t]*"aaa"|"AAA" { return AAA; }

[ \t]*"aad"|"AAD" { return AAD; }

[ \t]*"aam"|"AAM" { return AAM; }

[ \t]*"aas"|"AAS" { return AAS; }

[ \t]*"adc"|"ADC" { return ADC; }

[ \t]*"add"|"ADD" { return ADD; }

^[ \t]*"and"[ \t]|^[ \t]"AND" { return AND; }

[ \t]*"bsf"|"BSF" { return BSF; }

[ \t]*"bsr"|"BSR" { return BSR; }

[ \t]*"btc"|"BTC" { return BTC; }

[ \t]*"btr"|"BTR" { return BTR; }

[ \t]*"bts"|"BTS" { return BTS; }

[ \t]*"bt"|"BT" { return BT; }

[ \t]*"call"|"CALL" { return CALL; }

[ \t]*"cbw"|"CBW" { return CBW; }

[ \t]*"cdq"|"CDQ" { return CDQ; }

[ \t]*"clc"|"CLC" { return CLC; }

[ \t]*"cld"|"CLD" { return CLD; }

[ \t]*"cli"|"CLI" { return CLI; }

[ \t]*"cmc"|"CMC" { return CMC; }

[ \t]*"cmps" |"CMPS" { return CMPS; }

[ \t]*"cmpsb"|"CMPSB" { return CMPSB; }

[ \t]*"cmpsw"|"CMPSW" { return CMPSW; }

[ \t]*"cmpsd"|"CMPSD" { return CMPSD; }

[ \t]*"cmp"|"CMP" { return CMP; }

[ \t]*"cwd"|"CWD" { return CWD; }

[ \t]*"daa"|"DAA" { return DAA; }

[ \t]*"das"|"DAS" { return DAS; }

[ \t]*"dec"|"DEC" { return DEC; }

[ \t]*"div"|"DIV" { return DIV; }

[ \t]*"idiv"|"IDIV" { return IDIV; }

[ \t]*"imul"|"IMUL" { return IMUL; }

[ \t]*"inc"|"INC" { return INC; }

[ \t]*"int"|"INT" { return INT; }

[ \t]*"in" |"IN" { return IN; }

[ \t]*"iret"|"IRET" { return IRET; }

/*"jCONDITION"|"" { return ; }*/

/*^[ \t]*"jz"|"JZ" { return JZ; }

[ \t]*"je"|"JE" { return JE; }

[ \t]*"jnz"|"JNZ" { return JNZ; }

[ \t]*"jne"|"JNE" { return JNE; }

[ \t]*"jnb"|"JNB" { return JNB; }

[ \t]*"jb"|"JB" { return JB; }

[ \t]*"ja"|"JA" { return JA; }*/

"jz"|"JZ"|"je"|"JE"|"jnz"|"JNZ"|"jne"|"JNE|"jnb"|"JNB|"jb"|"JB"|"ja"|"JA"|"jnbe"|"JNBE" { return JMPIF; }

"jae"|"JAE"|"jnae"|"JNAE"|"jc"|"JC"|"jbe"|"JBE"|"jna"|"JNA"|"jcxz"|"JCXZ"|"jecxz"|"JECXZ"|"jg"|"JG" { return JMPIF; }

"jnle"|"JNLE"|"jge"|"JGE"|"jnl"|"JNL"|"jl"|"JL"|"jnge"|"JNGE"|"jle"|"JLE"|"jng"|"JNG"|"jno"|"JNO" { return JMPIF; }

"jnp"|"JNP"|"jpo"|"JPO"|"jns"|"JNS"|"jp"|"JP"|"jpe"|"JPE"|"jo"|"JO"|"js"|"JS" { return JMPIF; }

[ \t]*"jmp"[ \t]|"JMP"[ \t] { return JMP; }

[ \t]*"lahf"[ \t]|"LAHF"[ \t] { return LAHF; }

[ \t]*"lds"[ \t]|"LDS"[ \t] { return LDS; }

[ \t]*"les"[ \t]|"LES"[ \t] { return LES; }

[ \t]*"lfs"[ \t]|"LFS"[ \t] { return LFS; }

[ \t]*"lgs"[ \t]|"LGS"[ \t] { return LGS; }

[ \t]*"lss"[ \t]|"LSS"[ \t] { return LSS; }

[ \t]*"lea"[ \t]|"LEA"[ \t] { return LEA; }

[ \t]*"lods"[ \t]|"LODS"[ \t] { return LODS; }

[ \t]*"lodsb"[ \t]|"LODSB"[ \t] { return LODSB; }

[ \t]*"lodsw"[ \t]|"LODSW"[ \t] { return LODSW; }

[ \t]*"lodsd"[ \t]|"LODSD"[ \t] { return LODSD; }

[ \t]*"loopne"[ \t]|"LOOPNE"[ \t] { return LOOPNE; }

[ \t]*"loope"[ \t]|"LOOPE"[ \t] { return LOOPE; }

[ \t]*"loopz"[ \t]|"LOOPZ"[ \t] { return LOOPZ; }

[ \t]*"loop"[ \t]|"LOOP"[ \t] { return LOOP; }

[ \t]*"movsb"[ \t]|"MOVSB"[ \t] { return MOVSB; }

[ \t]*"movsw"[ \t]|"MOVSW"[ \t] { return MOVSW; }

[ \t]*"movsd"[ \t]|"MOVSD"[ \t] { return MOVSD; }

[ \t]*"movzx"[ \t]|"MOVZX"[ \t] { return MOVZX; }

[ \t]*"movs"[ \t]|"MOVS"[ \t] { return MOVS; }

[ \t]*"mov"[ \t]|"MOV"[ \t] { PRINT("instr"); return MOV; }

[ \t]*"mul"[ \t]|"MUL"[ \t] { return MUL; }

[ \t]*"neg"[ \t]|"NEG"[ \t] { return NEG; }

[ \t]*"nop"[ \t]|"NOP"[ \t] { return NOP; }

[ \t]*"not"[ \t]|"NOT"[ \t] { return NOT; }

^[ \t]*"or"[ \t]|^[ \t]*"OR"[ \t] { return OR; }

[ \t]*"out"[ \t]|"OUT"[ \t] { return OUT; }

[ \t]*"popad"[ \t]|"POPAD"[ \t] { return POPAD; }

[ \t]*"popa"[ \t]|"POPA"[ \t] { return POPA; }

[ \t]*"popfd"[ \t]|"POPFD"[ \t] { return POPFD; }

[ \t]*"popf"[ \t]|"POPF"[ \t] { return POPF; }

[ \t]*"pop"[ \t]|"POP"[ \t] { return POP; }

[ \t]*"pushad"[ \t]|"PUSHAD"[ \t] { return PUSHAD; }

[ \t]*"pusha"[ \t]|"PUSHA"[ \t] { return PUSHA; }

[ \t]*"push"[ \t]|"PUSH"[ \t] { return PUSH; }

[ \t]*"pushfd"[ \t]|"PUSHFD"[ \t] { return PUSHFD; }

[ \t]*"pushf"[ \t]|"PUSHF"[ \t] { return PUSHF; }

[ \t]*"rcl"[ ]|"RCL"[ ] { return RCL; }

[ \t]*"rcr"[ ]|"RCR"[ ] { return RCR; }

[ \t]*"rep"[ ]|"REP"[ ] { return REP; }

/*[ \t]*"repCONDITION"|"" { return ; }*/

[ \t]*"retn"[ \t] |"RETN"[ \t] { return RETN; }

[ \t]*"ret"[ \t]|"RET"[ \t] { return RET; }

[ \t]*"rol"[ \t]|"ROL"[ \t] { return ROL; }

[ \t]*"ror"[ \t]|"ROR"[ \t] { return ROR; }

[ \t]*"sahf"[ \t]|"SAHF"[ \t] { return SAHF; }

[ \t]*"sal"[ \t]|"SAL"[ \t]] { return SAL; }

[ \t]*"sar"[ \t]|"SAR"[ \t]] { return SAR; }

[ \t]*"sbb"[ \t]|"SBB"[ \t]] { return SBB; }

[ \t]*"scasb"[ \t]|"SCASB"[ \t] { return SCASB; }

[ \t]*"scasw"[ \t]|"SCASW"[ \t] { return SCASW; }

[ \t]*"scasd"[ \t]|"SCASD"[ \t] { return SCASD; }

[ \t]*"scas"[ \t]|"SCAS"[ \t] { return SCAS; }

/*[ \t]*"setCONDITION"|"" { return ; }*/

[ \t]*"shrd"[ \t]|"SHRD"[ \t] { return SHRD; }

[ \t]*"shld"[ \t]|"SHLD"[ \t] { return SHLD; }

^[ \t]*"shl"[ \t]|"SHL"[ \t] { return SHL; }

^[ \t]*"shr"[ \t]|"SHR"[ \t] { return SHR; }

[ \t]*"stc"[ \t]|"STC"[ \t] { return STC; }

[ \t]*"std"[ \t]|"STD"[ \t] { return STD; }

[ \t]*"sti"[ \t]|"STI"[ \t] { return STI; }

[ \t]*"stosb"[ \t]|"STOSB"[ \t] { return STOSB; }

[ \t]*"stosw"[ \t]|"STOSW"[ \t] { return STOSW; }

[ \t]*"stosd"[ \t]|"STOSD"[ \t] { return STOSD; }

[ \t]*"stos"[ \t]|"STOS"[ \t] { return STOS; }

[ \t]*"sub"[ \t]|"SUB"[ \t] { return SUB; }

[ \t]*"test"[ \t]|"TEST"[ \t] { return TEST; }

[ \t]*"wait"[ \t]|"WAIT"[ \t] { return WAIT; }

[ \t]*"xchg"[ \t]|"XCHG"[ \t] { return XCHG; }

[ \t]*"xlatb"[ \t]|"XLATB"[ \t] { return XLATB; }

[ \t]*"xlat"[ \t]|"XLAT"[ \t] { return XLAT; }

^[ \t]*"xor"[ \t]|^[ \t]*"XOR"[ \t] { return XOR; }

"db"|"DB" { PRINT("init"); return DB; }

"dw"|"DW" { PRINT("init"); return DW; }

"dd"|"DD" { PRINT("init"); return DD; }

"dq"|"DQ" { PRINT("init"); return DQ; }

"df"|"DF" { PRINT("init"); return DF; }

"dp"|"DP" { PRINT("init"); return DP; }

"dt"|"DT" { PRINT("init"); return DT; }

"mod"|"MOD" { PRINT("operation"); yylval.dirval = strdup(yytext); return _MOD; }

"shl"|"SHL" { PRINT("operation"); yylval.dirval = strdup(yytext); return _SHL; }

"shr"|"SHR" { PRINT("operation"); yylval.dirval = strdup(yytext); return _SHR; }

"and"|"AND" { PRINT("operation"); yylval.dirval = strdup(yytext); return _AND; }

"or"|"OR" { PRINT("operation"); yylval.dirval = strdup(yytext); return _OR; }

"xor"|"XOR" { PRINT("operation"); yylval.dirval = strdup(yytext); return _XOR; }

"eq"|"EQ" { PRINT("operation"); yylval.dirval = strdup(yytext); return _EQ; }

"ne"|"NE" { PRINT("operation"); yylval.dirval = strdup(yytext); return _NE; }

"lt"|"LT" { PRINT("operation"); yylval.dirval = strdup(yytext); return _LT; }

"le"|"LE" { PRINT("operation"); yylval.dirval = strdup(yytext); return _LE; }

"gt"|"GT" { PRINT("operation"); yylval.dirval = strdup(yytext); return _GT; }

"ge"|"GE" { PRINT("operation"); yylval.dirval = strdup(yytext); return _GE; }

"dup"|"DUP" { PRINT("dup"); return DUP; }

"." { /* PRINT("."); */ return '.'; }

"?" { /* PRINT("?"); */ return '?'; }

":" { /* PRINT(":"); */ return ':'; }

"," { /* PRINT(","); */ return ','; }

"-" { /* PRINT("-"); */ return '-'; }

"+" { /* PRINT("+"); */ return '+'; }

"*" { /* PRINT("*"); */ return '*'; }

"/" { /* PRINT("/"); */ return '/'; }

"[" { /* PRINT("["); */ return '['; }

"]" { /* PRINT("]"); */ return ']'; }

"(" { /* PRINT("("); */ return '('; }

")" { /* PRINT(")"); */ return ')'; }

/* "<" { return '<'; } */

/* ">" { return '>'; } */

"$" { /* PRINT("$"); */ return '$'; }

"title"[ \t]+[ .():_?@$a-zA-Z0-9\\/]+$|"TITLE"[ \t]+[ .():_?@$a-zA-Z0-9\\/]+$ { PRINT("title"); yylval.dirval = strdup(yytext); return TITLE; }

[_?@$a-zA-Z][0-9a-zA-Z_?@$]* { PRINT("id"); yylval.dirval = strdup(yytext); return IDENTIFICATOR; }

{ PRINT("ERROR symbol"); }//return(int)yytext[0];

%%

2. Файл masmparser.y

%{

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

FILE * yyin;

long error = 0;

int Line = 0;

int debug = 0;

int end_file = 0;

#define YYMAXDEPTH 900000

void yyerror(const char *str);

int yywrap(void);

%}

%token EAX EBX ECX EDX EBP ESI EDI ESP

AX BX CX DX

AL BL CL DL AH BH CH DH

EFLAGS EIP

FLAGS IP BP SI DI

CS DS SS ES FS GS

AAA AAD AAM AAS ADC ADD AND BSF BSR BT BTC BTR BTS CALL CBW CDQ CLC CLD

CLI CMC CMP CMPS CMPSB CMPSW CMPSD CWD DAA DAS DEC DIV IDIV IMUL IN

INC INT IRET JMPIF JMP LAHF LDS LES LFS LGS LSS

LEA LODS LODSB LODSW LODSD LOOP LOOPE LOOPZ LOOPNE MOV MOVS MOVSB

MOVSW MOVSD MOVZX MUL NEG NOP NOT OR OUT POP POPA POPAD POPF POPFD PUSH

PUSHA PUSHAD PUSHF PUSHFD RCL RCR REP RET RETN ROL ROR SAHF SAL

SAR SBB SCAS SCASB SCASW SCASD SHL SHLD SHR SHRD STC STD STI STOS STOSB STOSW

STOSD SUB TEST WAIT XCHG XLAT XLATB XOR

IDENTIFICATOR

COMMENT

PROCESSOR

_MODEL MODEL_TYPE

DATA_SEG DATA_SEGN CODE_SEG CONST_SEG STACK_SEG FARDATA_SEG FARDATA_SEGN _STARTUP

_OPTION _CASEMAP _DOTNAME _NODOTNAME _EMULATOR _NOEMULATOR _EPILOGUE _EXPR16 _EXPR32 _LANGUAGE

_LJMP _NOLJMP _M510 _NOM510 _NOKEYWORD _NOSIGNEXTEND _OFFSET _OLDMACROS _NOOLDMACROS _OLDSTRUCTS

_NOOLDSTRUCTS _PROC _USES _FRAME _PROLOGUE _READONLY _NOREADONLY _SCOPED _NOSCOPED _SEGMENT _SETIF2

_ASSUME _ERROR _NOTHING

_NONE _END _ENDP _ALIGN _ORG _LABEL _EVEN

_INCLUDE _INCLUDELIB INCLUDELIB PATH _PUBLIC _EXTRN _EXTERN _EXTERNDEF

NUM HEX BIN STRING LABEL//ALPHA SYMBOL

DB DW DD DQ DF DP DT

DUP DDD

_INVOKE

TYPE _PTR _PROTO

TITLE

_TINY _SMALL _COMPACT _MEDIUM _LARGE _HUGE _FLAT

_BASIC _FORTRAN _PASCAL _SYSCALL _STDCALL _NEARSTACK _FARSTACK

_XMM

_HIGH _HIGH32 _HIGHWORD _LOW _LOW32 _LOWWORD _OPATTR _SEG _IMAGEREL _LROFFSET _SECTIONREL _SIZE _SIZEOF //<type_op> expr

_MOD _SHL _SHR _AND _OR _XOR _EQ _NE _LT _LE _GT _GE

_SHORT //_NEAR _FAR

_BYTE _WORD _DWORD _QWORD _TBYTE _NEAR _FAR

_EQU _LENGTHOF _NOT _LENGTH _TYPE

_IF _IFE _IFDEF _IFNDEF _ELSE _ELSEIF _ELSEIFB _ELSEIFDEF _ELSEIFDIF _ELSEIFDIFI

_ELSEIFE _ELSEIFIDN _ELSEIFIDNI _ELSEIFNB _ELSEIFNDEF _ENDIF _EXITM _WHILE _ENDM

__BREAK __CONTINUE __ELSE __ELSEIF __ENDIF __ENDW __IF __REPEAT __UNTIL __UNTILCXZ __WHILE

SYMBOL_REF

_CARRY _OVERFLOW _PARITY _SIGN _ZERO

_PARA _PAGE

_MACRO MACRO_ARG //_REQ _DEFAULT _VARARG

_STRUCT _UNION _ENDS

%union {char* regval; char* dirval; long lval; char* strval; char cval;}

%start programm //lines

%%

programm:

| programm line

{

//currentLine++;

};

line:

directive tail | cmd tail | tail ;

tail:

'\n' | COMMENT | COMMENT '\n' ;

directive:

PROCESSOR

| model

| TITLE

| option

| include

| extern

| assume

| _STARTUP

| segment

| segment_create

| init

| struct

| union

| proc

| LABEL

| label_create

| proto

| public

| align

| invoke

| macro

| _ORG expr

| name _ENDP

| cond_asm

| cond_flow

| exit

| end ;

model:

_MODEL memorymodel | model ',' langtype | model ',' stackoption ;//_MODEL MODEL_TYPE | model ',' MODEL_TYPE |

memorymodel:

_TINY | _SMALL | _COMPACT | _MEDIUM | _LARGE | _HUGE | _FLAT ;

langtype:

'c' | 'C' | _BASIC | _FORTRAN | _PASCAL | _SYSCALL | _STDCALL ; //_C |

stackoption:

_NEARSTACK | _FARSTACK ;

include:

_INCLUDE PATH | _INCLUDELIB PATH | INCLUDELIB ;

extern:

_EXTRN name |_EXTRN extern_arg | _EXTERN name | extern extern_arg | _EXTERN extern_arg | _EXTERNDEF name | _EXTERNDEF extern_arg ;

extern_arg:

langtype name | name ':' type | ',' name ':' type ;

// | name ':' label_type | ',' name ':' label_type ;

segment:

CODE_SEG | CODE_SEG name | CONST_SEG | DATA_SEG | DATA_SEGN | STACK_SEG num | STACK_SEG

| FARDATA_SEG | FARDATA_SEG name | FARDATA_SEGN | FARDATA_SEGN name

| _XMM { printf("WARNING! Used XMM!"); } ;

segment_create:

name _SEGMENT | segment_create _READONLY | segment_create _NOREADONLY

| segment_create _BYTE | segment_create _WORD | segment_create _DWORD

| segment_create _PARA | segment_create _PAGE | segment_create _ALIGN '(' expr ')' ;

option:

_OPTION option_type ':' _NONE | _OPTION option_type ;

option_type:

_OPTION | _CASEMAP | _DOTNAME | _NODOTNAME | _EMULATOR | _NOEMULATOR | _EPILOGUE | _EXPR16 | _EXPR32 | _LANGUAGE

| _LJMP | _NOLJMP | _M510 | _NOM510 | _NOKEYWORD | _NOSIGNEXTEND | _OFFSET | _OLDMACROS | _NOOLDMACROS | _OLDSTRUCTS

| _NOOLDSTRUCTS | _PROLOGUE | _READONLY | _NOREADONLY | _SCOPED | _NOSCOPED | _SEGMENT | _SETIF2 ; //_PROC |

assume:

_ASSUME assume_arg | assume ',' assume_arg ;

assume_arg:

seg_reg ':' name | reg ':' type | reg ':' _ERROR | reg ':' _NOTHING | _NOTHING ;

label_create:

name _LABEL type | name _LABEL _PTR | name _LABEL _PTR type

| name _LABEL label_type _PTR type ;// name _LABEL label_type _PTR type ;

label_type:

type | _PROC ;

// _SHORT | _NEAR | _FAR | _PROC ;

proto:

label _PROTO langtype proto_arg | label _PROTO proto_arg ;

proto_arg:

name ':' _PTR type | name ':' type | ',' proto_arg ;

align:

_ALIGN num | _ALIGN _BYTE | _ALIGN _WORD | _ALIGN _DWORD | _ALIGN _PARA | _ALIGN _PAGE ;

init:

name initdir init_expr | initdir init_expr ;

init_expr:

num DUP '(' expr_data ')' | init_expr ',' expr_data | num DUP '(' STRING ')'

| init_expr ',' STRING | expr_data | STRING;

/*init:

name initdir init_expr | initdir init_expr ;

init_expr:

num DUP '(' init_data ')' | init_data ;

init_data:

init_expr ',' data | init_expr ',' name | data | name ; //init_data |

*/

struct:

_STRUCT | name _STRUCT | name _ENDS | _ENDS | name name init_expr ;

union:

_UNION | name _UNION ; //| name '.' name ;

public:

_PUBLIC name | public ',' name ;

invoke:

_INVOKE name | invoke ',' name | invoke name;

name:

IDENTIFICATOR //| TYPE IDENTIFICATOR //| TYPE _PTR IDENTIFICATOR

;

//ALPHA | name ALPHA | name NUM | SYMBOL NUM name | SYMBOL name

initdir:

DB | DW | DD | DQ | DF | DP | DT ;

cond_asm:

_IF cond | _IFE cond | _IFDEF cond | _IFNDEF cond | _ELSE | _ELSEIF cond | _ELSEIFB cond

| _ELSEIFDEF cond | _ELSEIFDIF cond | _ELSEIFDIFI cond

| _ELSEIFE cond | _ELSEIFIDN cond | _ELSEIFIDNI cond | _ELSEIFNB cond | _ELSEIFNDEF cond

| _ENDIF | _WHILE cond | _ENDM | _ENDM expr ;

cond_flow:

__IF cond | __ELSE | __ELSEIF cond | __ENDIF | __ENDW | __WHILE cond | __REPEAT

| __UNTIL cond | __UNTILCXZ | __UNTILCXZ cond | __BREAK | __BREAK _IF cond | __CONTINUE | __CONTINUE _IF cond ;

cond:

expr cond_op expr | expr | _CARRY | _OVERFLOW | _PARITY | _SIGN | _ZERO ;

//immed cond_op immed | reg cond_op immed | immed cond_op reg | mem cond_op immed

//| immed cond_op mem | reg cond_op mem | mem cond_op reg

cond_op:

'=''=' | '!''=' | '>' | '<' | '>''=' | '<''=' | '&''&' | '|''|' | '&' | '!' | '-' cond_op ; // & номер бита

exit:

_EXITM | _EXITM num | _EXITM STRING ;

//data:

// STRING | num | '?' ;

num:

NUM | HEX | BIN ;

//hex:

// HEX ; //dechex 'h' | 'o' alphahex 'h';

/*dechex:

NUM alphahex | NUM;

alphahex:

HEX alphahex | dechex | NUM | HEX;

//bin:

// bindigit 'b' | bindigit bin 'b';

bindigit:

'0' | '1';

*/

proc:

name _PROC | proc _USES reg | proc reg | proc name ':' type | proc ',' name ':' type | proc _FRAME ;

label:

expr | label_type expr | label_type _PTR expr ;

//name | '$' '+' num | label_type name | label_type _PTR name | label '[' reg ']'

|// label_type '[' reg ']' | label_type _PTR '[' reg ']';

macro:

equ | name _MACRO name | name _MACRO name ':' MACRO_ARG

| macro ',' name ':' MACRO_ARG | name expr | macro ',' expr ;

equ:

name _EQU expr | name _EQU '-' expr | name _EQU STRING | name '=' expr | name '=' '-' expr | name '=' STRING ;

//data | name _EQU reg | name '=' data | name '=' mem | name '=' expr | name _EQU mem | name _EQU expr ;

type:

_BYTE | _WORD | _DWORD | _QWORD | _TBYTE | _NEAR | _FAR

|_SHORT ; //! type_label

expr:

_NOT expr | _HIGH expr | _HIGH32 expr | _LOW expr | _LOW32 expr | _LOWWORD expr | _OPATTR expr | _HIGHWORD expr

| _SEG expr | _OFFSET expr | _IMAGEREL expr | _LROFFSET expr | _SECTIONREL expr | _LENGTH name | _LENGTHOF name

| _SIZE expr | _SIZEOF expr | _TYPE name | type expr | type _PTR expr

| expr op expr | '[' expr ']' | expr '[' expr ']' | '(' expr ')' | expr_data | reg | expr '.' expr ;

expr_data:

num | name | '$' | SYMBOL_REF | '?' ; //| reg op expr | '[' expr ']' | expr op expr ; //| '[' reg ']' | '[' reg op expr ']' | '[' expr ']';//data?

op:

'+' | '-' | '*' | '/' | _MOD | _SHL | _SHR | _AND | _OR | _XOR

| _EQ | _NE | _LT | _LE | _GT | _GE ;

end:

_END | _END name ;

cmd:

AAA | AAD | AAM | AAS | adc | add | and | bsf | bsr | bt | btc | btr | bts | call | CBW | CDQ | CLC | CLD | CLI | CMC

| cmp | CMPS mem ',' mem | CMPSB mem ',' mem | CMPSW mem ',' mem | CMPSD mem ',' mem

| CWD | DAA | DAS | dec | div | idiv | imul | in |inc | INT num | IRET | jmpif | jmp | LAHF

| LDS | LES | LFS | LGS | LSS | lea | lods | lodsb | lodsw | lodsd | loop | loope | loopz | loopne

| mov | movs | movsb | movsw | movsd | movzx | mul | neg | NOP | not | or | out | pop | POPA | POPAD | POPF | POPFD

| push | PUSHA | PUSHAD | PUSHF| PUSHFD | rcl | rcr | rep | RET | retn | rol | ror | SAHF | sal | sar | sbb

| scas | scasb | scasw | scasd | shl | shr | shld | shrd | STC | STD | STI | stos| stosb |stosw| stosd | sub | test | WAIT

| xchg | xlat | xlatb | xor ;

rep:

REP cmd_name | REP ;

// AAA | AAD | AAM | AAS | CBW | CDQ | CLC | CLD | CLI | CMC | CWD

// | DAA | DAS | IRET | LAHF | LDS | LES | LFS | LGS | LSS | NOP | POPA | POPAD | POPF | POPFD | PUSHA | PUSHAD | PUSHF

// | PUSHFD | REP | RET | SAHF | STC | STD | STI | WAIT

adc:

ADC mem ',' mem ; //reg ',' reg | ADC mem ',' reg | ADC reg ',' mem | ADC reg ',' immed | ADC mem ',' immed ;

add:

ADD mem ',' mem ; //reg ',' reg | ADD mem ',' reg | ADD reg ',' mem | ADD reg ',' immed | ADD mem ',' immed ;

and:

AND mem ',' mem ; //reg ',' reg | AND mem ',' reg | AND reg ',' mem | AND reg ',' immed | AND mem ',' immed ;

bsf:

BSF mem ',' mem ; //reg ',' reg | BSF reg ',' mem ; //BSF reg16 ',' reg16 | BSF reg16 ',' mem16 | BSF reg32 ',' reg32 | BSF reg32 ',' mem32 ;

bsr:

BSR mem ',' mem ; //reg ',' reg | BSR reg ',' mem ; // BSR reg16 ',' reg16 | BSR reg16 ',' mem16 | BSR reg32 ',' reg32 | BSR reg32 ',' mem32 ;

bt:

BT mem ',' mem ; //reg ',' reg | BT reg ',' immed | BT mem ',' immed | BT mem ',' reg ; // BT reg16 ',' reg16 | BT reg16 ',' immed8 | BT mem16 ',' immed8 | BT mem16 ',' reg16 ;

btc:

BTC mem ',' mem ; //reg ',' reg | BT reg ',' immed | BT mem ',' immed | BT mem ',' reg ; // BTC reg16 ',' reg16 | BTC reg16 ',' immed8 | BTC mem16 ',' immed8 | BTC mem16 ',' reg16 ;

btr:

BTR mem ',' mem ; //reg ',' reg | BTR reg ',' immed | BTR mem ',' immed | BTR mem ',' reg ; // BTR reg16 ',' reg16 | BTR reg16 ',' immed8 | BTR mem16 ',' immed8 | BTR mem16 ',' reg16 ;

bts:

BTS mem ',' mem ; //reg ',' reg | BTS reg ',' immed | BTS mem ',' immed | BTS mem ',' reg ; // BTS reg16 ',' reg16 | BTS reg16 ',' immed8 | BTS mem16 ',' immed8 | BTS mem16 ',' reg16 ;

call:

CALL label ; //| CALL reg | CALL mem ;//CALL mem16 | CALL mem32 ;

cmp:

CMP mem ',' mem ; //reg ',' reg | CMP mem ',' reg | CMP reg ',' mem | CMP reg ',' immed | CMP mem ',' immed ;

dec:

DEC mem ; //DEC reg |

div:

DIV mem ; // DIV reg |

idiv:

IDIV mem ; //IDIV reg |

imul:

IMUL mem | IMUL reg ',' mem // IMUL reg | | IMUL reg ',' reg | IMUL reg ',' reg ',' immed

| IMUL reg ',' mem ',' immed ;

in:

IN AL ',' immed | IN AX ',' immed | IN EAX ',' immed ;

inc:

INC mem ; //INC reg |

jmpif:

JMPIF label ;

jmp:

JMP label ;

lea:

LEA reg ',' mem ;

lods:

LODS label ;

lodsb:

LODSB label ;

lodsw:

LODSW label ;

lodsd:

LODSD label ;

loop:

LOOP label ;

loope:

LOOPE label ;

loopz:

LOOPZ label ;

loopne:

LOOPNE label ;

mov:

MOV mem ',' mem ; //reg ',' reg | MOV mem ',' reg | MOV reg ',' mem | MOV reg ',' immed | MOV mem ',' immed ;

movs:

MOVS mem ',' mem ;

movsb:

MOVSB mem ',' mem ;

movsw:

MOVSW mem ',' mem ;

movsd:

MOVSD mem ',' mem ;

movzx:

MOVZX mem ',' mem ; //reg ',' reg | MOVZX reg ',' mem ;

mul:

MUL mem ; //MUL reg |

neg:

NEG mem ; //NEG reg |

not:

NOT mem ; //NOT reg |

or:

OR mem ',' mem ; //reg ',' reg | OR mem ',' reg | OR reg ',' mem | OR reg ',' immed | OR mem ',' immed ;

out:

OUT immed ',' AH | OUT immed ',' AX | OUT immed ',' EAX | OUT DX ',' AH | OUT DX ',' AX | OUT DX ',' EAX ;

pop:

POP mem ; // POP reg | POP reg16 | POP reg32 | POP mem16 | POP mem32 ;

push:

PUSH mem ; //PUSH reg | | PUSH mem16 | PUSH mem32 ;

rcl:

RCL mem ',' mem ; //reg ',' immed/*8*/ | RCL reg ',' CL | RCL mem ',' immed/*8*/ | RCL mem ',' CL ;

rcr:

RCR mem ',' mem ; //reg ',' immed/*8*/ | RCR reg ',' CL | RCR mem ',' immed/*8*/ | RCR mem ',' CL ;

retn:

RETN immed/*8*/ | RET immed ;

rol:

ROL mem ',' mem ; //reg ',' immed/*8*/ | ROL reg ',' CL | ROL mem ',' immed/*8*/ | ROL mem ',' CL ;

ror:

ROR mem ',' mem ; //reg ',' immed/*8*/ | ROR reg ',' CL | ROR mem ',' immed/*8*/ | ROR mem ',' CL ;

sal:

SAL mem ',' mem ; //reg ',' immed/*8*/ | SAL reg ',' CL | SAL mem ',' immed/*8*/ | SAL mem ',' CL ;

sar:

SAR mem ',' mem ; //reg ',' immed/*8*/ | SAR reg ',' CL | SAR mem ',' immed/*8*/ | SAR mem ',' CL ;

sbb:

SBB mem ',' mem ; //reg ',' reg | SBB mem ',' reg | SBB reg ',' mem | SBB reg ',' immed | SBB mem ',' immed ;

scas:

SCAS mem ;

scasb:

SCASB mem ;

scasw:

SCASW mem ;

scasd:

SCASD mem ;

shl:

SHL reg ',' immed ; //8

//| SHL reg ',' CL | SHL mem ',' immed//8

//| SHL mem ',' CL ;

shr:

SHR mem ',' mem ; //reg ',' immed/*8*/ | SHR reg ',' CL | SHR mem ',' immed/*8*/ | SHR mem ',' CL ;

shld:

SHLD mem ',' mem ; //reg ',' reg ',' immed | SHLD mem ',' reg ',' immed | SHLD mem ',' mem ',' immed; //+cl

shrd:

SHRD mem ',' mem ; //reg ',' reg ',' immed | SHRD mem ',' reg ',' immed | SHRD mem ',' mem ',' immed; // ?!

stos:

STOS mem ;

stosb:

STOSB mem ;

stosw:

STOSW mem ;

stosd:

STOSD mem ;

sub:

SUB mem ',' mem ; //reg ',' reg | SUB mem ',' reg | SUB reg ',' mem | SUB reg ',' immed | SUB mem ',' immed ;

test:

TEST mem ',' mem ; //reg ',' reg | TEST mem ',' reg | TEST reg ',' mem | TEST reg ',' immed | TEST mem ',' immed ;

xchg:

XCHG mem ',' mem ; //reg ',' reg | XCHG mem ',' reg | XCHG reg ',' mem ;

xlat:

XLAT mem ;

xlatb:

XLATB mem ;

xor:

XOR mem ',' mem ; //reg ',' reg | XOR mem ',' reg | XOR reg ',' mem | XOR reg ',' immed | XOR mem ',' immed ;

reg:

reg8 | reg16 | reg32 ;

reg8:

AL | BL | CL | DL | AH | BH | CH | DH ;

reg16:

AX | BX | CX | DX | BP | SI | DI

| seg_reg //| FLAGS | IP

seg_reg:

CS | DS | SS | ES | FS | GS ;

reg32:

EAX | EBX | ECX | EDX | EBP | ESI | EDI | ESP //| EFLAGS | EIP

mem:

expr | '-' expr | seg_reg ':' expr | name ':' expr // | seg_reg ':' name | name ':' name ;

immed:

expr | '-' expr ; //data | // immed8 | immed16 | immed32 ;

cmd_name:

ADC | ADD | AND | BSF | BSR | BT | BTC | BTR | BTS | CALL | CMP | CMPS | CMPSB

| CMPSW | CMPSD | DEC | DIV | IDIV | IMUL | IN | INC | INT | JMPIF | JMP | LEA

| LODS | LODSB | LODSW | LODSD | LOOP | LOOPE| LOOPZ | LOOPNE | MOV | MOVS | MOVSB

| MOVSW | MOVSD | MOVZX | MUL | NEG | NOT | OR | OUT | POP | PUSH | RCL | RCR | RETN

| ROL | ROR | SAL | SAR | SBB | SCAS | SCASB | SCASW | SCASD | SHL | SHR | STOS

| STOSB | STOSW | STOSD | SUB | TEST | XCHG | XLAT | XLATB | XOR ;

void yyerror(const char *str)

{

if(end_file)

;//printf("parsed successfully!\n");

else

fprintf(stderr,"[%d]: error: %s '%s'\n", Line, str, yylval);

error = 1;

int yywrap(void)

{

end_file = 1;

//printf("parsed successfully!\n");

return 1;

}

void usage(char* programName)

{

printf("%s input_file_name\n", programName);

printf("%s help\n", programName);

exit(0);

}

void main(int argc, char *argv[])

{

Line = 1;

if (argc < 2)

{

printf("error: file name missed\n");

usage(argv[0]);

}

else

{

if (!strcmp(argv[1], "help"))

usage(argv[0]);

else

{

if(argc>2 && !strcmp(argv[2], "debug"))

debug = 1;

yyin = fopen(argv[1], "r");

if (!yyin) {

printf("error: can not open input file\n");

exit(1);

}

yyparse();

if(!error)

printf("parsed successfully!\n");

fclose(yyin);

}

}

}

Размещено на Allbest.ru