Курсовой проект по дисциплине Формальные грамматики, языки и автоматы / Curs1 / ARVIN / KURS / LEKCEM / LEX

//Є« ббЁдЁЄ жЁп ўе®¤­ле бЁ¬ў®«®ў
#define DIGIT  0
#define CHAR   1
#define OP     2
#define LEFTF  3 /*{*/
#define RIGHTF 4 /*}*/
#define LEFT   5 /*(*/
#define RIGHT  6 /*)*/
#define END    7 /*;*/
#define SPACE  8 /* */
#define DOT    9 /*.*/
#define COMA  10 /*,*/

//Є« ббЁдЁЄ жЁп б®бв®п­Ё©  ўв®¬ в 
#define _I_       0
#define _Nbr_     1
#define _NbrF_    2
#define _Id_      3
#define _Key_     4
#define _Op_      5
#define _Razd_    6

//Є« ббЁдЁЄ жЁп  «ҐЄбҐ¬
#define KEY   0 //§ аҐ§ҐаўЁа®ў ­­®Ґ б«®ў®
#define NBRI  1 //楫®зЁб«Ґ­­ п Є®­бв ­в 
#define NBRF  2 //¤а®Ў­ п Є®­бв ­в 
#define OPER  3 //®ЇҐа жЁп
#define ID    4 //Ё¤Ґ­вЁдЁЄ в®а
#define RAZD  5 //а §¤Ґ«ЁвҐ«м
#define ERROR 6 //®иЁЎЄ  ў Їа®жҐбᥠ«ҐЄбЁзҐбЄ®Ј® а §Ў®а 

char *LexName[]=
{ " ‘«г¦ҐЎ­®Ґ б«®ў® ",
  " –Ґ«®зЁб«Ґ­­ п Є®­бв ­в  ",
  " „а®Ў­ п Є®­бв ­в  ",
  " ЋЇҐа жЁп ",
  " €¤Ґ­вЁдЁЄ в®а ",
  " ђ §¤Ґ«ЁвҐ«м ",
  " Ћ€ЃЉЂ: "
};

char *RazdName[]=
{ "","","",
  "'{'",
  "'}'",
  "'('",
  "')'",
  "';'",
  "' '",
  "'.'",
  "','"
};

int nKeyWord=4;
char *KeyWord[]=
{
  "int",
  "float",
  "main()",
  "for("
};

int nOp=7;
char *Op[]=
{
  "<" ,
  ">" ,
  "<=",
  ">=",
  "+" ,
  "*" ,
  "="
};

const char* err1="«ҐЄбҐ¬  ­Ґ ¬®¦Ґв ­ зЁ­ вмбп б в®зЄЁ!";
const char* err2="®¦Ё¤ « бм жЁда  ў int-Є®­бв ­вҐ!";
const char* err3="®¦Ё¤ «®бм ; Ї®б«Ґ int-Є®­бв ­вл!";
const char* err4="­ҐЄ®а४в­л© бЁ¬ў®« ў int-Є®­бв ­вҐ:','";
const char* err5="®¦Ё¤ « бм жЁда  ў® float-Є®­бв ­вҐ!";
const char* err6="®¦Ё¤ «®бм ; Ї®б«Ґ float-Є®­бв ­вл!";
const char* err7="ўв®а п ¤ҐбпвЁз­ п в®зЄ  ў® float-Є®­бв ­вҐ!";
const char* err8="­ҐЄ®а४в­л© бЁ¬ў®« ў® float-Є®­бв ­вҐ:','";
const char* err9="®¦Ё¤ «®бм ; Ї®б«Ґ Ё¤Ґ­вЁдЁЄ в®а !";
const char* err10="­ҐЄ®а४в­л© бЁ¬ў®« ў Ё¤Ґ­вЁдЁЄ в®аҐ:'.'";
const char* err11="­ҐЄ®а४⭮Ґ § ўҐа襭ЁҐ б«г¦ҐЎ­®Ј® б«®ў !";
const char* err12="®вбгвбвўгҐв ўв®а®© ®ЇҐа ­¤ ў ЎЁ­ а­®© ®ЇҐа жЁЁ!";

const char* Errors[11][6]=
{
	 /*_I_*/   /*_NbrI_*/ /*_NbrF_*/ /*_Id_*/  /*_Key_*/ /*_Op_*/
/*Digt*/ {0     ,     0     ,    0     ,    0    ,    0    ,    0   },
/*Char*/ {0     ,    err2   ,   err5   ,    0    ,    0    ,    0   },
/*Op*/   {0     ,     0     ,    0     ,    0    ,  err11  ,    0   },
/*{*/    {0     ,    err3   ,   err6   ,   err9  ,  err11  ,  err12 },
/*}*/    {0     ,    err3   ,   err6   ,   err9  ,  err11  ,  err12 },
/*(*/    {0     ,    err3   ,   err6   ,    0    ,    0    ,    0   },
/*)*/    {0     ,     0     ,    0     ,    0    ,    0    ,  err12 },
/*;*/    {0     ,     0     ,    0     ,    0    ,  err11  ,  err12 },
/* */    {0     ,     0     ,    0     ,    0    ,    0    ,    0   },
/*.*/    {err1  ,     0     ,   err7   ,   err10 ,  err11  ,  err12 },
/*,*/    {0     ,    err4   ,   err8   ,    0    ,  err11  ,  err12 }
};

void BeginNbr();
void BeginId();
void BeginOp();
void BeginRazd();

void ProcessNbr();
void ProcessNbrF();
void ProcessKey();
void ProcessId();
void ProcessOp();

void EndNbr();
void EndNbrF();
void EndId();
void EndOp();
void EndKey();
void EndRazd();

extern void Error();

void (*Table[11][6])()=
{
	/*_I_*/   /*_NbrI_*/ /*_NbrF_*/ /*_Id_*/  /*_Key_*//*_Op_*/
/*Digt*/{BeginNbr,ProcessNbr,ProcessNbr,ProcessId ,EndKey ,EndOp     },
/*Char*/{BeginId ,Error     ,Error     ,ProcessId ,EndKey ,EndOp     },
/*Op*/  {BeginOp ,EndNbr    ,EndNbrF   ,EndId     ,Error  ,ProcessOp },
/*{*/   {EndRazd ,Error     ,Error     ,Error     ,Error  ,Error     },
/*}*/   {EndRazd ,Error     ,Error     ,Error     ,Error  ,Error     },
/*(*/   {EndRazd ,Error     ,Error     ,ProcessKey,EndKey ,EndOp     },
/*)*/   {EndRazd ,EndNbr    ,EndNbrF   ,EndId     ,EndKey ,Error     },
/*;*/   {EndRazd ,EndNbr    ,EndNbrF   ,EndId     ,Error  ,Error     },
/* */   {EndRazd ,EndNbr    ,EndNbrF   ,EndId     ,EndKey ,EndOp     },
/*.*/   {Error   ,ProcessNbrF,Error    ,Error     ,Error  ,Error     },
/*,*/   {EndRazd ,Error     ,Error     ,EndId     ,Error  ,Error     }
};

class Lex
{
 public:
  int type;
  union Ptr
  { long idx;
    void *ptr;
  }ptr;
  Lex()  {type=0;ptr.idx=0L;};
  Lex(int t,long idx){type=t;ptr.idx=idx;};
  Lex(int t,void *p ){type=t;ptr.ptr=p;};
  Lex(const Lex& l)
  { if(this!=&l)
    {
     type=l.type;
     ptr.idx=l.ptr.idx;
    }
  }
  int operator==(Lex &l)
  {
   return (type==l.type)&&(ptr.idx==l.ptr.idx);
  }
};

void output(Lex);