Таблица 3 - Таблица типов слов

5. Код программы

#include <stdafx.h>

#include <conio.h>

#include <stdio.h>

#include <string.h>

#include <locale.h>

FILE *in_file, *out_file;

const int max_dlin = 10000;

const int KS_kol = 13;

// массив ключевых слов

char * KS_mas[KS_kol] =

{

"begin", "end", "var", "real",

"boolean", "false", "true",

"read", "readln", "and",

"or", "label", "goto"

};

#define ks_begin 1

#define ks_end 2

#define ks_var 3

#define ks_real 4

#define ks_boolean 5

#define ks_false 6

#define ks_true 7

#define ks_read 8

#define ks_readln 9

#define ks_and 10

#define ks_or 11

#define ks_label 12

#define ks_goto 13

#define type_Real 1

#define type_Bool 2

#define type_Label 3

#define s_error 0

#define s_space 1

#define s_str 2

#define s_numb 3

#define s_char 4

typedef struct var{

char s[64];

int tp;

var * next;

};

var *vars, *lvars;

char in_str[max_dlin],out_str[max_dlin];

int in_len,out_len,in_pos;

int kol_err_1,kol_err_2,k_er;

int s_dlin;

int s_type;

int s_numf;

int otstup;

//добавить переменную в список

int dob_var(int gl){

var *np, *p;

if (gl) p = vars; else p = lvars;

while (p) {

if (strlen(p->s)==s_dlin&&

!memcmp(p->s,&in_str[in_pos],s_dlin)) return 0;

p = p->next;

}

np = new var;

memcpy(np->s,&in_str[in_pos],s_dlin);

np->s[s_dlin]=0;

np->tp = -1;

if (gl) {

np->next = vars;

vars = np;

} else {

np->next = lvars;

lvars = np;

}

return 1;

}

void set_type(int gl, int type){

var *p;

if (gl) p = vars; else p = lvars;

while (p) {

if (p->tp==-1) p->tp = type;

p = p->next;

}

}

// получение типа переменной

int type_var(){

var * p;

p = lvars;

while (p) {

if (strlen(p->s)==s_dlin&&

!memcmp(p->s,&in_str[in_pos],s_dlin)) return p->tp;

p = p->next;

}

p = vars;

while (p) {

if (strlen(p->s)==s_dlin&&

!memcmp(p->s,&in_str[in_pos],s_dlin)) return p->tp;

p = p->next;

}

return 0;

}

// освобождение списка переменных

void osv_vars(int gl){

var *p, *pp;

p = lvars;

while (p) {

pp = p;

p = p->next;

delete pp;

}

lvars = NULL;

if (gl) {

p = vars;

while (p) {

pp = p;

p = p->next;

delete pp;

}

vars = NULL;

}

}

// чтение слова

int read_slovo()

{

int st = 0;

char c;

s_dlin = 0;

while (s_dlin+in_pos<in_len ){

c = in_str[in_pos+s_dlin];

switch (st){

case 0:

if (c==' ' || c=='\t' || c=='\n') st = 1;

else

if ((c>='A' && c<='Z')||(c>='a' && c<='z')) st = 2;

else

if (c>='0' && c<='9') st = 3;

else

if (

c=='.' || c<=',' || c >=':' || c<=';' ||

c=='+' || c<='-' || c>='*' || c<='/' ||

c=='\''

)

{ s_dlin = 1; return s_type = s_char; }

else { s_dlin = 0; return s_type = s_error; }

break;

case 1:

if (c==' ' || c=='\t' || c=='\n') s_dlin++;

else return s_type = s_space;

break;

case 2:

if (

(c>='A' && c<='Z') ||

(c>='a' && c<='z') ||

(c>='0' && c<='9') ||

c=='_'

) s_dlin++;

else return s_type = s_str;

break;

case 3:

if (c>='0' && c<='9') s_dlin++; else

if (c=='.'&& in_str[in_pos+s_dlin+1]!='.') {

s_dlin++;

st = 5;

}

else{

s_numf = 0;

return s_type = s_numb;

}

break;

case 5:

if (c>='0' && c<='9') s_dlin++; else {

s_numf = 1;

return s_type = s_numb;

}

}

}

s_dlin = 0;

return 0;

}

//запись строки в выходной буфер

void put_stroku(char * s){

int l = strlen(s);

memcpy(&out_str[out_len],s,l);

out_len += l;

}

int scmp(char * m, char * s, int n){

int l = strlen(s);

if (n>l) l = n;

return memicmp(m,s,l);

}

//запись символа в выходной буфер

void put_simvol(char c){

out_str[out_len] = c;

out_len++;

}

void f_copy(){

memcpy(&out_str[out_len],&in_str[in_pos],s_dlin);

in_pos += s_dlin;

out_len += s_dlin;

}

int wequ(char * s){

return (!scmp(&in_str[in_pos],s,s_dlin));

}

//процедура пропуска пробела

void skip_space(){

in_pos += s_dlin;

}

//получение слов

int read_Slova(){

read_slovo();

if (s_type==s_space) {

skip_space();

read_slovo();

}

return s_type;

}

//увеличение отступа

void inc_otstup()

{

otstup += 2;

}

//уменьшение отступа

void dec_otstup()

{

otstup -= 2;

}

//вывод отступа

void put_otstup()

{

for (int i=0; i<otstup; i++) put_simvol(' ');

}

//открытие файла

int Open_Text(char * s1)

{

if ((in_file = fopen(s1, "rt")) == NULL){

return 0;

}

fseek(in_file, 0, SEEK_END);

in_len = ftell(in_file);

fseek(in_file, 0, SEEK_SET);

if (in_len>max_dlin) in_len = max_dlin;

in_len = fread(in_str,1,in_len,in_file);

in_str[in_len] = 0;

in_pos = 0;

out_len = 0;

return 1;

}

//вывод обработанного текста

int Put_Text(char * s2)

{

if ((out_file = fopen(s2, "wt")) == NULL){

return 0;

}

fwrite(out_str,out_len,1,out_file);

return 1;

}

//вывод ошибочного оператора

void func_Error()

{

put_stroku("< Ошибка! >");

int k;

put_simvol('<');

while (1){

read_Slova();

if (in_str[in_pos]== ';' || in_pos>= in_len) {

f_copy();

break;

};

f_copy();

}

put_simvol('>');

k_er++;

}

//проверка на комментарий

int func_Comment(){

return (in_str[in_pos]=='{' ||

in_str[in_pos]=='(' ||in_str[in_pos+1]=='*');

}

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

void func_CommentEnd(){

if (in_str[in_pos]=='{'){

out_str[out_len] = '/';

out_str[out_len+1] = '*';

in_pos++;

out_len += 2;

while (in_str[in_pos]!='}' && in_pos<in_len) {

if (in_pos>=in_len) return;

out_str[out_len] = in_str[in_pos];

in_pos++;

out_len++;

}

out_str[out_len] = '*';

out_str[out_len+1] = '/';

in_pos++;

out_len += 2;

}

else{

out_str[out_len] = '/';

out_str[out_len+1] = '*';

in_pos += 2;

out_len += 2;

while (!(in_str[in_pos]=='*' && in_str[in_pos+1]==')')

&& in_pos<in_len) {

if (in_pos>=in_len) return;

out_str[out_len] = in_str[in_pos];

in_pos++;

out_len++;

}

out_str[out_len] = '*';

out_str[out_len+1] = '/';

in_pos += 2;

out_len += 2;

}

put_simvol('\n');

}

// проверка на ключевое слово

int f_KS(){

for (int i=0; i<KS_kol; i++){

if (!scmp(&in_str[in_pos],KS_mas[i],s_dlin))

return i+1;

}

return 0;

}

//функция обработки label

int func_label(int gl)

{

skip_space();

while(1){

if (s_type!=s_str||f_KS()|| gl>0&&type_var() ) return 0;

read_Slova();

dob_var(gl);

set_type(gl,type_Label);

skip_space();

if (in_str[in_pos]==','){

in_pos++;

} else break;

};

if (in_str[in_pos]!=';') return 0;

in_pos++;

return 1;

}

//функция объявления переменных

int func_Real_Bool_Label(int svar, int gl){

char s[256];

int label;

int sp = 0;

read_Slova();

while (1){

if (s_type!=s_str||f_KS()|| gl>0&&type_var() ) return 0;

dob_var(gl);

if (svar) {

s[sp] = '&';

s[sp+1] = ' ';

sp += 2;

}

memcpy(&s[sp],&in_str[in_pos],s_dlin);

in_pos += s_dlin;

sp += s_dlin;

read_Slova();

if (in_str[in_pos]==','){

s[sp]=',';

in_pos++;

sp++;

} else break;

read_Slova();

}

if (in_str[in_pos]==':'){

in_pos++;

read_Slova();

if (s_type!=s_str) return 0;

if (!scmp(&in_str[in_pos],"boolean",s_dlin)){

set_type(gl,type_Bool);

put_stroku("int ");

skip_space();

memcpy(&out_str[out_len],&s[0],sp);

out_len += sp;

}

else

if (!scmp(&in_str[in_pos],"real",s_dlin)){

set_type(gl,type_Real);

put_stroku("float ");

skip_space();

memcpy(&out_str[out_len],&s[0],sp);

out_len += sp;

}

}

else if(label==ks_label) return 1;

else return 0;

return 1;

}

//обработка описания блока переменных

int func_var(int gl){

in_pos += s_dlin;

read_Slova();

do{

kol_err_1++;

if (func_Comment()){

func_CommentEnd();

kol_err_2++;

continue;

}

put_otstup();

if (f_KS()==ks_label)

{func_label(gl);}

if (!func_Real_Bool_Label(0,gl)) {func_Error();}

else kol_err_2++;

 read_Slova();

if (in_str[in_pos]!=';')

return 0;

skip_space();

put_stroku(";\n");

read_Slova();

if (s_type!=s_str || f_KS())

return 1;

}while(1);

}

//обработка блока описания переменных

int func_vardescr(){

in_pos += s_dlin;

int k,svar;

read_Slova();

do{

k = f_KS();

svar = k==ks_var;

if (svar) {

skip_space();

read_Slova();

}

if (!func_Real_Bool_Label(svar,0)) return 0;

read_Slova();

if (in_str[in_pos]!=';') return 1;

skip_space();

put_stroku(", ");

read_Slova();

k= f_KS();

if (s_type!=s_str || k&&k!=ks_var) return 0;

}while(1);

}

//функция обработки goto

int func_goto()

{

skip_space();

put_otstup();

put_stroku("goto ");

read_Slova();

f_copy();

if (in_str[in_pos]!=';') return 0;

put_stroku(";\n");

in_pos++;

return 1;

}

//функция обработки read

int func_read(int ln){

char s[256];

int sp;

int t;

skip_space();

put_otstup();

put_stroku("scanf");

read_Slova();

if (in_str[in_pos]!='(') return 0;

in_pos++;

put_stroku("(\"");

sp=0;

while (1) {

read_Slova();

if (s_type!=s_str) return 0;

t = type_var();

if (t==type_Real) put_stroku("%f");

else return 0;

s[sp] = '&';

sp += s_dlin;

memcpy(&s[sp],&in_str[in_pos],s_dlin);

in_pos += s_dlin;

sp += s_dlin;

read_Slova();

if (in_str[in_pos]!=',') break;

s[sp] = in_str[in_pos];

in_pos++;

sp++;

}

put_stroku("\",");

memcpy(&out_str[out_len],s,sp);

out_len += sp;

read_Slova();

if (in_str[in_pos]!=')') return 0;

in_pos++;

put_simvol(')');

 read_Slova();

if (in_str[in_pos]!=';') return 0;

in_pos++;

if (ln) put_stroku("; printf(\"\\n\");\n");

else put_stroku(";\n");

return 1;

}

int func_ae() {

read_Slova();

if (in_str[in_pos]=='+'){

f_copy();

}

else

if (in_str[in_pos]=='-'){

f_copy();

}

while (1){

read_Slova();

if (s_type==s_numb) f_copy(); else

if (s_type==s_str&&type_var()==type_Real) f_copy(); else

if (s_type==s_str&&type_var()==type_Label) f_copy();

else return 0;

 read_Slova();

char c = in_str[in_pos];

if (c=='+'||c=='-'||c=='*'||c=='/') f_copy();

else return 1;

}

}

//обработка арифметического выражения

int ae(){

char c,c1;

if (!func_ae()) return 0;

read_Slova();

c = in_str[in_pos];

c1 = in_str[in_pos+1];

if (c=='<'&&c1=='>') {

in_pos += 2;

put_stroku("!=");

}

else

if (c=='=') {

in_pos++;

put_stroku("==");

}

else

if (c=='>'||c=='<') {

if (c1=='='){

in_pos += 2;

}

else f_copy();

}

read_Slova();

if (!func_ae()) return 0;

return 1;

}

//обработка логического выражения

int func_le() {

int k;

char c,c1;

int arifm, ip,op;

while (1){

read_Slova();

k = f_KS();

int ip, op;

ip = in_pos;

op = out_len;

arifm = 0;

if(in_str[in_pos]=='+'||

in_str[in_pos]=='('||

in_str[in_pos]=='-'||

s_type==s_str&&!f_KS() ||

s_type==s_numb)

arifm = ae();

if (!arifm){

in_pos = ip;

out_len = op;

 read_Slova();

k = f_KS();

if (s_type==s_str&&k==ks_true){

skip_space();

put_simvol('1');

}

else

if (s_type==s_str&&k==ks_false) {

skip_space();

put_simvol('0');

}

else

if (s_type==s_str&&type_var()==type_Bool) f_copy(); else

if (in_str[in_pos]=='('){

f_copy();

if (!func_le()) return 0;

read_Slova();

if (in_str[in_pos]!=')') return 0;

in_pos++;

put_simvol(')');

}

else return 0;

}

read_Slova();

k = f_KS();

if (k==ks_or) put_stroku("||"); else

if (k==ks_and) put_stroku("&&");

else return 1;

skip_space();

}

}

// функция обработки присваивания

int func_asign(){

int type = type_var();

if (!(type==type_Bool||type==type_Real||type==type_Label)) return 0;

put_otstup();

f_copy();

read_Slova();

if((type==type_Label)&&in_str[in_pos]==':')

{

f_copy();

in_pos++;

put_simvol('\n');

return 1;

}

if (in_str[in_pos]!=':'||in_str[in_pos+1]!='=')

return 0;

put_simvol('=');

in_pos +=2;

if (type==type_Bool) {

if (!func_le()) return 0;

}

else

if (!func_ae()) return 0;

read_Slova();

if (in_str[in_pos]!=';') return 0;

f_copy();

put_simvol('\n');

return 1;

}

//функция обработки основной программы

int func_begin(int gl){

int rep_n = 0;

if(gl!=3) skip_space();

if (gl==1) put_stroku("\n\nvoid main()\n");

if ((gl!=2)||(gl!=3)) {

put_otstup();

put_stroku("{\n");

inc_otstup();

}

int b;

do{

b = 1;

read_Slova();

if (func_Comment()){

func_CommentEnd();

continue;

}

switch(f_KS()){

case ks_begin:

kol_err_1++;

if (!func_begin(0)) return 0;

kol_err_2++;

break;

case ks_read:

kol_err_1++;

if (!func_read(0)) return 0;

kol_err_2++;

break;

case ks_readln:

kol_err_1++;

if (!func_read(1)) return 0;

kol_err_2++;

break;

case ks_goto:

kol_err_1++;

if (!func_goto()) return 0;

break;

case ks_end:

kol_err_1++;

if(gl == 3) return 3;

skip_space();

dec_otstup();

put_otstup();

put_stroku("}\n");

read_Slova();

if (gl==1&&in_str[in_pos]=='.' ||

gl!=1&&in_str[in_pos]==';'){

skip_space();

kol_err_2++;

return 1;

}

else

{

skip_space();

return 0;

}

case 0:

if (!func_asign()) return 0;

break;

default:

return 0;

}

} while (b);

return 1;

}

//функция преобразование текста

int Translate()

{

int b;

int k;

kol_err_1 = kol_err_2 = 0;

put_stroku("#include <stdio.h>\n\n");

do{

b = 1;

read_Slova();

k = f_KS();

if (k==ks_var){

kol_err_1++;

if (!func_var(1)) {

func_Error();

}

else kol_err_2++; }

else

if(k==ks_label)

{

kol_err_1++;

if(!func_label(1)){ func_Error();}

}

else

if (k==ks_begin){

if (!func_begin(1)) {

func_Error();

}

b = 0;

}

else

if (func_Comment()) func_CommentEnd();

else {

kol_err_1++;

func_Error();

};

} while (b==1);

 if (in_str[in_pos]!='.') return 0;

in_pos++;

return 1;

}

void main()

{

int pr=1;

setlocale(LC_ALL,"Russian");

char s[128];

printf("Введите имя входного файла: ");

scanf("%s",s);

if (!Open_Text(s))

{

printf("\nОшибка! Невозможно открыть файл!\nПроверьте правильность пути и имя файла.");

}

vars = NULL;

lvars = NULL;

Translate();

osv_vars(1);

printf("\nВведите имя выходного файла:");

scanf("%s",s);

if (!Put_Text(s))

{

printf("\nОшибка! Невозможно создать файл!\nВозможно использование данного имени запрещенно или указан неверный путь.");

pr=0;

}

if(pr==1) {

printf("\nКоличество операторов в исходном файле: %d", kol_err_1);

printf("\nКоличество операторов в полученном файле: %d", kol_err_2);

printf("\nКоличество ошибочных операторов которые не были обработаны: %d", k_er);

printf("\n\nРезультат хранится в %s",s);

}

fclose(in_file);

fclose(out_file);

while (!kbhit()) ;

}