int globalDecl() { //za decl nebrat token
if ((error = testToken(T_ID)) != E_OK) return error; //ID
if(BSTSearch(TempTree, T.s) != NULL){
return E_SEMA;
}
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error;
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error;
/******************************************INSERT***************************************************************/
if(!(strCmpConstStr(&(T.s), "boolean"))) TempVar->type = O_BOOL;
if(!(strCmpConstStr(&(T.s), "integer"))) TempVar->type = O_INT;
if(!(strCmpConstStr(&(T.s), "real"))) TempVar->type = O_REAL;
if(!(strCmpConstStr(&(T.s), "string"))){
TempVar->type = O_STRING;
strInit(&TempVar->value.sval);
}
BSTInsert (&TempTree, IDstr, TempVar);
/******************************************INSERT***************************************************************/
gettoken();
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // ";"
gettoken();
//strFree(&IDstr);
if (testToken(T_ID) == E_OK)
if ((error = globalDecl()) != E_OK) return error; //dalsia promena?
return E_OK;
}
int blockList() {
//printf("block list \n");
switch(T.type){
case T_KEYWORD:
if (!(strCmpConstStr (&(T.s), "end"))) {
return E_OK;
}
if ((error = commands()) != E_OK) return error;
if(semi == 1){
gettoken();
if (!(strCmpConstStr (&(T.s), "end"))) { //uprava
return E_SYN;
}
semi = 0;
}
if ((error = blockList()) != E_OK) return error;
return E_OK;
break;
case T_ID:
if ((error = commands()) != E_OK) return error;
if(semi == 1){
gettoken();
if (!(strCmpConstStr (&(T.s), "end"))) { //uprava
return E_SYN;
}
semi = 0;
}
if ((error = blockList()) != E_OK) return error;
return E_OK;
break;
default:
return E_SYN; //E_OK puvodne
}
return E_OK;
}
int params() {
int enumerator;
if ((error = testToken(T_ID)) != E_OK) return error; // "ID_parametru" - mozna specifikovat
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error; // ":"
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error;
if(!(strCmpConstStr(&(T.s), "boolean"))) enumerator = O_BOOL;
else if(!(strCmpConstStr(&(T.s), "integer"))) enumerator = O_INT;
else if(!(strCmpConstStr(&(T.s), "real"))) enumerator = O_REAL;
else if(!(strCmpConstStr(&(T.s), "string"))) enumerator = O_STRING;
else return E_SEMA;
gettoken();
pc++;
if(strCmpstring(&IDstr, &ActFun) == 0) return E_SEMA; //ADDED
if (searchParam(paramlist, &IDstr) != NULL) return E_SEMA;
if ((error = insertParam(paramlist,&IDstr, enumerator)) != E_OK) return error;;
//strFree(&IDstr);
if (testToken(T_SEMICOLON) == E_OK) {
gettoken();
if((error = params()) != E_OK) return error; //vice parametru - rekurze
}
return E_OK;
}
int push(stack *s, int symb, string *name, tSymbolTable *table) {
stackItemPtr helper; // Pomocná promìnné pro vložení nového prvku
helper = malloc(sizeof(struct stackItem)); // Alokace nového prvku
if(symb == FUNCTION) {
if(strCmpConstStr(name, "sort") == 0) {
helper->function = SORT;
} else if(strCmpConstStr(name, "find") == 0) {
helper->function = FIND;
} else {
return SYNTAX_ERROR;
}
}
helper->symbol = symb; // Symbol na zásobníku - index ve znacích
helper->nextItem = s->first; // Nastavení následujícího prvku
s->first = helper; // Nastavení prvního prvku na aktuální
//if(symb == 'E' || symb == ID) printf("\t\t\tPUSH: %s\n", strGetStr(name));
if(symb != 'E') {
helper->term = TRUE;
s->top = helper;
helper->nextNonTerm = NULL;
}
else {
helper->term = FALSE;
helper->nextNonTerm = s->firstNonTerm;
s->firstNonTerm = helper;
}
if((symb == 0) || (symb == 'E')) {
if((helper->tablePtr = tableSearch(table, name)) == NULL) { // nenasel v tabulce, treba vygenerovat promennou
return SEM_ERROR;
}
}
return 0;
}
/*
* Prohleda tabulku klicovych slov a zjisti zda prijaty string neni mezi nimi
*
* @uses keyWords
* @param string* s zkoumany string
* @return TokenTypes Type of token (TYPE_IDENTIFICATOR|[KEYW_AUTO-KEYW_RETURN])
*
*/
int isKeyWord(string* s) {
int i = 0;
for (i = 0; i < 16; i++) {
if (strCmpConstStr(s, keyWords[i]) == 0) {
break;
}
}
if (i == 16) {
return TYPE_IDENTIFICATOR;
}
return KEYW_AUTO + i;
}
int localDecl() { //za decl nebrat token
if ((error = testToken(T_ID)) != E_OK) return error; //ID
if (searchParam(paramlist, &(T.s)) != NULL){ //zde budu muset nejspis dat jen jmenu aktualni fkce
return E_SEMA;
}
if(strCmpstring(&(T.s), &ActFun) == 0){ //ADDED
return E_SEMA;
}
if(BSTSearch (TempTreeL, T.s) != NULL){
return E_SEMA;
}
strInit(&IDstr);
strCopystring(&IDstr, &T.s);
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error;
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error; // typ
/******************************************INSERT***************************************************************/
if(!(strCmpConstStr(&(T.s), "boolean"))) TempVar->type = O_BOOL;
if(!(strCmpConstStr(&(T.s), "integer"))) TempVar->type = O_INT;
if(!(strCmpConstStr(&(T.s), "real"))) TempVar->type = O_REAL;
if(!(strCmpConstStr(&(T.s), "string"))){
TempVar->type = O_STRING;
strInit(&TempVar->value.sval);
}
BSTInsert (&TempTreeL, IDstr, TempVar);
/******************************************INSERT***************************************************************/
gettoken();
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // ";"
gettoken();
//strFree(&IDstr);
if (testToken(T_ID) == E_OK)
if ((error = localDecl()) != E_OK) return error; //dalsia promena?
return E_OK;
}
string* tabSymCreateTmpSymbol(tTabSym* table) {
char buffer[BUFFER_SIZE];
int flag;
//Notice that only when this returned value is non-negative and less than n, the string has been completely written.
flag = snprintf(buffer, BUFFER_SIZE, "%u", table->tmpCounter++);//vytvoreni nazvu docasne promenne
if (flag < 0 || flag >= BUFFER_SIZE) {
//chyba pri vytvareni nazvu
return NULL;
}
string* newString = (string*)malloc(sizeof(string));
if (newString == NULL) {
//chyba pri alokaci
return NULL;
}
if(strInit(newString)){
return NULL;
}
strCmpConstStr(newString, buffer);
return newString;
}
//############### Vlozeni prvku na zacatek zasobniku ####################
tErrors ExpStackPush (tExpStack *L, tExpType val, tVariable *item)
{
tElemPtr temp; //nova promenna typu tElemPtr
if ((temp = malloc(sizeof(struct tElem))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if ((val == LB) || (val == RB) || (val == DOLAR)) //kdyz davam na zasobnik '(' nebo ')' nebo '$'
{
temp->data = val; //do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; //ukazatel bud ukazovat na vrchol zasobniku
L->Top = temp; //ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
else if (val == NONTERM) //kdyz davam na zasobnik neterminal
{
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = res;
temp->data = val; //do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; //ukazatel bud ukazovat na vrchol zasobniku
L->Top = temp; //ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
else
{
switch(T.type)
{ //###################### INSTRUKCE ###################
case T_ADD : temp->instruction = ADD; break;
case T_SUB : temp->instruction = SUB; break;
case T_MUL : temp->instruction = MUL; break;
case T_DIV : temp->instruction = DIV; break;
case T_LESS : temp->instruction = LESS; break;
case T_MORE : temp->instruction = MORE; break;
case T_LESS_EQ : temp->instruction = EQL; break;
case T_MORE_EQ : temp->instruction = EQM; break;
case T_NOT_EQ : temp->instruction = NEQ; break;
case T_EQUAL : temp->instruction = EQ; break;
//####################### OPERANDY ####################
case T_INT : // push na stack token typu INT, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_INT; //operand typu O_INT
temp->tempVarPtr->value.ival = strtol(T.s.str,NULL, 10);
break;
case T_REAL : // push na stack token typu REAL, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_REAL; //operand typu O_REAL
temp->tempVarPtr->value.rval = strtod(T.s.str, NULL);
break;
case T_STRING : // push na stack token typu STRING, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_STRING;
if (strInit(&(temp->tempVarPtr->value.sval)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
if (strCopystring(&(temp->tempVarPtr->value.sval), &(T.s)) == STR_ERROR)
return E_INTERN;
break;
case T_KONST : // push na stack token typu KONST - BOOL, alokace mistro pro ulozeni jmena, typu a hodnoty tokenu //konstanty ukladam jako true nebo false
if ((temp->tempVarPtr = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->tempVarPtr->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->tempVarPtr->type = O_BOOL; //operand typu O_BOOL - boolean
if (!strCmpConstStr(&(T.s), "true")) //pokud hodnota tokenu true
temp->tempVarPtr->value.bval = true; // uloz hodnotu operandu jako true
else if (!strCmpConstStr(&(T.s), "false")) //pokud hodnota tokenu je false
temp->tempVarPtr->value.bval = false; //uloz hodnotu operandu jako false
else
return E_SYN; //vraci error E_SYN
break;
default : break;
}
}
temp->data = val; // do data vlozim interni typ precedencni tabulky
temp->rptr = L->Top; // ukazatel bud ukazovat na vrchol zasobniku
if(T.type == T_ID) // pokud typ tokenu je ID (nejaka promenna)
{
temp->tempVarPtr = item; // uloz mi ukazatel na promennou do stromu LBVS/GBVS
temp->tempVarPtr->valFull = NODATA;
}
L->Top = temp; // ulozeni prvku do ukazatele na vrchol zasobniku
return E_OK;
}
int get_token(FILE *F, double *num, string *stri, int *error )
{
int pom;
int cha=0;
int err_char=0;
int next_state=ST_START;
char c;
char *chyba;
char min;
*num=0;
c=fgetc(F);
while (c != EOF)
{
switch(next_state)
{
case ST_START:
if (c == '\n')
{
line++;
next_state=ST_START;
}
if (isspace(c))
{
break; //Tohle jsem přidával !!!!!!!!
}
else if (c == ';')
{
return TP_SEM;
}
else if (c == '/')
{
return TP_MOD;
}
else if (c == '.')
{
return TP_DOT;
}
else if (c == '(')
{
return TP_LBRA;
}
else if (c == '+')
{
return TP_PLUS;
}
else if (c == '-')
{
return TP_MINUS;
}
else if (c == ')')
{
return TP_RBRA;
}
else if (c == '*')
{
return TP_MUL;
}
else if (isdigit(c))
{
next_state=ST_NUMBER;
strAddChar(stri,c);
}
else if (isalpha(c))
{
pom=0;
next_state=ST_IDENT_KEY;
strAddChar(stri,c);
}
else if (c == '{')
{
next_state=ST_KOMENT;
}
else if (c == 39)
{
next_state=ST_STRING;
}
else if (c == ':')
{
next_state=ST_COLONS;
strAddChar(stri,c);
}
else if (c == '<')
{
next_state=ST_LESS;
}
else if (c == '>')
{
next_state=ST_MORE;
}
else if (c == ',')
{
return TP_COMMA;
}
else
{
*error=1; //nastala chyba.
}
break;
case ST_KOMENT:
if (c == '}')
{
next_state=ST_START;
}
break;
case ST_IDENT_KEY:
if ((!(isdigit(c))) && (!(isalpha(c)) && (c != '_')))
{
ungetc(c,F);
return TP_IDENT;
}
else
{
strAddChar(stri,c);
}
for (pom=0;pom<20;pom++)
{
if ((strCmpConstStr(stri,KeyWord[pom]))==0)
{
c=fgetc(F);
if ((!(isdigit(c))) && (!(isalpha(c))))
{
ungetc(c,F);
return pom+51;
}
else
{
ungetc(c,F);
}
}
}
break;
case ST_NUMBER:
if(!(isdigit(c)))
{
if(c == '.')
{
next_state=ST_REAL;
strAddChar(stri,c);
}
else if ((c == 'E') || (c == 'e'))
{
next_state=ST_REAL_EXP;
strAddChar(stri,c);
}
else if ((c == '+') || (c == '-'))
{
if (c == '-')
{
min='-';
}
c=fgetc(F);
if ((c == 'E') || (c == 'e'))
{
next_state=ST_REAL_EXP;
strAddChar(stri,c);
if (min == '-')
{
strAddChar(stri,'-');
}
}
else
{
*error=1;
next_state=ST_START;
}
}
else if ((isspace(c)) || (c == ';') || (c == '\n'))
{
*num = strtod(strGetStr(stri),&chyba);
return TP_INT;
}
else
{
*error=1;
next_state=ST_START;
}
}
else
{
strAddChar(stri,c);
}
break;
case ST_LESS:
if (c == '>')
{
return TP_NEQU;
}
else if (c == '=')
{
return TP_LESSEQ;
}
else
{
ungetc(c,F);
return TP_LESS;
}
break;
case ST_MORE:
if (c == '=')
{
return TP_MOREEQ;
}
else
{
ungetc(c,F);
return TP_MORE;
}
break;
case ST_COLONS:
if (c == '=')
{
return TP_SGNMNT;
}
else
{
ungetc(c,F);
return TP_COL;
}
break;
case ST_CHAR:
if (c == 39)
{
if (err_char == 0)
{
strAddChar(stri,cha);
}
err_char=0;
next_state=ST_STRING;
break;
}
if ((!(isdigit(c)) && (c != 39)) || (err_char==1))
{
printf("chyba\n");
}
else
{
cha=cha*10+(c-48);
if ((cha <1) && (cha >255))
{
printf("chyba\n");
err_char=1;
}
}
break;
case ST_STRING:
if (c == 39)
{
c=fgetc(F);
if (c == '#')
{
next_state=ST_CHAR;
break;
}
else
{
ungetc(c,F);
return TP_STRING;
}
}
else
{
strAddChar(stri,c);
}
break;
case ST_REAL:
if(!(isdigit(c)))
{
if ((c == 'E') || (c == 'e'))
{
next_state=ST_REAL_EXP;
strAddChar(stri,c);
}
else if ((c == '+') || (c == '-'))
{
if (c == '-')
{
min='-';
}
c=fgetc(F);
if ((c == 'E') || (c == 'e'))
{
next_state=ST_REAL_EXP;
strAddChar(stri,c);
if (min == '-')
{
strAddChar(stri,'-');
}
}
else
{
*error=1;
next_state=ST_START;
}
}
else if ((isspace(c)) || (c == ';') || (c == '\n'))
{
*num = strtod(strGetStr(stri),&chyba);
return TP_REAL;
}
else
{
*error=1;
next_state=ST_START;
}
}
else
{
strAddChar(stri,c);
}
break;
case ST_REAL_EXP:
if(!(isdigit(c)))
{
if ((isspace(c)) || (c == ';') || (c == '\n'))
{
*num = strtod(strGetStr(stri),&chyba);
return TP_REAL_EXP;
}
else
{
*error=1;
next_state=ST_START;
}
}
else
{
strAddChar(stri,c);
}
break;
}
c=fgetc(F);
}
return TP_EOF;
}
int getNextToken(string *attr) {
int esc = 0;
int state = 0; //při hledání každého nového tokenu bude počáteční stav 0
int c;
strClear(attr);//vyčítím řetězec pro nové použití
while(1) {
c = getc(source);
if (c == EOF && state != 0) lErr();
switch (state) {
/***** DEFAULT STATE *****/
case 0:
if (isspace(c))
state = 0;
else if (c == '<')
state = 1;
else if (c == '>')
state = 2;
else if (c == '!')
state = 3;
else if (c == '=')
state = 4;
else if (isdigit(c)) {
strAddChar(attr, c);
state = 5;
}
else if (isalpha(c) || c == '_') {
strAddChar(attr, c);
state = 11;
}
else if (c == '"') {
state = 15;
}
else if (c == '/')
state = 20;
else {
switch(c) {
case ';':
return STREDNIK;
break;
case '+':
return PLUS;
break;
case '-':
return MINUS;
break;
case '*':
return NASOBENI;
break;
case ',':
return CARKA;
break;
case '(':
return L_ZAVORKA;
break;
case ')':
return P_ZAVORKA;
break;
case '{':
return LS_ZAVORKA;
break;
case '}':
return PS_ZAVORKA;
break;
case EOF:
return FILEEND;
break;
default:
lErr();
break;
}
}
break;
/***** LESS OR LESS_OR_EQUALS *****/
case 1:
if (c == '=')
return MENE_NEBO_ROVNO; // token -> [<=, ]
else if (c == '<')
return ZAPIS; // token -> [<<, ]
else {
ungetc(c, source);
return MENE; // token -> [<, ]
}
break;
/***** MORE OR MORE_OR_EQUALS *****/
case 2:
if (c == '=')
return VICE_NEBO_ROVNO; // token -> [>=, ]
else if (c == '>')
return CTENI; // token -> [>>, ]
else {
ungetc(c, source);
return VICE; // token -> [>, ]
}
break;
/***** NOT EQUALS *****/
case 3:
if (c == '=')
return NEROVNOST; // token -> [!=, ]
else
lErr();
break;
/***** EQUALS *****/
case 4:
if (c == '=')
return ROVNA_SE; // token -> [==, ]
else {
ungetc(c, source);
return PRIRAZENI;
}
break;
/***** INT OR DOUBLE *****/
case 5:
if (isdigit(c))
strAddChar(attr, c);
else if (c == '.') {
strAddChar(attr, c);
state = 6;
}
else if (c == 'e' || c == 'E') {
strAddChar(attr, c);
state = 8;
}
else {
ungetc(c, source);
return INT_V;
} // token -> [INT_V, N]
break;
case 6:
if (isdigit(c)) {
strAddChar(attr, c);
state = 7;
}
else
lErr();
break;
case 7:
if (isdigit(c))
strAddChar(attr, c);
else if (c == 'e' || c == 'E') {
strAddChar(attr, c);
state = 8;
}
else {
ungetc(c, source);
return DOUBLE_V; // token -> [DOUBLE_V, D.D]
}
break;
case 8:
if (isdigit(c)) {
strAddChar(attr, c);
state = 10;
}
else if (c == '+' || c == '-') {
strAddChar(attr, c);
state = 9;
}
else
lErr();
break;
case 9:
if (isdigit(c)) {
strAddChar(attr, c);
state = 10;
}
else
lErr();
break;
case 10:
if (isdigit(c))
strAddChar(attr, c);
else {
ungetc(c, source);
return DOUBLE_V;
}
break;
/***** ID OR KEYWORD *****/
case 11:
if (isalnum(c) || c == '_')
strAddChar(attr, c);
else {
ungetc(c, source);
if (!strCmpConstStr(attr, "auto"))
return AUTO;
else if (!strCmpConstStr(attr, "cin"))
return CIN;
else if (!strCmpConstStr(attr, "cout"))
return COUT;
else if (!strCmpConstStr(attr, "double"))
return DOUBLE;
else if (!strCmpConstStr(attr, "else"))
return ELSE;
else if (!strCmpConstStr(attr, "for"))
return FOR;
else if (!strCmpConstStr(attr, "if"))
return IF;
else if (!strCmpConstStr(attr, "int"))
return INT;
else if (!strCmpConstStr(attr, "return"))
return RETURN;
else if (!strCmpConstStr(attr, "string"))
return STRING;
else
return ID;
}
break;
/***** STRING *****/
case 15:
if (c == '\\') {
state = 16;
}
else if (c == '"') {
return STRING_V;
}
else
strAddChar(attr, c);
break;
case 16:
if (c == '\\') {
strAddChar(attr, '\\');
state = 15;
}
else if (c == 't') {
strAddChar(attr, '\t');
state = 15;
}
else if (c == 'n') {
strAddChar(attr, '\n');
state = 15;
}
else if (c == '"') {
strAddChar(attr, '"');
state = 15;
}
else if (c == 'x') {
state = 17;
}
else {
lErr();
}
break;
case 17:
if (isxdigit(c)) {
if (c >= 'a' && c <= 'f') {
esc = (c - 'a' + 10) * 16;
}
else if (c >= 'A' && c <= 'F') {
esc = (c - 'A' + 10) * 16;
}
else {
esc = (c - '0') * 16;
}
state = 18;
}
else
lErr();
break;
case 18:
if (isxdigit(c)) {
if (c == '0' && esc == 0)
lErr();
if (c >= 'a' && c <= 'f') {
esc = esc + (c - 'a' + 10);
}
else if (c >= 'A' && c <= 'F') {
esc = esc + (c - 'A' + 10);
}
else {
esc = esc + (c - '0');
}
strAddChar(attr, esc);
state = 15;
}
else
lErr();
break;
/***** COMMENT *****/
case 20:
if (c == '*')
state = 21;
else if (c == '/')
state = 23;
else {
ungetc(c, source);
return DELENI;
}
break;
case 21:
if (c == '*')
state = 22;
break;
case 22:
if (c == '/')
state = 0;
else
state = 21;
break;
case 23:
if (c == '\n')
state = 0;
break;
}
}
}
int getNextToken(string *attr){
char c;
int stav = STATE_START;
strClear(attr);
while(1){
c = getc(sourceFile);
switch(stav){
case STATE_START:
if(isspace(c)){
stav = STATE_START;
}
else if(isalpha(c) || c == '_'){ // znaky: a-zA-Z nebo _
strAddChar(attr, c);
stav = STATE_ALPHANUM;
}
else if(isdigit(c)){ // cisla
strAddChar(attr, c);
stav = STATE_DIGIT;
}
else if(c == 34) { // "
//printf("%c", c);
// strAddChar(attr, c);
stav = STATE_STRING;
}
else {
switch(c){
case '+':
return TOK_ADDITION;
break;
case '-':
return TOK_SUBTRACTION;
break;
case '*':
return TOK_MULTIPLICATION;
break;
case '/':
stav = STATE_SLASH;
break;
case '<':
stav = STATE_LESS_THAN;
break;
case '>':
stav = STATE_GREATER_THAN;
break;
case '=':
stav = STATE_EQUALS;
break;
case '!':
stav = STATE_INEQUALITY;
break;
case ';':
return TOK_SEMICOLON;
break;
case '(':
return TOK_LEFT_BRACKET;
break;
case ')':
return TOK_RIGHT_BRACKET;
break;
case '.':
return TOK_DOT;
break;
case ',':
return TOK_COMMA;
break;
case EOF :
return TOK_END_OF_FILE;
break;
case '{' :
return TOK_LEFT_BRACE;
break;
case '}' :
return TOK_RIGHT_BRACE;
break;
default:
printf("defualt %c", c);
break;
}
}
break;
case STATE_INEQUALITY:
if(c == '='){
return TOK_INEQUALITY;
} else {
ungetc (c,sourceFile);
return LEX_ERROR;
}
break;
case STATE_STRING:
if(c == '"'){
// strAddChar(attr, c);
return TOK_STR;
} else if(c == 92){ // ASCII 92 je zpetne lomitko
// strAddChar(attr, c);
stav = STATE_ESCAPE_SEQUENCE;
} else if (c == EOF){
ungetc(c, sourceFile);
return LEX_ERROR;
} else if(c != 34 && c > 31){
strAddChar(attr, c);
} else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_ESCAPE_SEQUENCE:
if(c == 'n'){
strAddChar(attr, '\n');
stav = STATE_STRING;
} else if (c == 92){
strAddChar(attr, '\\');
stav = STATE_STRING;
} else if (c == 't'){
strAddChar(attr, '\t');
stav = STATE_STRING;
} else if (c == '"'){
// strAddChar(attr, c);
stav = STATE_STRING;
} else if (c == 'x'){
strAddChar(attr, 92);
strAddChar(attr, c);
stav = STATE_HEXA_CHAR;
} else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_HEXA_CHAR:
if((c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102)){
strAddChar(attr, c);
stav = STATE_HEXA_CHAR_SECOND;
} else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_HEXA_CHAR_SECOND:
if((c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102)){
strAddChar(attr, c);
stav = STATE_STRING;
} else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_DIGIT:
if(isdigit(c)){ // prislo dalsi cislo
strAddChar(attr, c);
}
else if(c == '.'){
strAddChar(attr, c);
stav = STATE_FLOATING_POINT;
}
else if(c == 'E' || c == 'e'){
strAddChar(attr, c);
stav = STATE_EXPONENT;
}
else {
ungetc (c,sourceFile);
return TOK_DECIMAL_NUMBER;
}
break;
case STATE_FLOATING_POINT:
if(isdigit(c)){
strAddChar(attr, c);
}
else if(c == 'E' || c == 'e'){
strAddChar(attr, c);
stav = STATE_EXPONENT;
}
else {
ungetc (c,sourceFile);
return TOK_FLOATING_POINT_NUMBER;
}
break;
case STATE_EXPONENT://
if(isdigit(c) != 0) {
strAddChar(attr, c);
stav = STATE_MORE_IN_EXPONENT;
}
else if(c == '+' || c == '-') {
strAddChar(attr, c);
stav = STATE_MORE_IN_EXPONENT;
}
else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_MORE_IN_EXPONENT:
if(isdigit(c) != 0) {
strAddChar(attr, c);
stav = STATE_MORE_IN_EXPONENT2;
} else {
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_MORE_IN_EXPONENT2:
if(isdigit(c) != 0) {
strAddChar(attr, c);
}
else if(c == ' ' || c == ';' || c == ')' || c == '+' || c == '-' || c == '/' || c == '*'){
ungetc(c, sourceFile);
return TOK_FLOATING_POINT_NUMBER;
}
else{
ungetc(c, sourceFile);
return LEX_ERROR;
}
break;
case STATE_EQUALS:
if(c == '='){
return TOK_COMPARISON;
} else {
ungetc (c,sourceFile);
return TOK_EQUALS;
break;
}
break;
case STATE_ALPHANUM:
if(!(isalnum(c) || c == '_')){ // kdyz neni toto: a-zA-Z0-9 nebo _
//printf("STATE_ALPHANUM: %s", attr->str);
ungetc(c, sourceFile);
if(0 == strCmpConstStr(attr, "int")){
return TOK_INT;
}
else if(0 == strCmpConstStr(attr, "double")){
return TOK_DOUBLE;
}
else if(0 == strCmpConstStr(attr, "else")){
return TOK_ELSE;
}
else if(0 == strCmpConstStr(attr, "if")){
return TOK_IF;
}
else if(0 == strCmpConstStr(attr, "return")){
return TOK_RETURN;
}
else if(0 == strCmpConstStr(attr, "string")){
return TOK_STRING;
}
else if(0 == strCmpConstStr(attr, "auto")){
return TOK_AUTO;
}
else if(0 == strCmpConstStr(attr, "cin")){
return TOK_CIN;
}
else if(0 == strCmpConstStr(attr, "for")){
return TOK_FOR;
}
else if(0 == strCmpConstStr(attr, "cout")){
return TOK_COUT;
}
else {
return TOK_ID;
}
} else {
strAddChar(attr, c);
}
break;
case STATE_GREATER_THAN:
switch(c){
case '=':
return TOK_GREATER_THAN_OR_EQUAL;
break;
case '>':
return TOK_DOUBLE_ARROW_RIGHT;
break;
default:
ungetc (c,sourceFile);
return TOK_GREATER_THAN;
break;
}
break;
case STATE_LESS_THAN:
switch(c){
case '=':
return TOK_LESS_THAN_OR_EQUAL;
break;
case '<':
return TOK_DOUBLE_ARROW_LEFT;
break;
default:
ungetc (c,sourceFile);
return TOK_LESS_THAN;
break;
}
break;
case STATE_SLASH:
switch(c){
case '/':
stav = STATE_LINE_COMMENT;
break;
case '*':
stav = STATE_BLOCK_COMMENT;
break;
default:
ungetc (c,sourceFile);
return TOK_DIVISION;
break;
}
case STATE_LINE_COMMENT:
if(c == '\n'){
stav = STATE_START;
}
break;
case STATE_BLOCK_COMMENT:
if(c == '*'){
stav = STATE_BLOCK_COMMENT_STAR;
}
break;
case STATE_BLOCK_COMMENT_STAR:
if(c == '/'){
stav = STATE_START;
}
break;
default:
break;
}
}
return LEX_ERROR;
}
int is_keyword(string *str, int fce)
{
if (strCmpConstStr(str, "begin") == 0)
return BEGIN;
if (strCmpConstStr(str, "boolean") == 0)
return BOOLEAN;
if (strCmpConstStr(str, "copy") == 0)
return COPY;
if (strCmpConstStr(str, "do") == 0)
return DO;
if (strCmpConstStr(str, "else") == 0)
return ELSE;
if (strCmpConstStr(str, "end") == 0)
return END;
if (strCmpConstStr(str, "false") == 0)
return FALSE;
if (strCmpConstStr(str, "find") == 0)
return FIND;
if (strCmpConstStr(str, "forward") == 0)
return FORWARD;
if (strCmpConstStr(str, "function") == 0)
return FUNCTION;
if (strCmpConstStr(str, "if") == 0)
return IF;
if (strCmpConstStr(str, "integer") == 0)
return INTEGER;
if (strCmpConstStr(str, "length") == 0)
return LENGTH;
if (strCmpConstStr(str, "readln") == 0)
return READLN;
if (strCmpConstStr(str, "real") == 0)
return REAL;
if (strCmpConstStr(str, "sort") == 0)
return SORT;
if (strCmpConstStr(str, "string") == 0)
return STRING;
if (strCmpConstStr(str, "then") == 0)
return THEN;
if (strCmpConstStr(str, "true") == 0)
return TRUE;
if (strCmpConstStr(str, "var") == 0)
return VAR;
if (strCmpConstStr(str, "while") == 0)
return WHILE;
if (strCmpConstStr(str, "write") == 0)
return WRITE;
if (fce)
return IDENTIFIKATORF;
return IDENTIFIKATOR;
}
int program() {
gettoken();
switch(T.type){
case T_KEYWORD:{
if (var == 0){
if (!(strCmpConstStr (&(T.s), "var"))){ //var
var = 1;
gettoken();
TempVar = allocate(sizeof(tVariable));
if ((error = globalDecl()) != E_OK) return error; // deklarace promennych
//free(TempVar);
}
}
if (!strCmpConstStr (&(T.s), "begin")) {// BEGIN
//if(searchFunListFW() != NULL) return E_SEMA;
if((error = searchFunListCH()) != E_OK) return E_SEMA;
gettoken();
//printf("main \n");
if (!strCmpConstStr (&(T.s), "end")){ //BEGIN END. - prazdne
gettoken();
if ((error = testToken(T_DOT)) != E_OK) return error;
gettoken();
if ((error = testToken(T_EOF)) != E_OK) return error;
error = InsertEmptyItemTape(); //vkladam novy prazdny prvek na pasku
if (error == E_INTERN)
return error;
Tape->last->instruction = NOP;
return E_OK;
}
if ((error = blockList()) != E_OK) return error;
}
else if (!strCmpConstStr (&(T.s), "function")) { // funkce
BSTInit(&TempTreeL);
TempVar = allocate(sizeof(tVariable));
afun = 1; // ADDED
if ((error = function()) != E_OK){
return error;
}
//printf("za funkcwma \n");
afun = 0; //ADDED
//strFree(&ActFun); //ADDED
if ((error = program()) != E_OK) return error;
return E_OK;
}
else {
return E_SYN;}
break;
}
default:
{
return E_SYN;
}
}
gettoken();
if ((error = testToken(T_DOT)) != E_OK) return error;
gettoken();
if ((error = testToken(T_EOF)) != E_OK) return error;
return E_OK;
}
int commands()
{
tVariable *glob = NULL;
tVariable *loc = NULL;
tParamList *par = NULL;
string *name = allocate(sizeof(string));
tTapeItem *previous = Tape->last;
tVariable *op1 = allocate(sizeof(tVariable));
tVariable *op2 = allocate(sizeof(tVariable));
tVariable *result = allocate(sizeof(tVariable));
if((name == NULL) || (op1 == NULL) || (op2 == NULL) || (result == NULL)) return E_INTERN;
switch(T.type){
case T_ID:
/* if(afun == 1){ //ADDED pokud neni ve funkci kontroluje jen global
if ((par = searchParam(paramlist, &(T.s))) == NULL){ //added
if(strCmpstring(&(T.s), &ActFun) != 0){ //zde budu muset nejspis dat jen jmenu aktualni fkce
if((loc = BSTSearch (TempTreeL, T.s)) == NULL){
if((glob = BSTSearch (TempTree, T.s)) == NULL){
return E_SEMA;
}*/
// else{
// Tape->last->op1 = glob;
// }
// }
// else{
// Tape->last->op1 = loc;
// }
// }
// else{
// Tape->last->op1 = item;
// }
//}
// else{
// Tape->last->op1 = par;
// }
// }
/* else {*/
if((glob = BSTSearch (TempTree, T.s)) == NULL){
return E_SEMA;
}
/*else{
Tape->last->op1 = glob; }*/
//}
gettoken();
if ((error = testToken(T_ASSIGN)) != E_OK) return error;
if ((error = ExpParser()) != E_OK) return error;
//if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = ASSIGN;
if (loc != NULL){
Tape->last->op1 = loc;
}
else if (glob != NULL){
Tape->last->op1 = glob;
}
if (res != Tape->last->op1->type ) return E_SEMB;
Tape->last->op2 = Tape->last->previous->result;
Tape->last->result = Tape->last->op1;
printf("parser adresa resultu v parseri %d \n",Tape->last->op2);
if ((strCmpConstStr (&(T.s), "end"))) {
if ((error = testToken(T_SEMICOLON)) != E_OK) return error;
semi = 1;
}
break;
case T_KEYWORD:
if(!strCmpConstStr (&(T.s), "begin")){
gettoken();
if((error = blockList()) != E_OK) return error;
gettoken();
if ((strCmpConstStr (&(T.s), "end"))) {
if ((error = testToken(T_SEMICOLON)) != E_OK) return error;
semi = 1;
}
break;
}
if(!strCmpConstStr (&(T.s), "if")){ //if
tTapeItem *label;
tTapeItem *endelse;
tVariable *op11 = allocate(sizeof(tVariable));
tVariable *op22 = allocate(sizeof(tVariable));
if((op11 == NULL) || (op22 == NULL)) return E_INTERN;
if((error = ExpParser()) != E_OK) return error; //vyraz
if (res != 3 ) return E_SEMB;
//ZAKONECNTOVANO if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = JUMPN;
Tape->last->op1 = Tape->last->previous->result;
Tape->last->op2 = op2;
Tape->last->op2->type = TAPE_POINTER;
label = Tape->last;
if((error = testToken(T_KEYWORD)) == E_OK){
if(strCmpConstStr (&(T.s),"then")) return E_SYN; //then
}
else
return error;
gettoken();
if((error = testToken(T_KEYWORD)) == E_OK){
if(strCmpConstStr (&(T.s),"begin")) return E_SYN; //begin slozeneho prikazu
}
else
return error;
gettoken();
if((error = blockList()) != E_OK) return error; //blocklist
gettoken();
Tape->last->instruction = JUMPN;
Tape->last->op1 = op11;
Tape->last->op1->type = O_BOOL;
Tape->last->op1->value.bval = false;
if(strInit(&(Tape->last->op1->name)) != STR_SUCCESS) return E_INTERN;
Tape->last->op2 = op22;
Tape->last->op2->type = TAPE_POINTER;
endelse = Tape->last;
if((error = testToken(T_KEYWORD)) != E_OK) return error;
if(strCmpConstStr (&(T.s),"else")) return E_SYN;
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = NOP;
label->op2->value.tape_pointer = Tape->last;
gettoken();
if((error = testToken(T_KEYWORD)) != E_OK) return error;
if(strCmpConstStr (&(T.s),"begin")) return E_SYN; //begin slozeneho prikazu
gettoken();
if((error = blockList()) != E_OK) return error; //blocklist
gettoken();
if ((strCmpConstStr (&(T.s), "end"))) {
if (testToken(T_SEMICOLON) != E_OK) return E_SYN;
semi = 1;
}
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = NOP;
endelse->op2->value.tape_pointer = Tape->last;
break;
}
if(!strCmpConstStr (&(T.s), "while")){
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = NOP;
tTapeItem *label1;
tTapeItem *label2 = Tape->last; // ukazatel na pasku kam se bude cyklus vracet
tVariable *op11 = allocate(sizeof(tVariable));
tVariable *op22 = allocate(sizeof(tVariable));
if((op11 == NULL) || (op22 == NULL)) return E_INTERN;
if((error = ExpParser()) != E_OK) return error; //vyraz
if (res != 3 ) return E_SEMB;
//ZAKONECNTOVANO if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = JUMPN;
Tape->last->op1 = Tape->last->previous->result;
Tape->last->op2 = op22;
Tape->last->op2->type = TAPE_POINTER;
label1 = Tape->last;
if((error = testToken(T_KEYWORD)) == E_OK){
if(strCmpConstStr (&(T.s),"do")) return E_SYN; //begin slozeneho prikazu
}
else
return error;
gettoken();
if((error = testToken(T_KEYWORD)) == E_OK){
if(strCmpConstStr (&(T.s),"begin")) return E_SYN; //begin slozeneho prikazu
}
else{
return error;
}
gettoken();
if((error = blockList()) != E_OK) return error; //blocklist
gettoken();
if ((strCmpConstStr (&(T.s), "end"))) {
if ((error = testToken(T_SEMICOLON)) != E_OK) return error;
semi = 1;
}
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = JUMP;
Tape->last->op1 = op1;
Tape->last->op1->type = O_BOOL;
Tape->last->op1->value.bval = false;
if(strInit(&(Tape->last->op1->name)) != STR_SUCCESS) return E_INTERN;
Tape->last->op2 = op2;
Tape->last->op2->type = TAPE_POINTER;
Tape->last->op2->value.tape_pointer = label2; // nepodmineny skok zpet na zacatek vyhodnocovani podminky cyklu
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = NOP; // instrukce, na kterou se skoci v pripade nesplneni podminky whilu
label1->op2->value.tape_pointer = Tape->last;
break;
}
if (!strCmpConstStr (&(T.s), "readln")) {
gettoken();
if((error = testToken(T_LB)) != E_OK) return error;
gettoken();
if((error = testToken(T_ID)) != E_OK) return error;
if(afun == 1){
if(strCmpstring(&(T.s), &ActFun) != 0){ //added: Jmeno fkce, params, global, local
if (searchParam(paramlist, &(T.s)) == NULL){
if((TempVar = BSTSearch (TempTreeL, T.s)) == NULL){
if((TempVar = BSTSearch(TempTree, T.s)) == NULL) return E_SEMA;
}
}
}
}
else{
if((TempVar = BSTSearch(TempTree, T.s)) == NULL) return E_SEMA;
}
if (TempVar->type == O_BOOL){
TempVar = NULL;
return E_SEMB;
}
gettoken();
if((error = testToken(T_RB)) != E_OK){
TempVar = NULL;
return error;
}
gettoken();
if ((strCmpConstStr (&(T.s), "end"))) {
if ((error = testToken(T_SEMICOLON)) != E_OK){
TempVar = NULL;
return error;
}
semi = 1;
}
TempVar = NULL;
break;
}
if (!strCmpConstStr (&(T.s), "write")) { //write(ID) !!! integer or real !!!
gettoken();
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
Tape->last->instruction = JUMP;
Tape->last->op1 = op1;
Tape->last->op1->type = O_BOOL;
Tape->last->op1->value.bval = false;
if((error = testToken(T_LB)) != E_OK) return error;
gettoken();
if((error = writefun()) != E_OK) return error;
gettoken();
if ((strCmpConstStr (&(T.s), "end"))) {
if ((error = testToken(T_SEMICOLON)) != E_OK) return error;
semi = 1;
}
break;
}
default:
return E_SYN;
}
return E_OK;
}
//################### HLEDANI A ZPRACOVANI FUNKCE #######################
tErrors SearchFun()
{
tFunListItem *FunPtr; // ukazatel na prvek seznamu funkce
tVariable *pTree; // ukazatel na strukturu tVariable
tParamItem *param; // ukazatel na parametr
tErrors er; // promenna typu tErrors pro ulozeni vysledneho error kodu
tExpType type; // typ prvku na zasobniku
tVariable *temp;
tVariable *temp2;
tParamList *parameterList;
int param_counter = 0;
int param_number = 0;
parameterList = allocate(sizeof(tParamList));
initParamlist(parameterList);
FunPtr = searchFunList(&(T.s)); // pokud najdes funkci v seznamu funkci
param_number = FunPtr->param_count; // ulozeni - pocet parametru funkce do param
param = FunPtr->param_list->first; // ulozeni ukazatele na prvni prvek v seznamu parametru funkci
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
if (type != LB) // pokud nenasleduje leva zavorka, E_SYN
return E_SYN;
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
//printf("P: %d T.TYPE: %d\n",param_number,T.type);
if ((param_number == 0) && (T.type != T_RB))
return E_SEMB;
while((type != RB) && ((strCmpConstStr (&(T.s), "end")!=0) && (T.type != T_SEMICOLON))) // ber novy token dokud neprojdes vsechny parametry funkce
{ //printf("JSEM ve WHILE\n");
//printf("TOKEN 01: %s\n",T.s.str);
if (T.type == T_ID) // pokud je typ ID, vyhledej jej v BVS
{
if (insertParam(parameterList, &(T.s), T.type) != E_OK) return E_INTERN;
if ((SearchDataType(TempTree, TempTreeL)) != NULL) // pokud je token typu ID a je nalezen v BVS
{
pTree = SearchDataType(TempTree, TempTreeL); // uloz mi ukazatel na prvek do stromu
if (pTree->type != param->type) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB; // vraci E_SEMB
}
else
{ // pokud neni prvek nalezen
return E_SEMA; // vraci E_SEMA
}
}
else if (T.type == T_INT)
{
if (param->type != O_INT) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_REAL)
{
if (param->type != O_REAL) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_STRING)
{
if (param->type != O_STRING) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else if (T.type == T_KONST)
{
if (param->type != O_BOOL) // pokud neni typ tokenu roven typu parametru funkce
return E_SEMB;
}
else // pokud neni parametr ID
{
return E_SYN; // vraci chybu E_SYN
}
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
param_counter++; // pocitadlo paramateru
if (((param_counter == param_number) && (type != RB)) && (type != COMMA)) // pokud neni za ID carka nebo za posledni parametrem neni prava zavorka
return E_SYN; // vrat chybu E_SYN
if (param_counter > param_number) // pokud pocitadlo parametru je vetsi jako hodnota, ktera je udana u funkce v seznamu
return E_SEMB; // vrat chybu E_SEMB
if (param->next != NULL)
param = param->next; // posunuti na dalsi parametr funkce ???????????????????????
gettoken();
er = ConvertToken(&type); // konvertovani tokenu
if (er) // pokud konvert neprobehl v poradku
return E_SYN; // koncim s chybou
}
if (param_number != param_counter)
return E_SEMB;
res = FunPtr->ret_type;
if ((temp = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
if ((temp2 = allocate(sizeof(tVariable))) == NULL) //pokud neni dostatek pameti => E_INTERN
return E_INTERN;
if (strInit(&(temp2->name)) == STR_ERROR) //pokud funkce init. stringu vrati chybu => E_INTERN
return E_INTERN;
temp->name = FunPtr->name;
temp->value.param_pointer = parameterList->first;
temp->type = PARAM_POINTER;
temp2->type = TAPE_POINTER;
temp2->value.tape_pointer = FunPtr->tape_ptr;
Tape->last->op1 = temp; // ulozeni ukazatele na tVariable polozku, ktera obsahuje ukazatel na funkci na pasce
Tape->last->instruction = CALL; // instrukce je funkce
Tape->last->op2 = temp2;
Tape->last->result->type = FunPtr->ret_type;
if (param_counter == 0)
gettoken();
return E_OK; // pokud to najde funkci E_OK
}
int getNextToken(string *attr)
{
int state = 0;
int c;
// vymazeme obsah atributu a v pripade identifikatoru
// budeme postupne do nej vkladat jeho nazev
strClear(attr);
while (1)
{
// nacteni dalsiho znaku
c = getc(source);
switch (state)
{
case 0:
// zakladni stav automatu
if (isspace(c))
// bila mista - ignorovat
state = 0;
else
if (c == '<')
// komentar
state = 1;
else
if (isalpha(c))
// identifikator nebo klicove slovo
{
strAddChar(attr, c);
state = 2;
}
else
if (c == '+')
// operator ++
state = 3;
else
if (c == '-')
// operator --
state = 4;
else
if (c == '{') return LEFT_VINCULUM;
else
if (c == '}') return RIGHT_VINCULUM;
else
if (c == ';') return SEMICOLON;
else
if (c == EOF) return END_OF_FILE;
else
return LEX_ERROR;
break;
case 1:
// komentar
if (c == '>') state = 0;
else
// komentar pokracuje libovolnymi znaky, zustan ve stavu 1,
// ale kontroluj, zda neprijde EOF (neukonceny komentar)
if (c == EOF) return LEX_ERROR;
break;
case 2:
// identifikator nebo klicove slovo
if (isalnum(c))
// identifikator pokracuje
strAddChar(attr, c);
else
// konec identifikatoru
{
ungetc(c, source); // POZOR! Je potreba vratit posledni nacteny znak
// kontrola, zda se nejedna o klicove slovo
if (strCmpConstStr(attr, "setzero") == 0) return SETZERO;
else
if (strCmpConstStr(attr, "read") == 0) return READ;
else
if (strCmpConstStr(attr, "write") == 0) return WRITE;
else
if (strCmpConstStr(attr, "while") == 0) return WHILE;
else
// jednalo se skutecne o identifikator
return ID;
}
break;
case 3:
// pokracovani operatoru ++
if (c == '+') return INC;
else
return LEX_ERROR;
break;
case 4:
// pokracovani operatoru --
if (c == '-') return DEC;
else
return LEX_ERROR;
break;
}
}
}
int function() {
int enumerator;
int fw =0;
pc =0;
gettoken();
if ((error = testToken(T_ID)) != E_OK) return error; // ID_funkce - mozna upresnit
string name; // tu je vkladanie funkcii do seznamu 98-103
if(strInit(&name) != STR_SUCCESS) return E_INTERN;
if(strInit(&ActFun) != STR_SUCCESS) return E_INTERN; //added
//if(searchFunList(&(T.s)) != NULL) return E_SEMA;
strCopystring(&name, &(T.s));
strCopystring(&ActFun, &(T.s)); //added
gettoken();
if ((error = testToken(T_LB)) != E_OK) return error; // leva zavorka
gettoken();
if ((testToken(T_RB) != E_OK) && (testToken(T_ID) != E_OK)) return E_SYN; // prava zavorka(muze byt prazdne) nebo parametr
if (testToken(T_ID) == E_OK){
initParamlist(paramlist);
if((error = params()) != E_OK) return error; //parametry
}
if ((error = testToken(T_RB)) != E_OK) return error;
gettoken();
if ((error = testToken(T_COLON)) != E_OK) return error; // ":"
gettoken();
if ((error = testToken(T_DATATYPE)) != E_OK) return error; // "typ" - mozna funkci pro typy - semantika? !!!!! TYPE
if(!(strCmpConstStr(&(T.s), "boolean"))) enumerator = O_BOOL;
else if(!(strCmpConstStr(&(T.s), "integer"))) enumerator = O_INT;
else if(!(strCmpConstStr(&(T.s), "real"))) enumerator = O_REAL;
else if(!(strCmpConstStr(&(T.s), "string"))) enumerator = O_STRING;
else return E_SEMA;
//if((searchFunList(&name)!= NULL)) return E_SYN;
gettoken();
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // ";"
gettoken();
switch(T.type){
case T_KEYWORD:
if (!strCmpConstStr (&(T.s), "forward")) {
gettoken();
fw = 1;
if((searchFunListFW(&name)!= NULL)) return E_SEMA;
if(insertFunListItem(&name,enumerator,paramlist,fw,pc) != E_OK) return E_INTERN;
if ((error = testToken(T_SEMICOLON)) != E_OK) return error; // FORWARD a ";"
return E_OK;
}
item = searchFunListN(&name);
if((item != NULL)) {
if (item->forward != 2)
return E_SEMA;
}
else {
fw = 2;
if(insertFunListItem(&name,enumerator,paramlist,fw,pc) != E_OK) return E_INTERN;}
if(InsertEmptyItemTape() != E_OK) return E_INTERN;
item = searchFunListN(&name);
Tape->last->instruction = FUNC;
//item->tape_ptr = Tape->last;
if (!strCmpConstStr (&(T.s), "var")) {
gettoken();
if ((error = localDecl()) != E_OK) return error; // deklarace lokalnich promennych
}
// printf("za local decl \n");
if (!strCmpConstStr (&(T.s), "begin")) {
gettoken();
// printf("za bein \n");
if ((error = blockList()) != E_OK) return error;
gettoken();
// printf("semicollon \n");
if ((error = testToken(T_SEMICOLON)) != E_OK) return error;
return E_OK;
}
else
return E_SYN;
break;
default:
return E_SYN;
}
}
