Token* getToken(void) {
Token *token;
int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar]) {
case CHAR_SPACE: skipBlank(); return getToken();
case CHAR_LETTER: return readIdentKeyword();
case CHAR_DIGIT: return readNumber();
case CHAR_DOUBLEQUOTE: return readString();
case CHAR_PLUS:
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS:
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES:
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_SLASH:
token = makeToken(SB_SLASH, lineNo, colNo);
readChar();
return token;
case CHAR_LT:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_LE, ln, cn);
} else return makeToken(SB_LT, ln, cn);
case CHAR_GT:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_GE, ln, cn);
} else return makeToken(SB_GT, ln, cn);
case CHAR_EQ:
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_EXCLAIMATION:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_NEQ, ln, cn);
} else {
token = makeToken(TK_NONE, ln, cn);
error(ERR_INVALIDSYMBOL, ln, cn);
return token;
}
case CHAR_COMMA:
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_PERIOD:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_RPAR)) {
readChar();
return makeToken(SB_RSEL, ln, cn);
} else if (currentChar != EOF && charCodes[currentChar] == CHAR_DIGIT) {
token = readNumber();
token->lineNo = ln;
token->colNo = cn;
if (token->tokenType == TK_FLOAT){
error(ERR_INVALIDNUMBER, ln, cn);
token->tokenType = TK_NONE;
return token;
} else if (token->tokenType == TK_INT){
token->tokenType = TK_FLOAT;
int i;
if (strlen(token->string) >= MAX_IDENT_LEN){
token->tokenType = TK_NONE;
return token;
}
for (i = strlen(token->string); i >= 0; i--)
token->string[i+1] = token->string[i];
token->string[0] = '.';
token->value = atof(token->string);
return token;
}
return token;
}
else return makeToken(SB_PERIOD, ln, cn);
case CHAR_SEMICOLON:
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_COLON:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_ASSIGN, ln, cn);
} else return makeToken(SB_COLON, ln, cn);
case CHAR_SINGLEQUOTE: return readConstChar();
case CHAR_LPAR:
ln = lineNo;
cn = colNo;
readChar();
if (currentChar == EOF)
return makeToken(SB_LPAR, ln, cn);
switch (charCodes[currentChar]) {
case CHAR_PERIOD:
readChar();
return makeToken(SB_LSEL, ln, cn);
case CHAR_TIMES:
readChar();
skipComment();
return getToken();
default:
return makeToken(SB_LPAR, ln, cn);
}
case CHAR_RPAR:
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
}
}
Token* getToken(void) {
Token *token;
int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar]) {
case CHAR_SPACE: skipBlank(); return getToken();
case CHAR_LETTER: return readIdentKeyword();
case CHAR_DIGIT: return readNumber();
case CHAR_PLUS:
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS:
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES:
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_SLASH:
token = makeToken(SB_SLASH, lineNo, colNo);
readChar();
return token;
case CHAR_LT:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_LE, ln, cn);
} else return makeToken(SB_LT, ln, cn);
case CHAR_GT:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_GE, ln, cn);
} else return makeToken(SB_GT, ln, cn);
case CHAR_EQ:
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_EXCLAIMATION:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_NEQ, ln, cn);
} else {
token = makeToken(TK_NONE, ln, cn);
error(ERR_INVALID_SYMBOL, ln, cn);
return token;
}
case CHAR_COMMA:
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_PERIOD:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_RPAR)) {
readChar();
return makeToken(SB_RSEL, ln, cn);
} else return makeToken(SB_PERIOD, ln, cn);
case CHAR_SEMICOLON:
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_COLON:
ln = lineNo;
cn = colNo;
readChar();
if ((currentChar != EOF) && (charCodes[currentChar] == CHAR_EQ)) {
readChar();
return makeToken(SB_ASSIGN, ln, cn);
} else return makeToken(SB_COLON, ln, cn);
case CHAR_SINGLEQUOTE: return readConstChar();
case CHAR_DOUBLEQUOTE: return readConstString();
case CHAR_LPAR:
ln = lineNo;
cn = colNo;
readChar();
if (currentChar == EOF)
return makeToken(SB_LPAR, ln, cn);
switch (charCodes[currentChar]) {
case CHAR_PERIOD:
readChar();
return makeToken(SB_LSEL, ln, cn);
case CHAR_TIMES:
readChar();
skipComment();
return getToken();
default:
return makeToken(SB_LPAR, ln, cn);
}
case CHAR_RPAR:
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALID_SYMBOL, lineNo, colNo);
readChar();
return token;
}
}
Token* getToken(void) {
Token *token;
int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar]) {
case CHAR_SPACE: skipBlank(); return getToken();
case CHAR_LETTER: return readIdentKeyword();
case CHAR_DIGIT: return readNumber();
case CHAR_PLUS:
// Token Plus
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS:
// Token Minus
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES:
// Token Times
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_SLASH:
// Token Slash
token = makeToken(SB_SLASH, lineNo, colNo);
readChar();
return token;
case CHAR_LT:
// Empty token
token = makeToken(TK_NONE, lineNo, colNo);
// Check next character
readChar();
switch(charCodes[currentChar]) {
case CHAR_EQ:
// Token Lest Than or Equal
token->tokenType = SB_LE;
readChar();
return token;
case CHAR_GT:
// Token Lest Than or Equal
token->tokenType = SB_KHAC;
readChar();
return token;
default:
// Token Lest Than
token->tokenType = SB_LT;
return token;
}
case CHAR_GT:
// Token Greater
token = makeToken(SB_GT, lineNo, colNo);
// If next character is '='
readChar();
if (charCodes[currentChar] == CHAR_EQ) {
// Token is Greater Than
token->tokenType = SB_GE;
readChar();
}
return token;
case CHAR_EXCLAIMATION:
/* token = makeToken(SB_EXCLAIMATION, lineNo, colNo);
readChar();
return token;*/
// Make empty token
ln=lineNo;
cn=colNo;
token = makeToken(TK_NONE, lineNo, colNo);
// If next character is not '='
readChar();
switch(charCodes[currentChar]) {
case CHAR_EQ:
token->tokenType = SB_NEQ;
readChar();
return token;
default:
error(ERR_INVALIDSYMBOL, ln, cn);
readChar();
return token;
}
case CHAR_EQ:
// Token Equal
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_COMMA:
// Token Comma
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_PERIOD:
// Token Period
token = makeToken(SB_PERIOD, lineNo, colNo);
// If next character is Right Parenthesis
readChar();
if (charCodes[currentChar] == CHAR_RPAR) {
// it is token Right Parenthesis
token->tokenType = SB_RSEL;
readChar();
}
return token;
case CHAR_COLON:
// Token Semicolon
token = makeToken(SB_COLON, lineNo, colNo);
// If next character is Equal
readChar();
if (charCodes[currentChar] == CHAR_EQ) {
// it is token Assignment
token->tokenType = SB_ASSIGN;
readChar();
}
return token;
case CHAR_SEMICOLON:
// Token Semicolon
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_SINGLEQUOTE:
return readConstChar();
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
case CHAR_RPAR:
// Token Right Parenthesis
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
case CHAR_LPAR:
// Empty token
token = makeToken(TK_NONE, lineNo, colNo);
// Get next character first
readChar();
switch(charCodes[currentChar]) {
case CHAR_PERIOD:
// This is token LSEL
token->tokenType = SB_LSEL;
readChar();
return token;
case CHAR_TIMES:
// This is a comment so free the allocated token first then skip comments
free(token);
skipComment();
return getToken();
//case CHAR_SPACE:
//readChar();
//return getToken();
default:
// Token Left Parenthesis
token->tokenType = SB_LPAR;
// readChar();
return token;
}
}
}
Token* getToken(void)
{
Token *token;
int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar])
{
case CHAR_SPACE:
skipBlank();
return getToken();
case CHAR_LETTER:
return readIdentKeyword();
case CHAR_DIGIT:
return readNumber();
case CHAR_PLUS:
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS:
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_LPAR:
readChar();
switch (charCodes[currentChar])
{
case CHAR_TIMES:
skipComment();
return getToken();
case CHAR_PERIOD:
token = makeToken(SB_LSEL, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(SB_LPAR, lineNo, colNo);
return token;
}
case CHAR_RPAR:
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES:
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_SEMICOLON:
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_COLON:
readChar();
switch (charCodes[currentChar])
{
case CHAR_EQ:
token = makeToken(SB_ASSIGN, lineNo, colNo-1);
readChar();
return token;
default:
token = makeToken(SB_COLON, lineNo, colNo);
readChar();
return token;
}
case CHAR_PERIOD:
readChar();
switch (charCodes[currentChar])
{
case CHAR_RPAR:
token = makeToken(SB_RSEL, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(SB_PERIOD, lineNo, colNo);
readChar();
return token;
}
case CHAR_EQ:
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_EXCLAIMATION:
readChar();
switch (charCodes[currentChar])
{
case CHAR_EQ:
token = makeToken(SB_NEQ, lineNo, colNo-1);
readChar();
return token;
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
}
case CHAR_COMMA:
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_SINGLEQUOTE:
return readConstChar();
// TODO
case CHAR_LT:
readChar();
switch (charCodes[currentChar])
{
case CHAR_EQ:
token = makeToken(SB_LE, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(SB_LT, lineNo, colNo);
return token;
}
case CHAR_GT:
readChar();
switch (charCodes[currentChar])
{
case CHAR_EQ:
token = makeToken(SB_GE, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(SB_GT, lineNo, colNo);
return token;
}
// TODO: xu ly dau _
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
}
}
Token* getToken(void) {
Token *token;
int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar]) {
case CHAR_SPACE: skipBlank(); return getToken();
case CHAR_LETTER: return readIdentKeyword();
case CHAR_DIGIT: return readNumber();
case CHAR_PLUS:
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS:
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES:
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_LT:
token = makeToken(SB_LT, lineNo, colNo);
readChar();
if (charCodes[currentChar] == CHAR_EQ) {
token->tokenType = SB_LE;
readChar();
}
return token;
case CHAR_GT:
token = makeToken(SB_GT, lineNo, colNo);
readChar();
if (charCodes[currentChar] == CHAR_EQ) {
token->tokenType = SB_GE;
readChar();
}
return token;
case CHAR_EXCLAIMATION:
token = makeToken(TK_NONE, lineNo, colNo);
readChar();
if (charCodes[currentChar] == CHAR_EQ) {
token->tokenType = SB_NEQ;
readChar();
}
return token;
case CHAR_EQ:
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_PERIOD:
token = makeToken(SB_PERIOD, lineNo, colNo);
readChar();
if (charCodes[currentChar] == CHAR_RPAR) {
token->tokenType = SB_RSEL;
readChar();
}
return token;
case CHAR_COMMA:
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_COLON:
token = makeToken(SB_COLON, lineNo, colNo);
readChar();
// If the next character is equal
if (charCodes[currentChar] == CHAR_EQ) {
token->tokenType = SB_ASSIGN;
readChar();
}
return token;
case CHAR_SEMICOLON:
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_SINGLEQUOTE: return readConstChar();
case CHAR_LPAR:
token = makeToken(SB_LPAR, lineNo, colNo);
readChar();
if (charCodes[currentChar] == CHAR_TIMES) {
skipComment();
readChar();
return getToken();
} else if (charCodes[currentChar] == CHAR_PERIOD) {
token->tokenType = SB_LSEL;
readChar();
}
return token;
case CHAR_RPAR:
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
}
}
Token* getToken(void) {
Token *token;
// int ln, cn;
if (currentChar == EOF)
return makeToken(TK_EOF, lineNo, colNo);
switch (charCodes[currentChar]) {
case CHAR_SPACE: skipBlank(); return getToken();
case CHAR_LETTER: return readIdentKeyword();
case CHAR_DIGIT: return readNumber();
case CHAR_PLUS: //'+'
token = makeToken(SB_PLUS, lineNo, colNo);
readChar();
return token;
case CHAR_MINUS://"-"
token = makeToken(SB_MINUS, lineNo, colNo);
readChar();
return token;
case CHAR_TIMES://'*'
token = makeToken(SB_TIMES, lineNo, colNo);
readChar();
return token;
case CHAR_SLASH://'/'
token = makeToken(SB_SLASH, lineNo, colNo);
readChar();
return token;
case CHAR_LT://'<'
token = makeToken(SB_LT, lineNo, colNo);
readChar();
return token;
case CHAR_GT://'>'
token = makeToken(SB_GT, lineNo, colNo);
readChar();
return token;
case CHAR_EXCLAIMATION://'!'
token = makeToken(TK_NONE, lineNo, colNo);
readChar();
if(charCodes[currentChar]==CHAR_EQ){
token->tokenType=SB_NEQ;
readChar();
}else{
error(ERR_INVALIDSYMBOL,lineNo,colNo);
}
return token;
case CHAR_EQ://'='
token = makeToken(SB_EQ, lineNo, colNo);
readChar();
return token;
case CHAR_COMMA://','
token = makeToken(SB_COMMA, lineNo, colNo);
readChar();
return token;
case CHAR_PERIOD://'.'
token = makeToken(SB_PERIOD, lineNo, colNo);
readChar();
return token;
case CHAR_COLON://':'
token = makeToken(SB_COLON, lineNo, colNo);
readChar();
if(charCodes[currentChar]==CHAR_EQ){
token->tokenType=SB_ASSIGN;
readChar();
}
return token;
case CHAR_SEMICOLON://';'
token = makeToken(SB_SEMICOLON, lineNo, colNo);
readChar();
return token;
case CHAR_SINGLEQUOTE://'\'
return readConstChar();
case CHAR_LPAR://'('
token = makeToken(SB_LPAR, lineNo, colNo);
readChar();
if(charCodes[currentChar]==CHAR_TIMES){
skipComment();
token->tokenType=TK_NONE;
}
return token;
case CHAR_RPAR://')'
token = makeToken(SB_RPAR, lineNo, colNo);
readChar();
return token;
// note sb_assign,SB_NEQ,SB_LE,SB_GE,SB_LSEL, SB_RSEL don't know what to do :))))
// ....
// TODO
// ....
default:
token = makeToken(TK_NONE, lineNo, colNo);
error(ERR_INVALIDSYMBOL, lineNo, colNo);
readChar();
return token;
}
}
