Subversion Repositories spk

#include "bod_cut_parser.h"
#include "../common/strutils.h"
//---------------------------------------------------------------------------------
bool bod_cut_parser::compile(token_stream& is, 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)
{
        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, obinaryfilestream *os, bool bDirectOutput)
{
        bod_text_parser::token *t;
        bob_path *actPath=0;
        bob_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_openCrBracket){
                                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, mystream::stream_base::seek_begin);
                        *os << pathCount;
                        os->seek((int)endPos, mystream::stream_base::seek_begin);
                }
                return cut;
        }
}
//---------------------------------------------------------------------------------
bob_path * bod_cut_parser::loadPath(bob_dom_cut *cut, token_stream& is)
{
        bob_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_openCrBracket)
                                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_openCrBracket)
                                        { 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_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_path::fScene;
                                                break;
                                        case 'b':
                                                path->bodyFlags|=bob_path::fBody;
                                                break;
                                        default:
                                                path->bodyFlags|=ch - 'b';
                                }
                        }
                }
        }
        while(false);

        if(bRes && t && t->type!=token::t_openCrBracket)
                { 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_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;
}
//---------------------------------------------------------------------------------
bool bod_cut_parser::loadFrame(bob_path *path, token_stream& is)
{
        token *t;
        bool bRes=false;

        bob_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_frame::flagMask)
                                error(is.tok(), S_Warning, "Unsupported bits set in frame flags - normalizing flags, unsupported values will not be compiled");

                        flags&=bob_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_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_frame::AngleAxis();
                        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_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_frame::Position();
                                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_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_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_closeCrBracket){
                        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_closeCrBracket)
                        error(is.tok(), S_Error, "Premature end of frame block encountered. Expected %d values (+frame flags)", frame->valueCount() + 2);
        }
        return bRes;
}
//---------------------------------------------------------------------------------
bool bod_cut_parser::loadTCBInfo(token_stream& is, bob_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;
}
//---------------------------------------------------------------------------------