static char isPragma(char *p)
{
p = skipBlank(p);
if( !isSharp(*p++) ) return 0;
p = skipBlank(p);
if( !startsWithWord(p, "pragma") ) return 0;
return 1;
}
int insertClientProxy(char *buf,int i) //humeng add 11.4.23
{
ClientProxyPtr node,cltPrxs;
AtomPtr temp,addr,key;
int x,y,rc;
if(!buf[i]=='=') return(0);
i++;
skipBlank(buf,i);
x=i;
while(!(buf[i] == '\n' || buf[i] == '\0' || buf[i] == '#'))
{
skipBlank(buf,i);
i++;
}
if(i>x+1)
temp=internAtomN(buf+x,i-x-1);
rc = atomSplit(temp, ':', &addr, &key);
if(rc <= 0) {
do_log(L_ERROR, "Couldn't parse parentProxy.");
return -1;
}
node=malloc(sizeof(ClientProxyRec));
node->next=NULL;
node->addr=addr;
node->key=key;
node->keyHash=keyHasher(key->string, key->length);
if(clientProxys==NULL)
{
clientProxys=node;
return 1;
}else
{
cltPrxs=clientProxys;
while(cltPrxs)
{
if(strcmp(cltPrxs->addr->string,node->addr->string)==0)
{
cltPrxs->key=node->key;
cltPrxs->keyHash=node->keyHash;
return 1;
}
if(cltPrxs->next==NULL)
{
cltPrxs->next=node;
return 1;
}
cltPrxs=cltPrxs->next;
}
}
return 1;
}
int getPassword(char *buf,int i) //added by yangkun
{
AtomPtr temp;
int x;
if(!buf[i]=='=') return -1;
i++;
x=skipBlank(buf,i);
while(!(buf[i] == '\n' || buf[i] == '\0' || buf[i] == '#'))
{
skipBlank(buf,i);
i++;
}
if(i>x+1)
{
temp = internAtomN(buf+x,i-x-1);
password = temp->string;
}
return 0;
}
int setAddress(char *buf,int i) //added by yangkun
{
AtomPtr temp1, temp2;
int x;
if(!buf[i]=='=') return -1;
i++;
x=skipBlank(buf,i);
while(!(buf[i] == '\n' || buf[i] == '\0' || buf[i] == '#'))
{
skipBlank(buf,i);
i++;
}
if(i>x+1)
{
temp1 = internAtomN(buf+x,i-x-1);
temp2 = internAtom("http://");
temp2 = atomCat(temp2, temp1->string);
temp2 = atomCat(temp2, "/heartbeat.php");
releaseAtom(temp1);
address = temp2->string;
}
return 0;
}
/// 解析一个Token
char *LexicalAnalysis::analyseToken(char *stream, TokenNode &tokenNode)
{
char *tmpstr = stream;
switch (analyseState(stream)) {
case Keyword:
tmpstr = analyseIden(tmpstr, tokenNode);
tmpstr = skipBlank(tmpstr);
break;
case Number:
tmpstr = analyseNumber(tmpstr, tokenNode);
tmpstr = skipBlank(tmpstr);
break;
case Iterator:
tmpstr = analyseIterator(tmpstr, tokenNode);
tmpstr = skipBlank(tmpstr);
break;
case Limit:
tmpstr = analyseLimit(tmpstr, tokenNode);
tmpstr = skipBlank(tmpstr);
break;
case Endline:
*tmpstr = '\0';
break;
case Blank:
tmpstr = skipBlank(tmpstr);
tokenNode.key = " ";
break;
case Error:
tmpstr++;
break;
default:
break;
}
return tmpstr;
}
static int isInclude(char *p)
{
p = skipBlank(p);
if( !isSharp(*p++) ) return 0;
p = skipBlank(p);
if( strncmp(p, "include", 7) != 0 ) return 0;
p += 7;
p = skipBlank(p);
if( *p != '"' && *p != '<') return 0;
int isSystemInclude = (*p == '<');
char terminator = (isSystemInclude)? '>' : '"';
char *lastTerminatorP = NULL; //last terminator's pointer
//find last terminator
while( *++p != '\0' ){
if( *p == terminator ) lastTerminatorP = p;
}
if(lastTerminatorP == NULL) return 0;
p = lastTerminatorP;
while(*++p != '\0'){
if( !isBlank(*p) ) return 0;
}
return (isSystemInclude)? SYSTEM_INCLUDE : USER_INCLUDE;
}
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;
}
}
WicErrors getNextToken(pToken tok)
{
pTokTab tokTabPtr;
WicErrors retVal = ERR_NONE;
static long tokAfterDefine = 2; // used to flag '(' in #define x( as a
// special parentheses
int temp;
assert(currTokF >= 0);
currTokLen = 0;
currTok[currTokLen] = 0;
TOK_NUM_AFTER_NEW_LINE++; /* Used for #preprocessor directives */
tokAfterDefine++; /* Used for #preprocessor directives */
g_currLineNum = LINE_NUM;
g_currColNum = COL_NUM;
/* When getNextToken gets called, STATE may be one of:
TS_START, TS_COMMENT. */
temp = skipBlank();
if (STATE == TS_START) {
setTokPos(
tok->pos,
TOK_FILE_NAME,
currTokF,
LINE_NUM,
COL_NUM,
LINES_BEFORE,
temp,
orderLineNum
);
while (NEXT_CHAR == ' ') {
getNextChar();
tok->pos->spacesBefore = skipBlank();
}
if (isalpha(NEXT_CHAR) || NEXT_CHAR == '_') {
if (!scanId()) {
char saveChar = NEXT_CHAR;
currTokLen = 0;
currTok[currTokLen] = 0;
getNextChar();
if (saveChar == '"') {
retVal = scanStr(tok->data);
} else {
retVal = scanChar(tok->data);
}
goto Return;
}
} else if (isdigit(NEXT_CHAR)) {
retVal = scanNum(tok->data);
goto Return;
} else switch (NEXT_CHAR) {
case '\'':
getNextChar();
retVal = scanChar(tok->data);
goto Return;
break;
case '"':
if (currLineIsInclude) {
getNextChar();
retVal = scanIncludeFileName(tok->data, '"');
goto Return;
} else {
getNextChar();
retVal = scanStr(tok->data);
goto Return;
break;
}
case '\n':
pushGetNextChar();
currLineIsInclude = 0;
break;
case '!':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case '#':
pushGetNextChar();
if (TOK_NUM_AFTER_NEW_LINE == 1) {
skipBlank();
if (isalpha(NEXT_CHAR) || NEXT_CHAR == '_') {
scanId();
} else {
tok->data->code = Y_PRE_NULL;
retVal = ERR_NONE;
goto Return;
}
} else {
if (NEXT_CHAR == '#') {
pushGetNextChar();
}
}
break;
case '%':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case '&':
pushGetNextChar();
if (NEXT_CHAR == '&') {
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
}
break;
case '(':
pushGetNextChar();
break;
case ')':
pushGetNextChar();
break;
case '*':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case '+':
pushGetNextChar();
if (NEXT_CHAR == '+') {
pushGetNextChar();
} else if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case ',':
pushGetNextChar();
break;
case '-':
pushGetNextChar();
if (NEXT_CHAR == '-') {
pushGetNextChar();
} else if (NEXT_CHAR == '=') {
pushGetNextChar();
} else if (NEXT_CHAR == '>') {
pushGetNextChar();
}
break;
case '.':
pushGetNextChar();
if (NEXT_CHAR == '.') {
pushGetNextChar();
if (NEXT_CHAR == '.') {
pushGetNextChar();
} else {
retVal = RERR_INV_CHAR;
goto Return;
}
} else if (isdigit(NEXT_CHAR)) {
if (pushFloatDotExp(tok->data, 1)) {
retVal = convStr2Const(tok->data);
goto Return;
} else {
retVal = RERR_INV_CHAR;
goto Return;
}
}
break;
case '/':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
} else if (NEXT_CHAR == '*') { /* comment begin */
popChars(1);
STATE = TS_COMMENT;
getNextChar();
retVal = scanComment(tok->data);
goto Return;
} else if (NEXT_CHAR == '/') {
popChars(1);
STATE = TS_COMMENT;
getNextChar();
retVal = scanCPlusPlusComment(tok->data);
goto Return;
}
break;
case ':':
pushGetNextChar();
if (NEXT_CHAR == '>') {
pushGetNextChar();
}
break;
case ';':
pushGetNextChar();
break;
case '<':
if (currLineIsInclude) {
getNextChar();
retVal = scanIncludeFileName(tok->data, '>');
goto Return;
} else {
pushGetNextChar();
if (NEXT_CHAR == '<') {
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
} else if (NEXT_CHAR == '=') {
pushGetNextChar();
}
}
break;
case '=':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case '>':
pushGetNextChar();
if (NEXT_CHAR == '>') {
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
}
} else if (NEXT_CHAR == '=') {
pushGetNextChar();
}
break;
case '?':
pushGetNextChar();
break;
case '[':
pushGetNextChar();
break;
case ']':
pushGetNextChar();
break;
case '^':
pushGetNextChar();
if (NEXT_CHAR == '=')
pushGetNextChar();
break;
case '{':
pushGetNextChar();
break;
case '|':
pushGetNextChar();
if (NEXT_CHAR == '=') {
pushGetNextChar();
} else if (NEXT_CHAR == '|') {
pushGetNextChar();
}
break;
case '}':
pushGetNextChar();
break;
case '~':
pushGetNextChar();
break;
case (char) EOF:
tok->data->code = Y_EOF;
retVal = ERR_NONE;
goto Return;
break;
default:
/* Eat up an ivalid character */
getNextChar();
retVal = RERR_INV_CHAR;
goto Return;
}
tokTabPtr = tabLookup(currTok);
if (tokTabPtr != NULL)
{
tok->data->code = tokTabPtr->code;
if (tok->data->code == Y_PRE_INCLUDE) {
currLineIsInclude = 1;
}
if (tok->data->code == Y_PRE_DEFINE) {
tokAfterDefine = 0;
}
if (tok->data->code == Y_LEFT_PAREN && tokAfterDefine == 2) {
// the case of #define x(...
if (tok->pos->spacesBefore == 0) {
tok->data->code = Y_PRE_SPECIAL_LEFT_PAREN;
}
}
tok->data->repr.string = registerString(tokTabPtr->name,
!FREE_STRING);
}
else {
if (currTok[0] == '#') {
retVal = RERR_INV_PREPROCESSOR;
goto Return;
} else {
tok->data->code = Y_ID;
tok->data->repr.string = registerString(wicStrdup(currTok),
FREE_STRING);
}
}
} else if (STATE == TS_COMMENT) {
setTokPos(tok->pos, TOK_FILE_NAME, currTokF, LINE_NUM, COL_NUM,
LINES_BEFORE, 0, orderLineNum);
retVal = scanComment(tok->data);
goto Return;
} else {
assert(0);
}
Return:
if (tok->data->code != Y_PRE_NEWLINE) {
tok->pos->linesBefore = tok->pos->lineNum - PREV_TOK_LINE_NUM;
PREV_TOK_LINE_NUM = tok->pos->lineNum;
} else {
tok->pos->linesBefore = 0;
}
zapTokPos(g_currPos);
g_currPos = dupTokPos(tok->pos, NULL);
return retVal;
}
static char *getPragmaStr(char *p)
{
return skipBlank(skipWord(skipBlank(skipSharp(skipBlank(p)))));
}
int insertParentProxy(char *buf,int i) //humeng add 11.5.10
{
ParentProxyPtr node,prtPrxs;
AtomPtr temp,addr,key,atom, port,allowIP;
AtomListPtr tempList;
int x,y,rc;
if(!buf[i]=='=') return(0);
i++;
skipBlank(buf,i);
x=i;
while(!(buf[i] == '\n' || buf[i] == '\0' || buf[i] == '#'))
{
skipBlank(buf,i);
i++;
}
if(i>x+1)
temp=internAtomN(buf+x,i-x-1);
rc = atomSplit(temp, ':', &addr, &temp);
if(rc <= 0) {
do_log(L_ERROR, "Couldn't parse parentProxy.");
return -1;
}
node=malloc(sizeof(ParentProxyRec));
node->addr=addr;
rc = atomSplit(temp, ':', &port, &temp);
if(rc <= 0) {
do_log(L_ERROR, "Couldn't parse parentProxy.");
return -1;
}
node->port=port;
//node->friendName=intern;
rc = atomSplit(temp, '-', &key, &allowIP);
if(rc <= 0) {
do_log(L_ERROR, "Couldn't parse parentProxy.");
return -1;
}
node->key=key;
node->keyHash=keyHasher(key->string, key->length);
tempList=findProxyClient(allowIP->string);
if(tempList){
node->allowIP=parseNetAddress(tempList);
}
if(ParentProxys==NULL)
{
ParentProxys=node;
//updateParentProxy("59.66.24.76","123","166.111.132.138");
return 1;
}else
{
prtPrxs=ParentProxys;
while(prtPrxs)
{
if(strcmp(prtPrxs->addr->string,node->addr->string)==0)
{
prtPrxs->port=node->port;
prtPrxs->key=node->key;
prtPrxs->keyHash=node->keyHash;
prtPrxs->allowIP=node->allowIP;
return 1;
}
if(prtPrxs->next==NULL)
{
prtPrxs->next=node;
return 1;
}
prtPrxs=prtPrxs->next;
}
}
return 1;
}
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;
}
}
