bill
/
AwesomePascal
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tag: Branch: Tree: 34bfb096d1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '34bfb096d1'
${ noResults }
AwesomePascal/ConsoleApplication18/ConsoleApplication18.cpp

1427 lines
31 KiB
Raw Blame History

// ConsoleApplication18.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <deque>
#include <stack>
#include <vector>
#include <set>
#include <cstdarg>
#include <cstdio>
#include <valarray>
#include <iostream>
#define MAX_BUFFER 102400
char buffer[MAX_BUFFER + 2];
using namespace std;
enum Preservations {CONST, VAR, PROCEDURE, BEGIN, END, DOT/*EOF*/, COMMA, SEMICOLON/*END OF STATEMENT*/, IF, THEN, ELSE, CALL, READ, WRITE,
PLUS, MINUS, DIVISION, MULTIPLE, WHILE, DO, ASSIGNMENT, LP, RP, ODD, EQUAL, GREATER, LESS, GREATEREQ, LESSEQ, NOTEQ};
enum States { P, SP, C, V, PRO, CDEF, INIT, VDEF, ST, MORE, COND, EXP, EXP2, ARITH, ARI2, TERM, FACTS, MULDIV, FACT };
enum Operations{ INT, JMP, LIT, OPR, STO, CAL, JPC, LOD, SIO };//pl/0 USER MANUAL
const char *operations[] { "INT", "JMP", "LIT", "OPR", "STO", "CAL", "JPC", "LOD", "SIO" };
const char *preservations[] = { "CONST", "VAR", "PROCEDURE", "BEGIN", "END", ".", ",", ";", "IF", "THEN", "ELSE", "CALL","READ", "WRITE", "+", "-",
"/", "*", "WHILE", "DO", ":=", "(", ")", "ODD", "=", ">", "<", ">=", "<=", "#"};
int *** states, **follows ;
inline int** init_st(int i, ...);
enum Type { PSR, SYM, NUM };
//short status_pers_match = {false}; FOR LATER
#define P(a) a + 3
#define S(a) P(a) + NOTEQ + 1
#define DeS(a) a - 4 - NOTEQ
#define _S(a) a >= S(0) && a <= S(FACT)
#define init_follow(...) init_st(__VA_ARGS__, -1)[0]
#define A_MOD P(EQUAL)
struct IDS {
int type;
int index;
IDS(int type, int index) {
this->type = type;
this->index = index;
}
}**pres;
template <class T>
struct HASH {
IDS *id;
char* value;
unsigned int* int_value;
HASH(char* value, int index)
{
this->value = value;
int_value = NULL;
if (value[0] < '0' || value[0] > '9')
id = new IDS(1, index);
else
{
id = new IDS(2, index);
int_value = new unsigned int(0);
int length = strlen(value);
for (int i = 0; i < length; i++)
{
*int_value *= 10;
*int_value += value[i] - 48;
}
}
}
~HASH()
{
if (int_value != NULL)
delete(int_value);
}
};
vector<HASH<char*> *> sym;
vector<HASH<unsigned int*> *> num;
struct GrammaUnit {
int *follows;
};
deque<IDS*> identifiers;
void GETSYM() {
char* bp = buffer, token;
int n_syms = NOTEQ + 2;
unsigned char flags[1024] = { true };
int index = 0, lastLength = 0;
int j = 0, n_pre = 0, n_ids = 0, n_ids_const, n_nums = 0, n_nums_const , i = 0, nums_offset = 0, n_pre_const = 0;
bool takein = false, lastTaken = false;
IDS *lastMatch;
//init
pres = new IDS*[NOTEQ];
for (j = 0; j <= NOTEQ; j++) {
pres[j] = new IDS(0, j);
}
while (*bp) {
takein = false;
lastTaken = false;
if (!index)
{
while (*bp == '\t' || *bp == '\n' || *bp == ' ' || *bp == '\r')
bp++;
n_pre = NOTEQ + 1;
n_pre_const = n_pre + 1;
n_nums_const = n_nums = num.size();
n_ids_const = n_ids = sym.size();
nums_offset = n_pre_const + n_ids_const + 1;
n_syms = NOTEQ + n_nums_const + n_ids_const + 3;
for (j = 0; j < n_syms; j++)
flags[j] = false;
if (*bp == '_' || (*bp >= 'a' && *bp <='z') || (*bp >= 'A' && *bp <= 'Z'))
flags[nums_offset - 1] = true;
else if (*bp >= '0' && *bp <= '9')
flags[n_pre] = true;
else
flags[nums_offset - 1] = flags[n_pre] = true;
lastMatch = 0;
lastLength = 0;
}
//pre
for (j = 0; j <= NOTEQ && n_pre > 0; j++)
if (!flags[j])
{
token = preservations[j][index];
if (!token)
{
flags[j] = 2;
lastMatch = pres[j];
lastLength = index - 1;
lastTaken = true;
n_pre--;
}
else {
if (*bp != token && (*bp != (token+ 32) || token <'A' || token >'Z'))
{
flags[j] = true;
n_pre--;
}
else {
takein = true;
}
}
}
if (!flags[n_pre_const - 1])
{
//id-todo - 1
//id-hasbeen
for (i = 0; i < n_ids_const && n_ids > 0; i++)
{
if (!flags[n_pre_const + i])
{
if (sym[i]->value[index])
{
if (*bp == sym[i]->value[index])
takein = true;
else {
flags[n_pre_const + i] = true;
n_ids--;
}
}
else if (!lastTaken)
{
flags[n_pre_const + i] = 2;
lastMatch = sym[i]->id;
lastLength = index - 1;
n_ids--;
lastTaken = true;
}
}
}
if (*bp == '_' || (*bp >= 'a' && *bp <= 'z') || (*bp >= 'A' && *bp <= 'Z') || (*bp >= '0' && *bp <= '9'))
{
takein = true;
}
else if (index != 0 && !lastTaken)
{
char* tmp = new char[index];
for (j = 0; j < index; j++)
tmp[j] = (bp-index)[j];
tmp[index] = 0;
sym.push_back(new HASH<char *> (tmp,n_ids_const));
lastMatch = sym.back()->id;
lastLength = index - 1;
flags[n_pre_const - 1] = true;
}
else {
flags[n_pre_const - 1] = true;
}
}
else if (!flags[nums_offset - 1]) {
for (i = 0; i < n_nums_const && n_nums > 0; i++)
if (!flags[nums_offset + i])
{
if (num[i]->value[index])
{
if (*bp == num[i]->value[index])
takein = true;
else {
flags[nums_offset + i] = true;
n_nums --;
}
}
else if (!lastTaken)
{
flags[nums_offset + i] = 2;
lastMatch = num[i]->id;
lastLength = index - 1;
n_nums --;
lastTaken = true;
}
}
if ((*bp >= '0' && *bp <= '9'))
{
takein = true;
}
else if(index != 0 && !lastMatch){
char* tmp = new char[index];
for (j = 0; j < index; j++)
tmp[j] = (bp - index)[j];
tmp[index] = 0;
num.push_back(new HASH<unsigned int *>(tmp, n_nums_const));
lastMatch = num.back()->id;
lastLength = index - 1;
flags[n_pre + n_ids_const + 1] = true;
}
else
flags[n_pre + n_ids_const + 1] = true;
}
if (takein)
{
bp++;
index++;
}
else if (lastMatch)
{
identifiers.push_back(lastMatch);
bp -= index - lastLength - 1;
index = 0;
}
else
{
cout << "undefined identifier " << *bp << endl;
exit(1);
}
}
if (index == 1 && *(bp - index) == '.')
identifiers.push_back(pres[DOT]);
for each (IDS *var in identifiers)
{
cout<<var->type<<'\t'<<var->index<< endl;
}
cout <<endl <<"Ints"<< endl;
for each (HASH<unsigned int *> *var in num)
{
cout << *(var->int_value) << endl;
}
cout << endl << "Syms" << endl;
for each (HASH<char*> *var in sym)
{
cout << var->value << endl;
}
}
struct Instruction {
int nop, lop, rop;
Instruction(int nop, int lop, int rop) {
this->nop = nop;
this->lop = lop;
this->rop = rop;
}
} *firstjump;
deque<pair<int, unsigned int>> *propos[1024];
bool checklist[1024];// = { true };
bool geting_proc = false;
deque<int> INTS;
int lv = -1, dx[1024] = { 0 };
void push();
template <typename T>
class cheque : public deque<T> {
public:
void push_back(T&& _Val )
{
if (!checklist[lv])
{
if (lv)
propos[lv - 1]->back().second = this->size();
else
firstjump->rop = this->size();
checklist[lv] = true;
push();
}
printf("inserting instructions...");
deque<T>::push_back(_Val);
}
void pb(T&& _Val)
{
deque<T>::push_back(_Val);
}
};
cheque<Instruction *> instructions;
void push() {
instructions.pb(new Instruction(INT, 0, INTS.back() + 1));
INTS.pop_back();
}
inline int** init_st(int i, ...) {
int j = 0, k = 1, t;
int **p = new int*[16];
va_list arg_ptr;
va_start(arg_ptr, i);
p[0] = new int[8];
t = i;
p[0][0] = i;
do {
if (t == -2)
{
p[++j] = new int[8];
k = 0;
}
t = va_arg(arg_ptr, int);
p[j][k++] = t;
} while (t != -1);
p[j + 1] = new int(-3);
va_end(arg_ptr);
return p;
}
inline int is_not_mod(int modifier){
return (modifier >= P(EQUAL) && modifier <= P(NOTEQ)) ? A_MOD : modifier;
}
struct Reduced{
int type;//S
void* param;
Reduced(int type, void* param){
this->type = type;
this->param = param;
}
Reduced(int type) { //P
this->type = type;
}
~Reduced() {
free(param);
}
};
class Indexes {
public:
int i, j, k;
Indexes(int i, int j, int k){
this->i = i;
this->j = j;
this->k = k;
}
Indexes(){
i = j = k = 0;
}
bool operator<(Indexes a) const
{
if (i == a.i)
if (j == a.j)
return k < a.k;
else
return j < a.j;
else
return i < a.i;
}
};
stack<int> lastSP;
deque<Reduced *> buf;
deque<pair<deque<pair<int, unsigned int>>, int>> vartable;
deque<IDS *>::iterator it;
Reduced *nextSym = 0;
stack<set<Indexes>> archive;
struct Pos {
int start, end;
};
Reduced* peekNext()
{
if (!nextSym) {
if (it != identifiers.end())
switch ((*it)->type)
{
case 0:
return new Reduced(P((*it)->index), NULL);
case 1:
return new Reduced(1, (void *)&(*it)->index);
case 2:
return new Reduced(2, (void *)num[(*it)->index]->int_value);
default:
printf("Are you an asshole? An unchecked list? Fuck off.");
exit(1);
}
else
return NULL;
}
else return nextSym;
}
int address = 0;
bool Next() {
if (nextSym)
{
nextSym = NULL;
return true;
}
else if (it == identifiers.end())
return false;
it++;
address++;
return true;
}
Reduced* getNext()
{
Reduced *n = peekNext();
Next();
return n;
}
inline void pop(const int &i, const int &j) {
int k = 0;
while (states[i][j][k++]>0)
buf.pop_back();
}
inline void popArchive(const int&i, const int &j) {
int k = 0;
while (states[i][j][k++] > 0)
archive.pop();
}
inline bool searchTableforVar(const int& param, int &level, int &d, bool &found, const bool con = false)
{
for each (pair<deque<pair<int, unsigned int>>, int> var in vartable)
{
if (var.second == 1 || var.second ==0 && con)
{
for each (pair<int, unsigned int> v in var.first)
{
if (v.first == param)
{
level /= 3;
d = v.second;
found = true;
break;
}
}
if (found)
{
//level--;
return (bool)var.second;
}
}
level++;
}
}
Reduced* reduce(int i, int j) {
//popArchive(i, j);
void *param = new int(0);
switch (i)
{
case P:
{
pop(i, j);
if (!Next())
cout << "succeed" << endl;
}
break;
case SP:
{
instructions.push_back(new Instruction(OPR, 0, 0));
lv--;
pop(i, j);
}
break;
case C:
{
lv++;
checklist[lv] = 0;
if (vartable.empty())
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 0));
else if (vartable.back().second)
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 0));
pop(i, j);
}
break;
case CDEF:
pop(i, j);
break;
case INIT:
{
if (vartable.empty())
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 0));
else
if (vartable.back().second)
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 0));
pair<deque<pair<int, unsigned int>>, int> *top = &vartable.back();
Reduced* last = buf.back();
if (last->type != 2)
cout << "Reducing Error: Expecting a number." << endl;
unsigned int intval = *((unsigned int *)last->param);
buf.pop_back();
buf.pop_back();
last = buf.back();
if (last->type != 1)
cout << "Reducing Error: Expecting a number." << endl;
int index = *((int *)last->param);
top->first.push_back(pair<int, unsigned int>(index, intval));
buf.pop_back();
}
break;
case V:
{
if (vartable.back().second != 1)
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 1));
if (j == 1)
{
buf.pop_back();
buf.pop_back();
Reduced *last = buf.back();
pair<deque<pair<int, unsigned int>>, int> *top = &vartable.back();
top->first.push_back(pair<int, unsigned int>(*((int *)last->param), dx[lv]++));
//instructions.push_back(new Instruction(INT, 0, vartable.back().first.size() + 2));
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 2));
propos[lv] = &vartable.back().first;
buf.pop_back();
buf.pop_back();
}
INTS.push_back(vartable[vartable.size() - 2].first.size() + 2);
}
break;
case VDEF:
if (j == 1)
{
buf.pop_back();
Reduced *last = buf.back();
if (vartable.empty())
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 1));
else
if (vartable.back().second != 1)
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque<pair<int, unsigned int>>(), 1));
pair<deque<pair<int, unsigned int>>, int> *top = &vartable.back();
top->first.push_back(pair<int, unsigned int>(*((int *)last->param), dx[lv]++));
buf.pop_back();
buf.pop_back();
}
break;
case PRO:
if (j == 1)
{
buf.pop_back();
buf.pop_back();
buf.pop_back();
/*
if (vartable.empty())
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque < pair<int, unsigned int>>(), 2));
else if (vartable.back().second!=1)
vartable.push_back(pair<deque<pair<int, unsigned int>>, int>(deque < pair<int, unsigned int>>(), 2));
pair<deque<pair<int, unsigned int>>, int> *top = &vartable.back();
Reduced* name = buf.back();
top->first.push_back(pair<int, unsigned int>(*((int *)name->param), lastSP.top()));
lastSP.pop();
*/
buf.pop_back();
buf.pop_back();
}
break;
case ST:
switch (j)
{
case 1:
{
buf.pop_back();
buf.pop_back();
int pa = *((int *)buf.back()->param);
buf.pop_back();
bool found = false;
int level = 0, d;
searchTableforVar(pa, level, d, found);
if (!found)
cout << "Error: undefined identifier " << sym[pa]->value << endl;
else
instructions.push_back(new Instruction(STO, level, d));
}
break;
case 2:
{
//JMP
int pa = *((int *)buf.back()->param);
buf.pop_back();
bool found = false;
int pos = 0;
for each (pair<deque<pair<int, unsigned int>>, int> var in vartable)
{
if (var.second == 2)
{
for each (pair<int, unsigned int> v in var.first)
{
if (v.first == pa)
{
pos = v.second;
found = true;
break;
}
}
}
}
if (!found)
cout << "Error: undefined procedure " << sym[pa]->value << endl;
buf.pop_back();
instructions.push_back(new Instruction(JMP, 0, pos));
}
break;
case 3:
pop(i, j);
break;
case 4:
{
buf.pop_back();
buf.pop_back();
Reduced *cond = buf.back();
instructions[((Pos *)(cond->param))->end]->rop = instructions.size();
buf.pop_back();
buf.pop_back();
}
break;
case 5:
{
buf.pop_back();
buf.pop_back();
Reduced *cond = buf.back();
instructions.push_back(new Instruction(JMP, 0, ((Pos *)cond->param)->start + 1));
instructions[((Pos *)(cond->param))->end]->rop = instructions.size();
buf.pop_back();
buf.pop_back();
}
break;
case 6:
{
int level = 0, d;
bool found = false;
buf.pop_back();
searchTableforVar((*(int *)buf.back()->param), level, d, found);
if (found)
{
instructions.push_back(new Instruction(SIO, 0, 2));
instructions.push_back(new Instruction(STO, level, d));
}
else
cout << "Error: Undefined parameter: " << sym[*(int*)buf.back()->param]->value << endl;
buf.pop_back();
buf.pop_back();
buf.pop_back();
}
break;
case 7:
{
int level = 0, d;
bool found = false;
buf.pop_back();
Reduced *id = buf.back();
if (id->type == 1)
{
searchTableforVar((*(int *)(id->param)), level, d, found);
if(found)
instructions.push_back(new Instruction(LOD, level, d));
else
cout << "Error: Undefined parameter: " << sym[*(int*)buf.back()->param]->value << endl;
}
else if (id->type == 2)
instructions.push_back(new Instruction(LIT, 0, *((int *)id->param)));
else
cout << "Error: Undefined parameter: " << *(int*)buf.back()->param - 3 << endl;
instructions.push_back(new Instruction(SIO, 0, 1));
buf.pop_back();
buf.pop_back();
buf.pop_back();
}
break;
case 8:
buf.pop_back();
default:
break;
}
break;
case MORE:
pop(i, j);
break;
case COND:
{
Pos *position = new Pos();
switch (j)
{
case 0:
{
Reduced* exp = buf.back();
position->start = *((int *) exp->param);
instructions.push_back(new Instruction(OPR, 0, 6));
instructions.push_back(new Instruction(JPC, 0, -1));
buf.pop_back();
buf.pop_back();
}
break;
case 1:
{
Reduced* r;
int rop = -1;
buf.pop_back();
r = buf.back();
switch (r->type)
{
case P(GREATER):
rop = 12;
break;
case P(LESS):
rop = 10;
break;
case P(GREATEREQ):
rop = 13;
break;
case P(LESSEQ):
rop = 11;
break;
case P(NOTEQ):
rop = 9;
break;
case P(EQUAL):
rop = 8;
break;
default:
cout << "Error: Expected an condition modifier." << endl;
break;
}
if (rop == 9)
{
instructions.push_back(new Instruction(OPR, 0, 8));
instructions.push_back(new Instruction(LIT, 0, 0));
instructions.push_back(new Instruction(OPR, 0, 8));
}
else
instructions.push_back(new Instruction(OPR, 0, rop));
instructions.push_back(new Instruction(JPC, 0, -1));
buf.pop_back();
r = buf.back();
position->start = *((int*)r->param);
buf.pop_back();
}
break;
default:
break;
}
//push
position->end = instructions.size() - 1;
param = (void *)position;
}
break;
case EXP:
{
buf.pop_back();
Pos* pos = (Pos *)buf.back()->param;
int end = pos->end, *start = new int(pos->start);
deque<Instruction *>::iterator iter = instructions.begin() + end;
buf.pop_back();
int ari2 = *((int *)buf.back()->param);
if (ari2)
(*iter)->rop = 1;
else
instructions.erase(iter);
//if((*iter)->)
param = start;
buf.pop_back();
}
break;
case EXP2:
if(j == 1)
{
buf.pop_back();
int end = ((Pos *)buf.back()->param)->end;
buf.pop_back();
int arith = *((int *)buf.back()->param);
if (arith)
instructions[end]->rop = 3;
else
instructions[end]->rop = 2;
buf.pop_back();
}
break;
case ARITH:
{
buf.pop_back();
param = new int(j);
}
break;
case ARI2:
if (j == 0)
param = new int(0);
else
{
param = new int(*((int *)buf.back()->param));
buf.pop_back();
}
break;
case TERM://head
{
int end = *((int *)buf.back()->param);
buf.pop_back();
if (end == 0)
end = ((Pos *)buf.back()->param)->end;
int start = ((Pos *)buf.back()->param)->start;
instructions.erase((instructions.begin() + end));
instructions.push_back(new Instruction(OPR, 0, -2));
buf.pop_back();
end = instructions.size() - 1;
Pos *pos = new Pos();
pos->start = start;
pos->end = end;
param = pos;
}
break;
case FACTS:
if (j == 1)
{
int change = *((int*)buf.back()->param);//FACTS.end
buf.pop_back();
int end = ((Pos *)buf.back()->param)->end;//fact->end
buf.pop_back();
int muldiv = *((int *)buf.back()->param);
if (muldiv)
instructions[end]->rop = 5;
else
instructions[end]->rop = 4;
param = new int((!change) ? change : end);
buf.pop_back();
}
break;
case MULDIV:
{
buf.pop_back();
param = new int (j);
}
break;
case FACT:
{
Pos* pos = new Pos();
switch (j) {
case 0:
{
int level = 0, d;
bool found = false;
pos->start = instructions.size() - 1;
bool type = searchTableforVar(*((int *)buf.back()->param), level, d, found, true);
buf.pop_back();
if (found && type)
instructions.push_back(new Instruction(LOD, level, d));
else if(found && !type)
instructions.push_back(new Instruction(LIT, 0, d));
else
cout << "Error: Unfefined identifier: " << sym[*((int *)buf.back()->param)]->value << endl;
}
break;
case 1:
{
pos->start = instructions.size() - 1;
instructions.push_back(new Instruction(LIT, 0, *((int *)buf.back()->param)));
buf.pop_back();
}
break;
case 2:
{
buf.pop_back();
Reduced *exp = buf.back();
pos->start = *((int *)exp->param);
buf.pop_back();
buf.pop_back();
}
break;
default:
break;
}
instructions.push_back(new Instruction(OPR, 0, -1));
pos->end = instructions.size() - 1;
param = (void *)pos;
}
break;
}
return new Reduced(S(i), param);
}
void initStates() {
states = new int**[FACT + 1];
states[P] = init_st(S(SP), P(DOT), -1);
states[SP] = init_st(S(C), S(V), S(PRO), S(ST), P(SEMICOLON), -1);
states[C] = init_st(-2, P(CONST), S(INIT), S(CDEF), P(SEMICOLON), -1);
states[CDEF] = init_st(-2, P(COMMA), S(INIT), S(CDEF), -1);
states[INIT] = init_st(1, P(EQUAL), 2, -1);
states[V] = init_st(-2, P(VAR), 1, S(VDEF), P(SEMICOLON), -1);
states[VDEF] = init_st(-2, P(COMMA), 1, S(VDEF), -1);
states[PRO] = init_st(-2, P(PROCEDURE), 1, P(SEMICOLON), S(SP), S(PRO), -1);
states[ST] = init_st(-2, 1, P(ASSIGNMENT), S(EXP), -2, P(CALL), 1, -2,
P(BEGIN), S(ST), S(MORE), P(END), -2, P(IF), S(COND), P(THEN), S(ST), -2,
P(WHILE), S(COND), P(DO), S(ST), -2, P(READ), P(LP), 1, P(RP), -2, P(WRITE),
P(LP), 1, P(RP), -2, P(SEMICOLON), - 1);
states[MORE] = init_st(-2, P(SEMICOLON), S(ST), S(MORE), -1);
states[COND] = init_st(P(ODD), S(EXP), -2, S(EXP), A_MOD, S(EXP), -1);
states[EXP] = init_st(S(ARI2), S(TERM), S(EXP2), -1);
states[EXP2] = init_st(-2, S(ARITH), S(TERM), S(EXP2), -1);
states[ARITH] = init_st(P(PLUS), -2, P(MINUS), -1);
states[ARI2] = init_st(-2, S(ARITH), - 1);
states[TERM] = init_st(S(FACT), S(FACTS), -1);
states[FACTS] = init_st(-2, S(MULDIV), S(FACT), S(FACTS), -1);
states[MULDIV] = init_st(P(MULTIPLE), -2, P(DIVISION), -1);
states[FACT] = init_st(1, -2, 2, -2, P(LP), S(EXP), P(RP), -1);
follows = new int*[FACT + 1];
follows[P] = init_follow(-1);
follows[SP] = init_follow(P(DOT), P(END), P(SEMICOLON), P(BEGIN), P(CALL), P(IF), P(WHILE), P(READ), P(WRITE), 1, P(PROCEDURE));
follows[C] = init_follow(P(VAR), P(END), P(SEMICOLON), P(BEGIN), P(CALL), P(IF), P(WHILE), P(READ), P(WRITE), 1, P(PROCEDURE));
follows[CDEF] = init_follow(P(SEMICOLON));
follows[INIT] = init_follow(P(SEMICOLON), P(COMMA));
follows[V] = init_follow(P(SEMICOLON), P(PROCEDURE), P(END), P(BEGIN), P(CALL), P(IF), P(WHILE), P(READ), P(WRITE), 1);
follows[VDEF] = init_follow(P(SEMICOLON));
follows[PRO] = init_follow(P(END), P(SEMICOLON), P(BEGIN), P(CALL), P(IF), P(WHILE), P(READ), P(WRITE), 1);
follows[ST] = init_follow(P(END), P(SEMICOLON));
follows[MORE] = init_follow(P(END));
follows[COND] = init_follow(P(THEN), P(DO));
follows[EXP] = init_follow(A_MOD, P(THEN), P(DO), P(RP), P(END), P(SEMICOLON));
follows[EXP2] = init_follow(A_MOD, P(THEN), P(DO), P(RP), P(END), P(SEMICOLON));
follows[ARITH] = init_follow(1, 2, P(LP));
follows[ARI2] = init_follow(1, 2, P(LP));
follows[TERM] = init_follow(P(PLUS), P(MINUS), A_MOD, P(THEN), P(DO), P(RP), P(END), P(SEMICOLON));
follows[FACTS] = init_follow(P(PLUS), P(MINUS), A_MOD, P(THEN), P(DO), P(RP), P(END), P(SEMICOLON));
follows[MULDIV] = init_follow(1, 2, P(LP));
follows[FACT] = init_follow(P(MULTIPLE), P(DIVISION), P(PLUS), P(MINUS), A_MOD, P(THEN), P(DO), P(END), P(SEMICOLON), P(RP));
instructions.pb(new Instruction(JMP, 0, -1));
firstjump = instructions[0];
checklist[0] = true;
}
//stack<void(*) (deque<IDS*>::iterator)> callback;
inline void expend(set<Indexes> &togo) {
int size0, j;
do {
size0 = togo.size();
for each (Indexes var in togo)
{
j = states[var.i][var.j][var.k];
int i;
if (_S(j))
for (i = 0; i < 16; i++) {
if (states[DeS(j)][i][0] == -3)
break;
else
togo.insert(Indexes(DeS(j), i, 0));
}
}
} while (size0 != togo.size());
}
void Shift(set<Indexes> togo) {
if (lv == 0)
int null = 1;
if (address == 75)
int fuck = 1;
//shifting
Reduced* nextsym = peekNext();
set<Indexes> tobeReduced;
int nexttype = is_not_mod(nextsym->type), t;
archive.push(togo);
set<Indexes>::pointer pt;
set<Indexes>::iterator var = togo.begin();
while(var != togo.end()){
t = states[var->i][var->j][var->k];
if (t < 0)
{
tobeReduced.insert(Indexes(var->i, var->j, 0));
var = togo.erase(var);
if (togo.empty())
break;
}
else if (t != nexttype)
{
var = togo.erase(var);
if (togo.empty())
break;
}
else
var++;
}
//reducing
int FOL;
bool match;
int j;
var = tobeReduced.begin();
//reduce conflict.
while (var != tobeReduced.end())
{
j = 0;
match = false;
FOL = follows[var->i][j++];
while (FOL > 0)
if (is_not_mod(nextsym->type) == FOL)
{
match = true;
break;
}
else
FOL = follows[var->i][j++];
if (!match)
var = tobeReduced.erase(var);
else
var++;
if (tobeReduced.empty())
break;
}
if (tobeReduced.size() > 0)
{
int i = tobeReduced.begin()->i, k = 0;
j = tobeReduced.begin()->j;
nextSym = reduce(i, j);
while (states[i][j][k++] > 0)
archive.pop();
set<Indexes> togoNext = archive.top();
archive.pop();
Shift(togoNext);
return;
}
else if (Next())
{
if (!togo.empty())
{
set<Indexes> togoNext;
for each (Indexes var in togo){
var.k++;
togoNext.insert(var);
}
togo.clear();
expend(togoNext);
buf.push_back(nextsym);
if (nexttype == P(PROCEDURE) && !geting_proc)
geting_proc = true;
else if (geting_proc && nexttype == 1)
{
propos[lv]->push_back(pair<int, unsigned int>(*((int *)nextsym->param), INT_MAX));
checklist[lv] = false;
geting_proc = false;
}
Shift(togoNext);
}
}
}
void BLOCK() {
initStates();
it = identifiers.begin();
set<Indexes> going;
going.insert(Indexes(P, 0, 0));
//
expend(going);
Shift(going);
//callback.push(&I1);
// instructions[0]->rop = 1;//lastSP.top();
//lastSP.pop();
vartable.clear();
cout << address <<Next() << endl;
}
deque<void **> *memory;
deque<unsigned int> *t;
int PC, I;
void* b;
#define getij() _getij(i, j)
#define geti _geti(i)
inline void _getij(unsigned int &i, unsigned int &j) {
j = t->back();
t->pop_back();
i = t->back();
t->pop_back();
}
inline void _geti(unsigned int &i) {
i = t->back();
t->pop_back();
}
void PARSE() {
I = 0;
PC = -1;
unsigned int i, j;
memory = new deque<void **>;
while (I < instructions.size())
{
if (I == 44)
int fuck = 0;
cout << "\n inst "<< I << endl;
switch (instructions[I] ->nop)
{
case INT:
{
b = new void*[instructions[I]->rop];
memory->push_back((void **)b);
t = new deque<unsigned int>;
((void **)b)[0] = t;
((void **)b)[1] = b;
((void **)b)[2] = new int(PC);
}
break;
case OPR:
switch (instructions[I]->rop)
{
case 0:
{
if ((*(int *)(((void**)b)[2])) > 0)
I = (*(int *)(((void**)b)[2]));
else
return;
delete (deque<unsigned int> *)((void **)b)[0];
delete[]b;
memory->pop_back();
t = (deque<unsigned int > *)(memory->back()[0]);
b = memory->back()[1];
continue;
}
break;
case 1:
{
geti;
t->push_back(-i);
}
break;
case 2:
{
getij();
t->push_back(i + j);
}
break;
case 3:
{
getij();
t->push_back(i - j);
}
break;
case 4:
{
getij();
t->push_back(i * j);
}
break;
case 5:
{
getij();
if (j == 0)
{
cout << "Error: Division by zero" << endl;
exit(1);
}
t->push_back(i / j);
}
break;
case 6:
{
geti;
t->push_back((i % 2) != 0);
}
break;
case 8:
{
getij();
t->push_back(i == j);
}
break;
case 9:
{
getij();
t->push_back(i != j);
}
break;
case 10:
{
getij();
t->push_back(i < j);
}
break;
case 11:
{
getij();
t->push_back(i <= j);
}
break;
case 12:
{
getij();
t->push_back(i > j);
}
break;
case 13:
{
getij();
t->push_back(i >= j);
}
break;
}
break;
case SIO:
if (instructions[I]->rop == 2) {
cin >> i;
t->push_back(i);
}
else {
i = t->back();
t->pop_back();
cout << i;
}
break;
case LOD:
{
i = *(int *)(*memory)[instructions[I]->lop][instructions[I]->rop + 3];
t->push_back(i);
}
break;
case LIT:
t->push_back(instructions[I]->rop);
break;
case JMP:
I = instructions[I]->rop;
continue;
break;
case JPC:
{
geti;
if (!i)
{
I = instructions[I]->rop;
continue;
}
} break;
case STO:
{
geti;
(*memory)[instructions[I]->lop][instructions[I]->rop + 3] = new int(i);
}
break;
case CAL:
I = instructions[I]->rop;
break;
default:
cout << "Undefined Instruction: \n" << operations[instructions[I]->nop] << " " << instructions[I]->lop << " " << instructions[I]->rop << endl;
break;
}
I++;
PC = I + 1;
}
delete memory;
}
inline void test_main(){
cout << "************************Tests*************************" << endl;
valarray<int>
a;
void * pointer;
HASH<char*> fuck = HASH<char*>("fuck", 1);
pointer = &fuck;
((HASH<char*>*) pointer)->value;
printf("%s\n", ((HASH<char*>*) pointer)->value);
int *follow;
int f[] = { 1,2 };
follow = f;
printf("%d\n", P(NOTEQ));
it = identifiers.begin() + 2;
stack<set<Indexes>> st1;
set<Indexes > fucked;
st1.push(fucked);
fucked.insert(Indexes(1, 2, 3));
fucked.insert(Indexes(1, 4, 3));
fucked.insert(Indexes(3, 3, 2));
fucked.insert(Indexes(1, 2, 7));
fucked.insert(Indexes(1, 2, 3));
if (st1.top().size())
exit(1);
for each (Indexes var in fucked)
{
if (var.i == 1)
fucked.insert(Indexes(0, var.j, var.k));
cout << var.i << '\t' << var.j << '\t' << var.k << endl;
}
do {
while (false);
} while (false);
vector<bool> B;
vector<long double> LD;
B.push_back(1);
LD.push_back(1);
deque<Instruction *> deq;
deq.push_back(new Instruction(1, 2, 3));
deq.push_back(new Instruction(3, 4, 5));
deq.push_back(new Instruction(0, 3, 7));
deq.push_back(new Instruction(4, 7, 8));
//(deq.begin() + 2) =
deq.erase(deq.begin() + 1);
deque<Instruction *>::iterator iterat = deq.begin();
while (iterat != deq.end())
{
cout << (*iterat)->lop<<endl;
iterat++;
}
for (int i = 0; i < deq.size(); i++)
{
cout << deq[i]->lop << endl;
}
cout << "*********************Capacities***********************" << endl;
cout << B.capacity() << '\t' << LD.capacity() << endl;
cout << "*********************End Tests***********************" << endl;
}
int main(int argc, char** argv)
{
long length;
char* file = 0;
FILE *fp = NULL;
if (argc > 2)
fp = fopen(argv[1], "r");
//#ifdef _DEBUG
fp = fopen("input2.pas", "r");
// test_main();
//#endif
if (!fp)
file = new char[65536];
loop_input: while (!fp) {
cout << "Input the path of input file."<<endl;
scanf("%s", file);
fp = fopen(file, "r");
}
fseek(fp, 0, SEEK_END);
length = ftell(fp);
if (length > MAX_BUFFER)
{
cout << "Cannot handle now:)" << endl;
fclose(fp);
fp = NULL;
goto loop_input;
}
fseek(fp, 0, SEEK_SET);
free(file);
fread(buffer, 1, length, fp);
fclose(fp);
buffer[length] = ' ';
buffer[length] = EOF;
sym.reserve(512);
num.reserve(512);
//coping
GETSYM();
//PARSING
BLOCK();
//Interprating
/*for (int i = instructions.size() -1; i > 0; i--)
{
Instruction *var = instructions[i];
*/
int inst = 0;
for each (Instruction *var in instructions)
{
cout <<inst++ <<" "<< operations[var->nop] << " "<< var->lop << " "<< var->rop << endl;
}
PARSE();
return 0;
}
Reference in new issue View Git Blame Copy Permalink