Subversion Repositories spk

#include "bod_cut_parser.h"
#include "../common/strutils.h"
//---------------------------------------------------------------------------------
bool bod_cut_parser::compile(token_stream& is, bob_dom_obinaryfilestream& os)
{
        os << bob_dom_cut::hdr_begin;
        
        bob_dom_cut *cut=loadCUT(is, &os, true);
        
        //if(cut)
                //cut->toFile(os);
        
        delete cut;
        
        os << bob_dom_cut::hdr_end;
        
        return cut!=NULL;
}
//---------------------------------------------------------------------------------
bob_dom_cut * bod_cut_parser::loadCUT(token_stream& is)
{
        bob_dom_obinaryfilestream *dummy=0;
        
        return loadCUT(is, dummy, false);
}
//---------------------------------------------------------------------------------
// this is bit weird function as it serves for 2 purposes: it can return loaded cut object
// or it can directly output parts of cut as it's being loaded
bob_dom_cut * bod_cut_parser::loadCUT(token_stream& is, bob_dom_obinaryfilestream *os, bool bDirectOutput)
{
        bod_text_parser::token *t;
        bob_dom_path *actPath=0;
        bob_dom_stat *actStat=0;
        bob_dom_cut *cut=new bob_dom_cut(m_settings);
        
        // used for direct output
        int pathCountOffset;
        int pathCount=0;
        
        bool bErrors=false;
        bool bRes=false;
        
        while(is.good() && is.tok()->type==token::t_hdrinfo){
                if(cut->info.text()!=0)
                        error(is.tok(), S_Warning, "Header info already defined, last value will be used");
                cut->info.text(is.tok()->text);
                ++is;
        }

        do{
                // VERSION
                t=is.tok();
                if(t==NULL || t->type!=token::t_text || strcmp(t->text, "VER")!=0)
                        { error(t ? t : is.previous(), S_Error, "Expected version specification"); break; }
                
                t=(++is).tok();
                if(t==NULL || t->type!=token::t_colon)
                        { error(t ? t : is.previous(), S_Error, "Expected ':' after '%s'", is.previous()->text); break; }
                
                if(!checkImmediatePlacement(is.previous(), is.tok())) 
                        break;
                
                if((t=loadValue(++is))==NULL)
                        break;
                if(!isinteger(t->text))
                        { error(t ? t : is.previous(), S_Error, "Expected version number after ':'"); break; }
                        
                cut->version=atoi(t->text);
                
                if(cut->version > bob_dom_cut::supported_version)
                        error(is.tok(), S_Warning, "File version is %d, supported version is %d", cut->version, bob_dom_cut::supported_version);
                
                if(bDirectOutput){
                        cut->info.toFile(*os);
                        *os << cut->version; 
                        /*      
                                we must output the path count right now, 
                                but we will rewrite it once we finish
                        */
                        pathCountOffset=(int)os->tell();
                        *os << pathCount; 
                }
                
                while(is.good()){
                        t=is.tok();
                        
                        if(t->type==token::t_openBracket){
                                if(actPath==NULL){
                                        error(t, S_Error, "Block unexpected here.");
                                        break;
                                }
                                else{
                                        bErrors|=!loadFrame(actPath, ++is); 
                                }
                        }
                        
                        else{
                                if(actPath && bDirectOutput){
                                        pathCount++;
                                        actPath->toFile(*os, cut->version);
                                        cut->removeChild(--cut->end());
                                }
                                if((actPath=loadPath(cut, is))==NULL)
                                        break;
                                
                                if(!is.good()){
                                        error(is.previous(), S_Error, "Missing Frame declaration after Body declaration");
                                        break;
                                }
                        }
                        bRes=!bErrors;
                }
        }
        while(false);
        
        if(actPath && bDirectOutput){
                pathCount++;
                actPath->toFile(*os, cut->version);
                cut->removeChild(--cut->end());
        }
        
        if(bRes==false){
                delete cut;
                return NULL;
        }
        else{
                if(bDirectOutput){      
                        size_t endPos=os->tell();
                        os->seek(pathCountOffset, bob_filestream::seek_begin);
                        *os << pathCount;
                        os->seek((int)endPos, bob_filestream::seek_begin);
                }
                return cut;
        }
}
//---------------------------------------------------------------------------------
bob_dom_path * bod_cut_parser::loadPath(bob_dom_cut *cut, token_stream& is)
{
        bob_dom_path *path=cut->createChild();

        bool bRes=false;
        
        bod_text_parser::token *t;
        
        do{
                t=is.tok();
                
                // index
                if(t==NULL || t->type!=token::t_text || strcmp(t->text, "P")!=0)
                        { error(t ? t : is.previous(), S_Error, "Expected body declaration starting with Path ID (P)."); break; }
                if((t=loadValue(++is))==NULL)
                        break;
                if(!isinteger(t->text))
                        { error(t, S_Error, "Body declaration: Expected number after '%s'", is.previous()->text); break; }
                else
                        path->partIdx=atoi(t->text);
                
                // body id
                t=is.tok();
                if(t==NULL || t->type!=token::t_text || strcmp(t->text, "B")!=0)
                        { error(t ? t : is.previous(), S_Error, "Body declaration: Expected Body ID (B)."); break; }
                if((t=loadValue(++is))==NULL)
                        break;
                if(cut->version < 6 && !isinteger(t->text)) {
                        error(t, S_Error, "Body declaration: body ID is string but cut version is %d. Change version to 6.", cut->version);
                        break;
                }
                path->bodyId(t->text);
                
                bRes=true;
                
                bool bCockpit=false, bParentIdx=false, bName=false, bNotes=false;
                
                // cockpit, name, flag, body flag, inner bob, notes
                while(is.good()){
                        t=is.tok();
                        if(t->type==token::t_openBracket)
                                break;
                                
                        if(t->type!=token::t_text || strlen(t->text) > 1){
                                error(t, S_Error, "Unexpected here: '%s'", t->getText());
                                bRes=false;
                                break;
                        }
                        
                        char ch=t->text[0];
                        
                        // cockpit index
                        if(ch=='C'){
                                if((t=loadValue(++is))==NULL)
                                        { bRes=false; break; }
                                if(!isinteger(t->text))
                                        { error(t, S_Error, "Body declaration: Expected number after '%s'", is.previous()->text); bRes=false; break; }
                                
                                if(bCockpit)
                                        error(t, S_Warning, "Cockpit index already defined, last value will be used");
                                
                                bCockpit=true;
                                path->cockpitIdx=atoi(t->text);
                        }
                        // parent index
                        else if(ch=='F'){
                                if((t=loadValue(++is))==NULL)
                                        { bRes=false; break; }
                                if(!isinteger(t->text))
                                        { error(t, S_Error, "Body declaration: Expected number after '%s'", is.previous()->text); bRes=false; break; }
                                
                                if(bParentIdx)
                                        error(t, S_Warning, "Parent index already defined, last value will be used");
                                        
                                bParentIdx=true;
                                path->parentIdx=atoi(t->text);
                        }
                        // name
                        else if(ch=='N'){
                                const char *name=loadString(++is);
                                if(name==0) break;
                                
                                if(bName)
                                        error(t, S_Warning, "Name already defined, last value will be used");
                                
                                bName=true;
                                path->name.m_text=(char*)name;
                        }
                        // embedded bob
                        else if(ch=='L'){
                                t=(++is).tok();
                                if(t==NULL || t->type!=token::t_openBracket)
                                        { error(t ? t : is.previous(), S_Error, "Expected beginning of block after '%s'", is.previous()->getText()); bRes=false; break; }
                                else{
                                        ++is;
                                        path->bob=loadBOB(is, true);
                                        if(path->bob==NULL) {
                                                bRes=false; break;
                                        }
                                }
                        }
                        // notes
                        else if(ch=='T'){
                                if(loadNote(path, is)==false) 
                                        { bRes=false; break; }
                                
                                if(bNotes)
                                        error(t, S_Warning, "Notes already defined, last definition will be used");
                                
                                bNotes=true;
                        }
                        // constants
                        else if(ch=='K'){
                                int count;
                                bob_dom_constants::constant c;
                                
                                if(!loadIntValue(++is, &count)){
                                        bRes=false; break;
                                }
                                for(int i=0; i < count; i++){
                                        loadIntValue(is, &(c.a));
                                        if(!loadDoubleValue(is, &(c.b))){
                                                bRes=false; break;
                                        }
                                        path->constants.values.push_back(c);
                                }
                                if(bRes==false) break;  
                        }
                        // last try if it's a body flag (Camera, Light, Direct, v). It must not be followed by semicolon
                        else{
                                t=(++is).tok();
                                if(t){
                                        if(t->type==token::t_semicolon)
                                                { error(t, S_Error, "Invalid Body flag specification '%s': flag must NOT be followed by ';'", is.previous()->text); bRes=false; break; }
                                        if(t->type==token::t_colon)
                                                { error(t, S_Error, "Unexpected here: ':'"); bRes=false; break; }
                                }
                                if(!(ch >='a' && ch<='z' || ch>='A' && ch<='Z'))
                                        { error(is.previous(), S_Error, "Invalid Body flag specification '%c': flag must be alphabetic character", ch); bRes=false; break; }
                                if(ch!='c' && ch!='l' && ch!='d' && ch!='v' && ch!='b' && ch!='j' && ch!='u')
                                        { error(is.previous(), S_Warning, "Body flag '%c' out of safe limits, known values are 'c', 'l', 's', 'v', 'p', 'j', 'u'", ch); }
                                
                                //path->bodyFlag=ch - 'b';
                                /*
                                        TODO: translate the char into body flag and
                                        OR the flags together
                                
                                */
                                /*
                                        if(bodyFlags & BodyFlags::fBody)
                                        os << "b ";
                                        if(bodyFlags & BodyFlags::fScene)
                                                os << "j ";
                                        int i=bodyFlags & 0x3F;
                                        if(i) 
                                                os << (char) ('b' + i) << ' ';
                                */
                                switch(ch){
                                        // both probably mean 'scene'
                                        case 'j': // no break
                                        case 'u':
                                                path->bodyFlags|=bob_dom_path::fScene;
                                                break;
                                        case 'b':
                                                path->bodyFlags|=bob_dom_path::fBody;
                                                break;
                                        default:
                                                path->bodyFlags|=ch - 'b';
                                }
                        }
                }
        }
        while(false);
        
        if(bRes && t && t->type!=token::t_openBracket)
                { error(is.previous(), S_Error, "Unexpected end of document found when looking for beginning of Frame block"); bRes=false; }
        
        if(bRes==false){
                cut->removeChild(cut->end() - 1);
                path=NULL;
        }
        
        return path;
}
//---------------------------------------------------------------------------------
bool bod_cut_parser::loadNote(bob_dom_path *path, token_stream& is)
{
        bob_note *n;
        bod_text_parser::token *t;
        bool bEnd=false;
        
        path->notes().removeChildren();
        
        ++is;
        do{
                n=path->notes().createChild();
                // left
                if((t=loadValue(is))==NULL)
                        break;
                if(!isinteger(t->text))
                        { error(t, S_Error, "Expected number"); break; }
                n->value=atoi(t->text);
                
                if(n->value==-1) {      
                        path->notes().removeChild(path->notes().end() - 1);
                        bEnd=true;
                        break; // end of notes
                }
                
                // right 
                n->text=loadString(is);
                if(n->text==NULL){
                        path->notes().removeChild(path->notes().end() - 1);
                        break;
                }
        }
        while(is.good());
        
        if(bEnd==false && is.eof())
                error(is.previous(), S_Error, "Unexpected end of document found while looking for end of Notes (-1)");
        
        return t!=NULL;
}
//---------------------------------------------------------------------------------
#ifdef X2BC_USE_INI_FORMATS
bool bod_cut_parser::loadFrame(bob_dom_path *path, token_stream& is)
{
        token *t;
        bool bRes=false;
        
        bob_dom_stat *stat=path->createChild();
        const Settings::StatFormat *f;
        
        // frame id
        t=is.tok();
        if(t==NULL)
                error(is.previous(), S_Error, "Expected frame ID"); 
        else if(loadValue(is)){
                if(!(isinteger(t->text) || ishexa(t->text)))
                        error(t, S_Error, "Expected frame ID in decadic or hexadecimal format");
                else{
                        if(t->text[0]=='0' && ((t->text[1] | 0x20) == 'x'))
                                stat->frameId=hextoi(t->text);
                        else
                                stat->frameId=atoi(t->text);
                                
                        f=m_settings->findStatFormat(stat->frameId);
                        if(f==NULL)
                                error(is.previous(), S_Error, "Cannot find frame format 0x%X - cannot continue", stat->frameId);
                        else
                                bRes=true;
                }
        }
        
        if(bRes){
                for(Settings::StatFormat::const_iterator &it=f->tokens.begin(); it!=f->tokens.end(); ++it){
                        for(int i=0; i < it->count; i++){
                                if((t=loadValue(is))==NULL){
                                        error(is.previous(), S_Error, "Frame format 0x%X requires %d numbers", stat->frameId, f->cumulativeTokenCount);
                                        bRes=false;
                                        goto the_end; // yes it's a GOTO so kill me
                                }
                                if(!isfloat(t->text)){
                                        error(t, S_Error, "Expected number (integer or float)"); 
                                        bRes=false;
                                        goto the_end;
                                }
                                
                                if(it->numFormat->outformat==Settings::NumberFormat::Integer && !isinteger(t->text))
                                        error(t, S_Warning, "Expected integer not float");
                                
                                unsigned int v;
                                double d=(atof(t->text) / it->numFormat->multiplier);
                                
                                // this is same as v=(unsigned int) d;
                                // but is uses normal rounding - not round toward zero, this is important 'cos otherwise there will 
                                // be error + 1 in the resulting int (only if the resulting double has fraction part)
                                __asm{
                                        fld qword ptr d
                                        fistp dword ptr v
                                }
                                
                                stat->push_back(v);
                        }
                }
                size_t pos=is.tell();
                while((t=is.tok()) && t->type!=token::t_closeBracket){
                        ++is;
                }
                if(t==NULL){
                        error(is.previous(), S_Error, "Unexpected end of document found while looking for end of frame block '}'");
                        bRes=false;
                }
                else if(is.tell()!=pos){
                        error(is.previous(), S_Error, "Too many parameters in frame declaration, expected %d numbers", f->cumulativeTokenCount);
                        bRes=false;
                }
                ++is; // advance past the end bracket
        }
        
the_end:
        if(bRes==false)
                path->removeChild(path->end() - 1);
        return bRes;
}
//---------------------------------------------------------------------------------
#else // !defined(X2BC_USE_INI_FORMATS)
bool bod_cut_parser::loadFrame(bob_dom_path *path, token_stream& is)
{
        token *t;
        bool bRes=false;
        
        bob_dom_frame *frame=path->createChild();
        int flags;
        
        // frame flags
        t=is.tok();
        if(t==NULL)
                error(is.previous(), S_Error, "Expected frame ID"); 
        else if(loadValue(is)){
                if(!(isinteger(t->text) || ishexa(t->text)))
                        error(t, S_Error, "Expected frame ID in decadic or hexadecimal format");
                else{
                        if(t->text[0]=='0' && ((t->text[1] | 0x20) == 'x'))
                                flags=hextoi(t->text);
                        else
                                flags=atoi(t->text);
                        
                        if(flags & CUT_F_POSBEZINFO)
                                error(NULL, S_Warning, "CUT_F_POSBEZINFO encoutered - don't know how to compile");
                        if(flags & CUT_F_SAMESCALE)
                                error(NULL, S_Warning, "CUT_F_SAMESCALE encoutered");
                        
                        if(flags & ~bob_dom_frame::flagMask)
                                error(is.tok(), S_Warning, "Unsupported bits set in frame flags - normalizing flags, unsupported values will not be compiled");
                        
                        flags&=bob_dom_frame::flagMask;
                        frame->flags=flags;
                        
                        bRes=true;
                }
        }
        
        while(bRes){
                static const char *pos_context = "frame: position: ";
                static const char *rot_context ="frame: rotation: ";
                static const char *tpos_context ="frame: target position: ";
                static const char *troll_context ="frame: roll angle: ";
                static const char *fov_context ="frame: FOV: ";
                static const char *color_context ="frame: RGB: ";
                static const char *len_context ="frame: length: ";
                static const char *idx_context ="frame: index: ";
                
                if((flags & CUT_F_SAMEPOS)==0){
                        loadIntValue(is, &(frame->position.x), pos_context);
                        loadIntValue(is, &(frame->position.y), pos_context);
                        if((bRes=loadIntValue(is, &(frame->position.z), pos_context))==false) break;
                        
                        if(flags & CUT_F_POSTCBINFO) {
                                frame->pos_tcb_info=new bob_dom_frame::tcb_info();
                                if((bRes=loadTCBInfo(is, frame->pos_tcb_info))==false) break;
                        }
                }
                if((flags & CUT_F_SAMEROT)==0 && (flags & CUT_F_ROT)){
                        frame->rotation=new bob_dom_frame::angle_axis();
                        loadDoubleValue(is, &(frame->rotation->angle), rot_context);
                        loadDoubleValue(is, &(frame->rotation->x), rot_context);
                        loadDoubleValue(is, &(frame->rotation->y), rot_context);
                        if((bRes=loadDoubleValue(is, &(frame->rotation->z), rot_context))==false) break;
                        
                        if(flags & CUT_F_ROTTCBINFO){
                                frame->rot_tcb_info=new bob_dom_frame::tcb_info();
                                if((bRes=loadTCBInfo(is, frame->rot_tcb_info))==false) break;
                        }
                }
                if(flags & CUT_F_TARGETPOS){
                        if((flags & CUT_F_SAMETARGET)==0){
                                frame->targetPos=new bob_dom_frame::point3d();
                                loadIntValue(is, &(frame->targetPos->x), tpos_context);
                                loadIntValue(is, &(frame->targetPos->y), tpos_context);
                                if((bRes=loadIntValue(is, &(frame->targetPos->z), tpos_context))==false) break;
                        }
                        if((flags & CUT_F_SAMEROT)==0){
                                if((bRes=loadDoubleValue(is, &(frame->rollAngle), troll_context))==false) break;
                        }
                        if(flags & CUT_F_TPOSTCBINFO){
                                frame->tpos_tcb_info=new bob_dom_frame::tcb_info();
                                if((bRes=loadTCBInfo(is, frame->tpos_tcb_info))==false) break;
                        }
                }
                if((flags & CUT_F_SAMEFOV)==0 && flags & CUT_F_FOV){
                        if((bRes=loadDoubleValue(is, &(frame->fov), fov_context))==false) break;
                }
                if((flags & CUT_F_SAMECOLOR)==0 && flags & CUT_F_COLOR){
                        frame->color=new bob_dom_frame::rgb();
                        loadDoubleValue(is, &(frame->color->r), color_context);
                        loadDoubleValue(is, &(frame->color->r), color_context);
                        if((bRes=loadDoubleValue(is, &(frame->color->r), color_context))==false) break;
                }
                if((bRes=loadIntValue(is, &(frame->length), len_context))==false) break;
                if((bRes=loadIntValue(is, &(frame->index), idx_context))==false) break;
                
                break;
        }
        if(bRes){
                int c=0;
                while((t=is.tok()) && t->type!=token::t_closeBracket){
                        c++;
                        if(loadValue(is)==false) break;
                }
                if(t==NULL){
                        error(is.previous(), S_Error, "Unexpected end of document found while looking for end of frame block '}'");
                }
                else if(c > 0){
                        error(is.tok(), S_Warning, "Too many values in frame block: %d (expected %d), they will be discarded", frame->valueCount() + 2, frame->valueCount() + 2 + c);
                }
                ++is; // past the end bracket
        }
        else{
                if(is.tok() && is.tok()->type==token::t_closeBracket)
                        error(is.tok(), S_Error, "Premature end of frame block encountered. Expected %d values (+frame flags)", frame->valueCount() + 2);
        }
        return bRes;
}
#endif // !defined(X2BC_USE_INI_FORMATS)
//---------------------------------------------------------------------------------
bool bod_cut_parser::loadTCBInfo(token_stream& is, bob_dom_frame::tcb_info *info)
{
        if(!loadDoubleValue(is, &(info->tension), "TCB info (tension): ")) return false;
        if(!loadDoubleValue(is, &(info->continuity), "TCB info (continuity): ")) return false;
        if(!loadDoubleValue(is, &(info->bias), "TCB info (bias): ")) return false;
        if(!loadDoubleValue(is, &(info->easeFrom), "TCB info (ease from): ")) return false;
        if(!loadDoubleValue(is, &(info->easeTo), "TCB info (ease to): ")) return false;
        return true;
}
//---------------------------------------------------------------------------------