Token LexParser_readIdOrKeyword(LexParser *self, char ch) {
Token found;
String_clear(&self->str);
String_append(&self->str, tolower(ch));
ch = tolower(BuffFile_get(&(self->input)));
while ( isalnum(ch) || ch == '_') {
String_append(&self->str, tolower(ch));
ch = BuffFile_get(&(self->input));
}
BuffFile_pushBack(&self->input, ch);
found = LexParser_keywordCheck(&self->str);
if (found == t_id)
LexParser_syncLastVar(self);
return found;
}
void LexParser_readString(LexParser * self) {
char ch, ch2;
while (true) {
ch = BuffFile_get(&(self->input));
if (ch == EOF)
Lex_throwError(self, "String missing right ' (end of string).\n");
else if (ch == '\'') {
ch2 = BuffFile_get(&(self->input));
if (ch2 != '\'') {
ch = ch2;
break;
}
}
if(ch <= 30)
Lex_throwError(self, "Invalid char in string.\n");
String_append(&(self->str), ch);
}
/*BuffFile_pushBack(&(self->input), ch);
ch = BuffFile_get(&(self->input));*/
while (true) {
if (ch == '\'') {
LexParser_readString(self);
} else if (ch == '#') {
LexParser_readEscape(self);
} else {
break;
}
ch = BuffFile_get(&(self->input));
}
BuffFile_pushBack(&(self->input), ch);
}
Token LexParser_next(LexParser *self) {
char ch;
char ch2;
while ((ch = BuffFile_get(&(self->input))) != EOF) {
if (!isspace(ch))
switch (ch) {
case ';':
return t_scolon;
case '-':
return t_minus;
case '+':
return t_plus;
case '*':
return t_asterisk;
case '/':
return t_slash;
case ',':
return t_comma;
case '=':
return t_eqv;
case '(':
return t_lParenthessis;
case ')':
return t_rParenthessis;
case '{':
LexParser_readComment(self);
break;
case '\'':
String_clear(&self->str);
LexParser_readString(self);
String_append(&self->str, 0);
return t_str_val;
case '.':
ch2 = BuffFile_get(&(self->input));
BuffFile_pushBack(&(self->input), ch2);
if (isdigit(ch2)) {
return LexParser_parseNum(self, ch);
}
return t_period;
case ':':
return LexParser_colonOrAssigment(self);
case '<':
return LexParser_lessFound(self);
case '>':
return LexParser_greaterFound(self);
default:
if (isdigit(ch)) {
return LexParser_parseNum(self, ch);
}
if (isalpha(ch) || ch == '_')
return LexParser_readIdOrKeyword(self, ch);
else
Lex_throwError(self, "Can't resolve token from string");
}
}
return t_eof;
}
void LexParser_readEscape(LexParser * self) {
char ch = '0';
String str;
String__init__(&str, 4);
while (isdigit(ch)) {
ch = BuffFile_get(&(self->input));
String_append(&str, ch);
}
if (str.len < 1)
Lex_throwError(self, "Incomplete escape sequence.\n");
int escp = atoi(str.buff);
String__dell_(&str);
if (escp > 255)
Lex_throwError(self, "Unknown escape sequence.\n");
String_append(&(self->str), (char) escp);
if (ch == '\'')
LexParser_readString(self);
else if (ch == '#')
LexParser_readEscape(self);
else
BuffFile_pushBack(&(self->input), ch);
}
String File_appendFileName(String fileName, const String name)
{
assert(fileName != NULL);
assert(name != NULL);
if (String_length(fileName) > 0)
{
if (String_index(fileName,String_length(fileName)-1) != FILES_PATHNAME_SEPARATOR_CHAR)
{
String_appendChar(fileName,FILES_PATHNAME_SEPARATOR_CHAR);
}
}
String_append(fileName,name);
return fileName;
}
String* readline(String* str)
{
String* ret_string = str ? str : String_construct(10);
String_empty(str);
while(1)
{
char buffer[21];
buffer[20] = 0;
fgets(buffer, sizeof(buffer), stdin);
String_append(ret_string, buffer);
if(strlen(buffer)!=sizeof(buffer)-1)
break;
}
return ret_string;
};
Token LexParser_parseNum(LexParser * self, char ch) {
NumParsingState st;
if (ch == '.')
st = np_needAfterDot;
else
st = np_int;
String_clear(&self->str);
String_append(&self->str, ch);
while (true) {
ch = BuffFile_get(&self->input);
switch (st) {
case np_int:
if (isdigit(ch)) {
break;
} else if (ch == '.') {
st = np_needAfterDot;
} else if (ch == 'e' || ch == 'E') {
ch = 'e';
st = np_needExponent;
} else {
BuffFile_pushBack(&self->input, ch);
return t_num_int;
}
break;
case np_needAfterDot:
if (isdigit(ch))
st = np_real;
else
Lex_throwError(self, "expected number after dot");
break;
case np_needExponent:
if (isdigit(ch))
st = np_expReal;
else if (ch == '-' || ch == '+') {
st = np_needExponent_gotSign;
} else
Lex_throwError(self, "expected number as exponent");
break;
case np_needExponent_gotSign:
if (isdigit(ch))
st = np_expReal;
else
Lex_throwError(self, "expected number as exponent");
break;
break;
case np_real:
if (isdigit(ch)) {
} else if (ch == 'e' || ch == 'E') {
ch = 'e';
st = np_needExponent;
} else {
BuffFile_pushBack(&self->input, ch);
return t_num_real;
}
break;
case np_expReal:
if (ch == '.')
st = np_expReal_needAfterDot;
else if (isdigit(ch)) {
break;
} else {
BuffFile_pushBack(&self->input, ch);
return t_num_real;
}
break;
case np_expReal_needAfterDot:
if (isdigit(ch))
st = np_expReal_realExp;
else
Lex_throwError(self, "expected number after dot in exponent");
break;
case np_expReal_realExp:
if (!isdigit(ch)) {
BuffFile_pushBack(&self->input, ch);
return t_num_real;
}
}
String_append(&self->str, ch);
}
Lex_throwError(self, "Lex parser is unable to parse number");
return t_invalid;
}
