Sintaksis.H

#ifndef SintaksisH

#define SintaksisH

#include "DataBase.h"

Void Sint(Ident &I, rez &r);

#endif

Sintaksis.Cpp

#pragma hdrstop

#include "Sintaksis.h"

#include "Stack_mass.h"

#include "LeksBlok.h"

#include "string.h"

//------------------------------------------------------------------------------------------------------------------------------------------------------

Void Sint(Ident &I, rez &r)

{

Stack<int> St; //стек программы

int ptr; //атрибуты p,q,t

St.push(T_S);

elem el = I.Get(0);

for (int i = 0; St.Size() > 0 && i < I.Size(); el = I.Get(i))

{

switch(St.pop())

{

case T_S: //#1

if (el.clas == C_IDENTIF ||

el.clas == C_KEY_WORD && el.name[0] == 'i' ||

el.clas == C_KEY_WORD && el.name[0] == 'w' ||

el.clas == C_RAZDEL && el.name[0] == -74)

{

St.push(T_SOVOK_OPER);

}

else

throw ErrInvChain();

break;

case T_SOVOK_OPER: //#2

if (el.clas == C_IDENTIF ||

el.clas == C_KEY_WORD && el.name[0] == 'i' ||

el.clas == C_KEY_WORD && el.name[0] == 'w')

{

St.push(T_SOVOK_OPER);

St.push(T_OPER);

break;

}

if (el.clas == C_RAZDEL && el.name[0] == -74 ||

el.clas == C_KEY_WORD && el.name[0] == 'e' && el.name[1] == 'n')

{

break; //#3

}

throw ErrInvChain();

case T_OPER :

if (el.clas == C_IDENTIF) //#4

{

St.push(T_OPER_PRISV);

break;

}

if (el.clas == C_KEY_WORD && el.name[0] == 'i') //#5

{

St.push(T_OPER_IF);

break;

}

if (el.clas == C_KEY_WORD && el.name[0] == 'w') //#6

{

St.push(T_OPER_CYCLE);

break;

}

throw ErrInvChain();

case T_OPER_PRISV:

if (el.clas == C_IDENTIF) //#7

{

St.push(S_T_Z);

St.push(-1);

//проверка на вхождения

for (ptr = 0; ptr < R.Data.Size(); ++ptr)

if (R.Data[ptr].clas == C_IDENTIF && !strcmp(R.Data[ptr].name, el.name))

break;

if (ptr == R.Data.Size())

R.Data.push(el);

St.push(ptr);

St.push(K_PRISV);

St.push(St.Size() - 3);

St.push(T_E);

i += 2;

}

else

throw ErrInvChain();

break;

case T_E:

switch(el.clas)

{

case C_INT: case C_IDENTIF: //#8

St.push(-1);

St.push(T_E_SPIS);

St.push(St.Size() - 2);

St.push(T_T);

break;

default:

throw ErrInvChain();

}

break;

case T_E_SPIS: //#9

if (el.clas == C_RAZDEL)

switch(el.name[0])

{

case '+' :

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_E_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_SLOJ);

St.push(St.Size() - 3);

St.push(T_T);

++i;

break;

case ';' : //#10

ptr = St.pop();

St[St.pop()] = ptr;

break;

default:

throw ErrInvChain();

}

break;

case T_T:

switch(el.clas) //#11

{

case C_INT: case C_IDENTIF:

St.push(-1);

St.push(T_T_SPIS);

St.push(St.Size() - 2);

St.push(T_F);

break;

default:

throw ErrInvChain();

}

break;

case T_T_SPIS:

if (el.clas == C_RAZDEL) //#12

switch(el.name[0])

{

case '*' :

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_T_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_UMNOJ);

St.push(St.Size() - 3);

St.push(T_F);

++i;

break;

case '+' : case ';' : //#13

ptr = St.pop();

St[St.pop()] = ptr;

break;

default:

throw ErrInvChain();

}

break;

case T_F:

switch(el.clas) //#14

{

case C_INT: case C_IDENTIF:

St.push(-1);

St.push(T_F_SPIS);

St.push(St.Size() - 2);

St.push(T_P);

break;

default:

throw ErrInvChain();

}

break;

case T_F_SPIS:

if (el.clas == C_RAZDEL)

switch(el.name[0])

{

case '^': //#15

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_F_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_V_STEP);

St.push(St.Size() - 3);

St.push(T_P);

++i;

break;

case '*' : case '+' : case ';' : //#16

ptr = St.pop();

St[St.pop()] = ptr;

break;

default :

throw ErrInvChain();

}

break;

case T_P:

switch(el.clas)

{

case C_INT: case C_IDENTIF: //#17//#18

//проверка на вхождения

for (ptr = 0; ptr < R.Data.Size(); ++ptr)

if ((R.Data[ptr].clas == C_IDENTIF || R.Data[ptr].clas == C_INT) && !strcmp(R.Data[ptr].name, el.name))

break;

if (ptr == R.Data.Size())

R.Data.push(el);

St[St.pop()] = ptr;

++i;

break;

default :

throw ErrInvChain();

}

break;

case T_OPER_IF:

if (el.clas == C_KEY_WORD && el.name[0] == 'i') //#19

{

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(T_ELSE_PART);

St.push(T_OPER);

St.push(KS_THEN);

St.push(R.Label.Size() - 1);

St.push(-1);

St.push(K_PEREHOD_0);

St.push(St.Size() - 2);

St.push(T_LOG_VIR);

++i;

}

else

throw ErrInvChain();

break;

case T_ELSE_PART:

if (el.clas == C_KEY_WORD && el.name[0] == 'e') //#20

{

ptr = St.pop();

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

St.push(T_OPER);

St.push(ptr);

St.push(K_METKA);

St.push(R.Label.Size() - 1);

St.push(K_PEREHOD_BEZ_USL);

++i;

break;

}

if (el.clas == C_IDENTIF || //#21

el.clas == C_KEY_WORD && el.name[0] == 'i' ||

el.clas == C_KEY_WORD && el.name[0] == 'w' ||

el.clas == C_RAZDEL && el.name[0] == -74)

{

St.push(K_METKA);

break;

}

throw ErrInvChain();

case T_OPER_CYCLE: //#22

if (el.clas == C_KEY_WORD && el.name[0] == 'w')

{

St.push(KS_END_WHILE);

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_PEREHOD_BEZ_USL);

St.push(T_SOVOK_OPER);

St.push(R.Label.Size() - 2);

St.push(-1);

St.push(K_PEREHOD_SRAVN);

St.push(St.Size() - 2);

St.push(T_LOG_VIR);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

++i;

}

else

throw ErrInvChain();

break;

case T_LOG_VIR: //#23

if (el.clas == C_RAZDEL)

{

ptr = St.pop();

St.push(S_SK_RIGHT);

St.push(ptr);

St.push(-1);

St.push(T_LOG_SPIS);

St.push(St.Size() - 2);

St.push(T_P);

++i;

break;

}

throw ErrInvChain();

case T_LOG_SPIS: //#24 //#25

if (el.clas == C_RAZDEL && (el.name[0] == '#' || el.name[0] == '='))

{

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St[St.pop()] = R.Data.Size() - 1;

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

if (el.name[0] == '=')

St.push(K_RAVNO);

if (el.name[0] == '#')

St.push(K_NE_RAVNO);

St.push(St.Size() - 3);

St.push(T_P);

++i;

}

else

throw ErrInvChain();

break;

case S_T_Z:

if (el.clas == C_RAZDEL && el.name[0] == ';')

++i;

else

throw ErrInvChain();

break;

case S_SK_RIGHT:

if (el.clas == C_RAZDEL && el.name[0] == ')' )

++i;

else

throw ErrInvChain();

break;

case KS_THEN: case KS_END_WHILE:

if (el.clas == C_KEY_WORD && (el.name[0] == 't' || el.name[0] == 'e'))

++i;

else

throw ErrInvChain();

break;

//Команды

case K_PRISV:

R.Command.push(K_PRISV);

for (int ptr = 0; ptr < 2; ++ptr)

R.Command.push(St.pop());

break;

case K_SLOJ:

R.Command.push(K_SLOJ);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_UMNOJ:

R.Command.push(K_UMNOJ);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_V_STEP:

R.Command.push(K_V_STEP);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_PEREHOD_0:

R.Command.push(K_PEREHOD_0);

for (int i = 0; i < 2; ++i)

R.Command.push(St.pop());

break;

case K_PEREHOD_BEZ_USL:

R.Command.push(K_PEREHOD_BEZ_USL);

R.Command.push(St.pop());

break;

case K_PEREHOD_SRAVN:

R.Command.push(K_PEREHOD_SRAVN);

for (int i = 0; i < 2; ++i)

R.Command.push(St.pop());

break;

case K_RAVNO:

R.Command.push(K_RAVNO);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_NE_RAVNO:

R.Command.push(K_NE_RAVNO);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_METKA:

R.Label[St.pop()] = R.Command.Size();

break;

default:

throw ErrSearch();

}

}

}

#pragma package(smart_init)