Subversion Repositories spk

#include "bod_text_parser.h"
#include "../common/strutils.h"

#include <memory.h>
//---------------------------------------------------------------------------------
// ERROR
const char* bod_text_parser::Error::m_messages[]={
        "No error",
        "Newline in constant"
};

// TOKEN
const char* bod_text_parser::token::specialChars[]={ "{", "}", ";", ":", "=", "/!", "!/", "/#", "(", ")", "/", ".", "+" };
char bod_text_parser::token::tabWidth;

const char* bod_text_parser::token::getText() const
{ 
        if(type >= t_text)
                return text;
        else
                return specialChars[(int)type];
}
//---------------------------------------------------------------------------------
void bod_text_parser::preParseBuffer(char *pszBuffer, size_t size)
{
        m_pszBuffer=pszBuffer;
        m_buffLen=size;
}       
//---------------------------------------------------------------------------------
size_t bod_text_parser::parseBuffer(size_t limit)
{
        char *ln;
        size_t old=tokens.size();
        while(ln=nextLine()){
                if(parseLine(ln, ++m_lineIdx)==false)
                        break;
                        
                if(limit!=-1 && ((tokens.size() - old) >= limit)){
                        break;
                }
        }
        return tokens.size() - old;
}
//---------------------------------------------------------------------------------
#define PUSH_PREVIOUS_STRING() { t=new token(); \
t->type=token::t_text; \
t->line=idx; \
t->text=old; \
t->col=(int)(old - line + 1); \
tokens.push_back(t); }

#define PUSH_TOKEN(_type, _col, _text) { t=new token(); \
t->type=_type; \
t->line=idx; \
t->col=(int)(_col); \
t->text=_text; \
tokens.push_back(t); }

bool bod_text_parser::parseLine(char *line, int idx)
{
        char *old=line, *pos=line, ch;
        token *t;
        bool bInQuotedString=false;
        
        while(*pos!=0){
                ch=*pos;
                
                if(bInQuotedString || (ch=='"' && testFlag(parseQuotedStrings))){
                        if(ch=='"'){
                                bInQuotedString=!bInQuotedString;
                                
                                *pos=0;
                                if(bInQuotedString){
                                        if(*old!=0)
                                                PUSH_PREVIOUS_STRING();
                                }       
                                // got string
                                else
                                        PUSH_TOKEN(token::t_quotedString, old - line, old);
                                        
                                old=pos + 1;
                        }
                        else{
                                ++pos;
                                continue;
                        }
                }
                
                else if(ch==';' || ch==':' || (ch=='=' && testFlag(parseEqual)) || 
                (testFlag(parseOperators) && (ch=='.' || ch=='+'))) {
                        *pos=0;
                        
                        if(*old!=0)
                                PUSH_PREVIOUS_STRING();
                        
                        token::Type ty;
                        switch(ch){
                                case ';':
                                        ty=token::t_semicolon;
                                        break;
                                case ':':
                                        ty=token::t_colon;
                                        break;
                                case '=':
                                        ty=token::t_equal;
                                        break;
                                case '.':
                                        ty=token::t_dot;
                                        break;
                                case '+':
                                        ty=token::t_plus;
                                        break;
                        }
                        PUSH_TOKEN(ty, pos - line + 1, 0);
                        
                        old=pos + 1;
                }
                // space or tabulator
                else if(ch==' ' || ch==0x9){
                        *pos=0;
                        if(*old!=0)
                                PUSH_PREVIOUS_STRING();
                        
                        old=pos + 1;
                }
                // brackets
                else if(ch=='{' || ch=='}' || (testFlag(parseStdBrackets) && (ch=='(' || ch==')'))) {
                        *pos=0;
                        if(*old!=0)
                                PUSH_PREVIOUS_STRING();
                        
                        token::Type ty;
                        switch(ch){
                                case '{':
                                        ty=token::t_openCrBracket;
                                        break;
                                case '}':
                                        ty=token::t_closeCrBracket;
                                        break;
                                case '(':
                                        ty=token::t_openStdBracket;
                                        break;
                                case ')':
                                        ty=token::t_closeStdBracket;
                                        break;
                        }
                        PUSH_TOKEN(ty, pos - line + 1, 0);
                        
                        old=pos + 1;
                }
                // either comment, header info or processing instruction
                else if(ch=='/') {
                        if(pos[1]=='#'){
                                t=new token();
                                t->text=pos + 2;
                                while(*t->text!=0 && *t->text==' ')
                                        t->text++;
                                if(*t->text==0)
                                        delete t;
                                else{
                                        t->line=idx;
                                        t->col=(int)(pos - line) + 1;
                                        t->type=token::t_hdrinfo;
                                        tokens.push_back(t);
                                }
                        }
                        // open proc instruction /!
                        if(pos[1]=='!') {
                                PUSH_TOKEN(token::t_openInstrBlock, pos - line + 1, 0);
                                old=pos + 2;
                                pos++;
                        }
                        // slash
                        else{
                                /* if ignore slash is on then do nothing
                                  else treat it as comment unless C comments are specified, in which case there must
                                  be // to make comment, otherwise / is treated as token
                                */
                                if(testFlag(parseIgnoreSlash)==false){
                                        if(testFlag(parseBODComments)) {
                                                *pos=0;
                                                pos--;
                                        }
                                        else if(testFlag(parseCComments) && pos[1]=='/') {
                                                *pos=0;
                                                pos--;
                                        }
                                        else {
                                                *pos=0;
                                                if(*old!=0)
                                                        PUSH_PREVIOUS_STRING();
                                                
                                                PUSH_TOKEN(token::t_slash, pos - line + 1, 0);
                                                old=pos + 1;
                                        }
                                }
                        }
                }
                // close proc instruction !/
                else if(ch=='!' && pos[1]=='/'){
                        *pos=0;
                        if(*old!=0)
                                PUSH_PREVIOUS_STRING();
                        
                        PUSH_TOKEN(token::t_closeInstrBlock, pos - line + 1, 0);
                        old=pos + 2;
                        pos++;
                }
                
                pos++;
        }
        
        if(bInQuotedString){
                error(idx, (int)strlen(line), Error::errNewLineInConstant);
                return false;
        }
        // if there are some chars left after last delimeter (usually ;) this will process them
        if(old!=pos){
                PUSH_TOKEN(token::t_text, old - line + 1, old);
        }
        return true;
}
//---------------------------------------------------------------------------------
char * bod_text_parser::nextLine()
{
        size_t i, size=m_buffLen;
        char *line=0, *buffer=(char*)m_pszBuffer;
        
        for(i=m_lastPos; i < size; i++){
                if(buffer[i]==0xD){
                        buffer[i]=0;
                        m_newPos=i;
                        if(((i + 1) < size) && buffer[i+1]==0xA) {
                                m_newPos++;
                        }
                        m_newPos++;
                        line=buffer + m_lastPos;
                        
                        break;
                }
                else if(buffer[i]==0xA){
                        buffer[i]=0;
                        m_newPos=i + 1;
                        
                        line=buffer + m_lastPos;
                        break;
                }
        }
        if(m_lastPos > size) return NULL;
        
        if(line==0) {
                line=buffer + m_lastPos;
                m_newPos=size + 1;
        }
        
        m_lastPos=m_newPos;
        
        return line;
}
//---------------------------------------------------------------------------------