static void vcc_Eval_Regsub(struct vcc *tl, struct expr **e, const struct symbol *sym) { struct expr *e2; int all = sym->eval_priv == NULL ? 0 : 1; char *p; char buf[128]; vcc_delete_expr(*e); SkipToken(tl, ID); SkipToken(tl, '('); vcc_expr0(tl, &e2, STRING); if (e2->fmt != STRING) vcc_expr_tostring(&e2, STRING); SkipToken(tl, ','); ExpectErr(tl, CSTR); p = vcc_regexp(tl); vcc_NextToken(tl); bprintf(buf, "VRT_regsub(sp, %d,\n\v1,\n%s\n", all, p); *e = vcc_expr_edit(STRING, buf, e2, *e); SkipToken(tl, ','); vcc_expr0(tl, &e2, STRING); if (e2->fmt != STRING) vcc_expr_tostring(&e2, STRING); *e = vcc_expr_edit(STRING, "\v1, \v2)", *e, e2); SkipToken(tl, ')'); }
const char *ParseTexCoords(const char *pText, F3DSubObject &sub, int numPositions) { SkipToken(pText, "{"); // get num positions int numUV = GetInt(pText, &pText); MFDebug_Assert(numUV == numPositions, "Number of UV's does not match the number of verts in the mesh."); sub.uvs.resize(numUV); // read positions for(int a=0; a<numUV; a++) { sub.uvs[a].x = GetFloat(pText, &pText); sub.uvs[a].y = GetFloat(pText, &pText); if(a < numUV-1) SkipToken(pText, ","); } SkipToken(pText, ";"); // map to faces for(int m=0; m<sub.matSubobjects.size(); m++) { int totalVerts = sub.matSubobjects[m].vertices.size(); for(int a=0; a<totalVerts; a++) { sub.matSubobjects[m].vertices[a].uv1 = sub.matSubobjects[m].vertices[a].position; } } SkipToken(pText, "}"); return pText; }
static void UnlessStatement(void) { Int32 l1,l2; SkipToken(tUNLESS); Expr(); if( Token==tTHEN ) NextToken(); l1 = vm_genI(op_jz,0); StatementList(); if( Token==tELSE ) { SkipToken(tELSE); l2 = vm_genI(op_jmp,0); vm_patch(l1,vm_addr()); l1 = l2; StatementList(); } vm_patch(l1,vm_addr()); SkipToken(tEND); }
static void FormalParamList(SymPtr func) { SymPtr t,p; Int32 num,shift; SkipToken(tLPAREN); if(Token==tVARIABLE) { FormalParam(); func->nargs++; } while( Token==tCOMMA ) { SkipToken(tCOMMA); FormalParam(); func->nargs++; } SkipToken(tRPAREN); /* Reverse and shift the argument numbers (if any). Arguments are located directly after the function. */ p = func; shift = in_class ? 2 : 1; for( num=-func->nargs; num<0; num++ ) { /* shift to make room for argc and maybe class */ t = p->next; p = t; p->num = num-shift; } }
static Int32 ActualParams(void) { Int32 args=0; if( Token==tLPAREN ) { SkipToken(tLPAREN); if( Token != tRPAREN ) { Expr(); args++; while( Token==tCOMMA ) { SkipToken(tCOMMA); Expr(); args++; } } SkipToken(tRPAREN); } return args; }
static void CaseStatement(void) { Int32 ii=0; Int32 l1,l2[MAXCOND]; SkipToken(tCASE); Expr(); while( Token==tWHEN ) { SkipToken(tWHEN); vm_gen0(op_dup); Expr(); if( Token==tTHEN ) NextToken(); vm_gen0(op_eql); l1 = vm_genI(op_jz,0); StatementList(); l2[ii++] = vm_genI(op_jmp,0); vm_patch(l1,vm_addr()); } if( Token==tELSE ) { SkipToken(tELSE); StatementList(); } while( --ii >= 0 ) vm_patch(l2[ii],vm_addr()); vm_gen0(op_pop); SkipToken(tEND); }
static void vcc_Compound(struct vcc *tl) { int i; SkipToken(tl, '{'); Fb(tl, 1, "{\n"); tl->indent += INDENT; C(tl, ";"); while (1) { ERRCHK(tl); switch (tl->t->tok) { case '{': vcc_Compound(tl); break; case '}': vcc_NextToken(tl); tl->indent -= INDENT; Fb(tl, 1, "}\n"); return; case CSRC: if (tl->allow_inline_c) { Fb(tl, 1, "%.*s\n", (int) (tl->t->e - (tl->t->b + 2)), tl->t->b + 1); vcc_NextToken(tl); } else { VSB_printf(tl->sb, "Inline-C not allowed\n"); vcc_ErrWhere(tl, tl->t); } break; case EOI: VSB_printf(tl->sb, "End of input while in compound statement\n"); tl->err = 1; return; case ID: if (vcc_IdIs(tl->t, "if")) { vcc_IfStmt(tl); break; } else { i = vcc_ParseAction(tl); ERRCHK(tl); if (i) { SkipToken(tl, ';'); break; } } /* FALLTHROUGH */ default: /* We deliberately do not mention inline C */ VSB_printf(tl->sb, "Expected an action, 'if', '{' or '}'\n"); vcc_ErrWhere(tl, tl->t); return; } } }
void XFileLoader::ReadArray(istream& s, iter b, iter e) { for (iter i = b; i != e; ++i) { if (i != b) SkipToken(s, XFileToken::Comma); ReadData(s, *i); } SkipToken(s, XFileToken::Semicolon); }
static SymPtr LookupIdent(char **name) { SymPtr sym=NULL,parent; /* check this class only */ if( in_class && Token==tSELF ) { SkipToken(tSELF); SkipToken(tPERIOD); *name = GetIdent(); sym = SymFindLevel(*name,(SymGetScope()-1)); } /* check super class only */ else if( in_class && Token==tSUPER && base_class->super!=NULL ) { SkipToken(tSUPER); SkipToken(tPERIOD); *name = GetIdent(); sym = SymFindLocal(*name,base_class->super); if( sym!=NULL && sym->flags&SYM_PRIVATE ) { compileError("attempt to access private field '%s'",*name); NextToken(); return COMPILE_ERROR; } } /* check all super classes */ else if( in_class ) { *name = GetIdent(); parent=base_class->super; while(parent!=NULL) { sym = SymFindLocal(*name,parent); if(sym!=NULL) break; parent=parent->super; } if( sym!=NULL && sym->flags&SYM_PRIVATE ) { compileError("attempt to access private field '%s'",*name); NextToken(); return COMPILE_ERROR; } } /* check globals */ if( sym==NULL ) { *name = GetIdent(); sym = SymFind(*name); } return sym; }
static void vcc_Conditional(struct vcc *tl) { SkipToken(tl, '('); Fb(tl, 0, "(\n"); L(tl, vcc_Expr(tl, BOOL)); ERRCHK(tl); Fb(tl, 1, ")\n"); SkipToken(tl, ')'); }
static void parse_hash_data(struct vcc *tl) { vcc_NextToken(tl); SkipToken(tl, '('); Fb(tl, 1, "VRT_hashdata(ctx, "); vcc_Expr(tl, STRING_LIST); ERRCHK(tl); Fb(tl, 0, ");\n"); SkipToken(tl, ')'); }
static void MethodDefinition(void) { Pointer name; SymPtr sym; Int32 l1,shift; SkipToken(tDEF); /* MatchToken(tVARIABLE); */ name = GetIdent(); /* maybe check for duplicates here? */ sym = SymAdd(name); sym->kind = FUNCTION_KIND; sym->object.u.ival = vm_addr(); sym->flags |= cur_scope; if( in_class && base_class!=NULL ) sym->clas=base_class; if( in_class && super_class!=NULL ) sym->super=super_class; NextToken(); SymEnterScope(); in_method=TRUE; l1 = vm_genI(op_link,0); /* check for any formal parameters */ if( Token==tLPAREN ) { FormalParamList(sym); } /* function statements */ local_num=0; StatementList(); sym->nlocs = local_num; /* backpatch any return statements */ CheckReturn(sym); /* implicit return */ shift = in_class ? 2 : 1; vm_genI(op_rts,sym->nlocs+sym->nargs+shift); /* reserve space for locals */ vm_patch(l1,sym->nlocs); SymExitScope(sym); in_method=FALSE; /* end of function */ SkipToken(tEND); if( Token==tSEMI ) NextToken(); }
static void ForStatement(void) { Int32 l1,l2,l3,l4; SkipToken(tFOR); SkipToken(tLPAREN); /* init */ if( Token != tSEMI ) { AssignmentStatement(); while( Token==tCOMMA ) { SkipToken(tCOMMA); AssignmentStatement(); } } SkipToken(tSEMI); /* cond */ l1 = vm_addr(); if( Token != tSEMI ) { Expr(); } else { vm_genI(op_pushint,1); } l2 = vm_genI(op_jnz,0); l3 = vm_genI(op_jmp,0); /* incr */ SkipToken(tSEMI); vm_patch(l3,vm_addr()); l4 = vm_addr(); if( Token != tRPAREN ) { AssignmentStatement(); while( Token==tCOMMA ) { SkipToken(tCOMMA); AssignmentStatement(); } } vm_genI(op_jmp,l1); /* statements */ SkipToken(tRPAREN); vm_patch(l2,vm_addr()); StatementList(); vm_genI(op_jmp,l4); /* done */ vm_patch(l3,vm_addr()); CheckBreak(); SkipToken(tEND); }
static Int32 Factor(void) { Int32 type; switch(Token) { case tINTCONST: vm_genI(op_pushint,GetInt()); NextToken(); type=INT_TYPE; break; case tREALCONST: vm_genR(op_pushreal,GetReal()); NextToken(); type=REAL_TYPE; break; case tSTRINGCONST: vm_genS(op_pushstring,GetString()); NextToken(); type=STRING_TYPE; break; case tNOT: NextToken(); type=Factor(); vm_gen0(op_not); break; case tLPAREN: SkipToken(tLPAREN); type=Expr(); SkipToken(tRPAREN); break; case tLBRACK: ArrayInitializer(); type=ARRAY_TYPE; break; default: type=Rhs(); break; } return type; }
static void parse_error(struct vcc *tl) { vcc_NextToken(tl); Fb(tl, 1, "VRT_error(sp,\n"); if (tl->t->tok == '(') { vcc_NextToken(tl); vcc_Expr(tl, INT); if (tl->t->tok == ',') { Fb(tl, 1, ",\n"); vcc_NextToken(tl); vcc_Expr(tl, STRING); } else Fb(tl, 1, ", 0\n"); SkipToken(tl, ')'); } else { vcc_Expr(tl, INT); if (tl->t->tok != ';') { Fb(tl, 1, ",\n"); vcc_Expr(tl, STRING); } else Fb(tl, 1, ", 0\n"); } Fb(tl, 1, ");\n"); Fb(tl, 1, "VRT_done(sp, VCL_RET_ERROR);\n"); }
static void parse_set(struct vcc *tl) { const struct var *vp; const struct arith *ap; enum var_type fmt; vcc_NextToken(tl); ExpectErr(tl, ID); vp = vcc_FindVar(tl, tl->t, 1, "cannot be set"); ERRCHK(tl); assert(vp != NULL); Fb(tl, 1, "%s", vp->lname); vcc_NextToken(tl); fmt = vp->fmt; for (ap = arith; ap->type != VOID; ap++) { if (ap->type != fmt) continue; if (ap->oper != tl->t->tok) continue; if (ap->oper != '=') Fb(tl, 0, "%s %c ", vp->rname, *tl->t->b); vcc_NextToken(tl); fmt = ap->want; break; } if (ap->type == VOID) SkipToken(tl, ap->oper); if (fmt == STRING) { vcc_Expr(tl, STRING_LIST); } else { vcc_Expr(tl, fmt); } Fb(tl, 1, ");\n"); }
void XFileLoader::ReadData<glm::mat4>(istream& s, glm::mat4& d) { float elems[16]; ReadArray(s, elems, elems + 16); d = make_mat4(elems); SkipToken(s, XFileToken::Semicolon); }
static Int32 ArrayValue(Int32 size) { Int32 repeat; vm_gen0(op_dup); /* var */ if( Token==tINTCONST && LookAheadChar()=='x' ) { /* Handle array repeat operator. We must use an intconst because we need to know the array size at compile time. */ repeat = GetInt(); SkipChar(); SkipToken(tINTCONST); vm_genI(op_pushint,size); /* start-idx */ size += repeat; vm_genI(op_pushint,size-1); /* end-idx */ Expr(); /* val */ vm_gen0(op_setslice); } else { /* single expression */ vm_genI(op_pushint,size++); /* idx */ Expr(); /* val */ vm_gen0(op_setarray); } return size; }
const char *ParseAnimationSet(const char *pText) { const char *pName = GetNextToken(pText, &pText); if(MFString_Compare(pName, "{")) SkipToken(pText, "{"); const char *pTok = GetNextToken(pText, &pText); while(MFString_Compare(pTok, "}")) { if(!MFString_Compare(pTok, "Animation")) { pText = ParseAnimation(pText); } else { MFDebug_Warn(4, MFStr("Unexpected token '%s'\n", pTok)); SkipSection(pText); } pTok = GetNextToken(pText, &pText); } return pText; }
// ------------------------------------------------------------------- void ObjFileParser::getVector( std::vector<aiVector3D> &point3d_array ) { size_t numComponents( 0 ); const char* tmp( &m_DataIt[0] ); while( !IsLineEnd( *tmp ) ) { if ( !SkipSpaces( &tmp ) ) { break; } SkipToken( tmp ); ++numComponents; } float x, y, z; if( 2 == numComponents ) { copyNextWord( m_buffer, BUFFERSIZE ); x = ( float ) fast_atof( m_buffer ); copyNextWord( m_buffer, BUFFERSIZE ); y = ( float ) fast_atof( m_buffer ); z = 0.0; } else if( 3 == numComponents ) { copyNextWord( m_buffer, BUFFERSIZE ); x = ( float ) fast_atof( m_buffer ); copyNextWord( m_buffer, BUFFERSIZE ); y = ( float ) fast_atof( m_buffer ); copyNextWord( m_buffer, BUFFERSIZE ); z = ( float ) fast_atof( m_buffer ); } else { throw DeadlyImportError( "OBJ: Invalid number of components" ); } point3d_array.push_back( aiVector3D( x, y, z ) ); m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine ); }
static void vxp_expr_group(struct vxp *vxp, struct vex **pvex) { AN(pvex); AZ(*pvex); if (vxp->t->tok == '(') { SkipToken(vxp, '('); vxp_expr_or(vxp, pvex); ERRCHK(vxp); SkipToken(vxp, ')'); return; } vxp_expr_cmp(vxp, pvex); }
static void DefOption( opt_entry *optn, char *ptr ) { //======================================================= // Define a macro. optn = optn; MacroDEFINE( ptr, SkipToken( ptr ) - ptr ); }
static void UntilStatement(void) { Int32 l1,l2; SkipToken(tUNTIL); l1 = vm_addr(); Expr(); if( Token==tDO ) NextToken(); l2 = vm_genI(op_jnz,0); StatementList(); vm_genI(op_jmp,l1); vm_patch(l2,vm_addr()); CheckBreak(); SkipToken(tEND); }
static void ProtectedStatement(void) { SkipToken(tPROTECTED); cur_scope=SYM_PROTECTED; if(!in_class || in_method) { compileError("protected only valid inside a class definition"); } }
static void PrivateStatement(void) { SkipToken(tPRIVATE); cur_scope=SYM_PRIVATE; if(!in_class || in_method) { compileError("private only valid inside a class definition"); } }
static void PublicStatement(void) { SkipToken(tPUBLIC); cur_scope=SYM_PUBLIC; if(!in_class || in_method) { compileError("public only valid inside a class definition"); } }
static void IfStatement(void) { Int32 ii=0; Int32 l1,l2[MAXCOND]; SkipToken(tIF); Expr(); if( Token==tTHEN ) NextToken(); l1 = vm_genI(op_jz,0); StatementList(); l2[ii++] = vm_genI(op_jmp,0); while( Token==tELSIF ) { SkipToken(tELSIF); vm_patch(l1,vm_addr()); Expr(); if( Token==tTHEN ) NextToken(); l1 = vm_genI(op_jz,0); StatementList(); l2[ii++] = vm_genI(op_jmp,0); } vm_patch(l1,vm_addr()); if( Token==tELSE ) { SkipToken(tELSE); StatementList(); } while( --ii >= 0 ) { vm_patch(l2[ii],vm_addr()); } SkipToken(tEND); }
static void ArrayInitializer(void) { Int32 label,size=0; label = vm_genI(op_pushint,0); vm_gen0(op_newarray); SkipToken(tLBRACK); size = ArrayValue(size); while( Token==tCOMMA ) { SkipToken(tCOMMA); size = ArrayValue(size); } SkipToken(tRBRACK); vm_patch(label,size); }
void vcc_ParseRoundRobinDirector(struct vcc *tl) { struct token *t_field, *t_be; int nelem; struct fld_spec *fs; const char *first; char *p; fs = vcc_FldSpec(tl, "!backend", NULL); Fc(tl, 0, "\nstatic const struct vrt_dir_round_robin_entry " "vdrre_%.*s[] = {\n", PF(tl->t_dir)); for (nelem = 0; tl->t->tok != '}'; nelem++) { /* List of members */ first = ""; t_be = tl->t; vcc_ResetFldSpec(fs); SkipToken(tl, '{'); Fc(tl, 0, "\t{"); while (tl->t->tok != '}') { /* Member fields */ vcc_IsField(tl, &t_field, fs); ERRCHK(tl); if (vcc_IdIs(t_field, "backend")) { vcc_ParseBackendHost(tl, nelem, &p); ERRCHK(tl); AN(p); Fc(tl, 0, "%s .host = VGC_backend_%s", first, p); } else { ErrInternal(tl); } first = ", "; } vcc_FieldsOk(tl, fs); if (tl->err) { VSB_printf(tl->sb, "\nIn member host specification starting at:\n"); vcc_ErrWhere(tl, t_be); return; } Fc(tl, 0, " },\n"); vcc_NextToken(tl); } Fc(tl, 0, "};\n"); Fc(tl, 0, "\nstatic const struct vrt_dir_round_robin vgc_dir_priv_%.*s = {\n", PF(tl->t_dir)); Fc(tl, 0, "\t.name = \"%.*s\",\n", PF(tl->t_dir)); Fc(tl, 0, "\t.nmember = %d,\n", nelem); Fc(tl, 0, "\t.members = vdrre_%.*s,\n", PF(tl->t_dir)); Fc(tl, 0, "};\n"); }
static SymPtr FieldReference(SymPtr clas) { SymPtr field,parent; char *fieldname; SkipToken(tPERIOD); fieldname = GetIdent(); /* lookup field in class and parents */ parent=clas; while( parent!=NULL ) { field = SymFindLocal(fieldname,parent); if( field!=NULL ) break; parent = parent->super; } if( field==NULL ) { compileError("field '%s' not found",fieldname); return NULL; } field->flags |= SYM_FIELD; /* MCC */ if( field->flags&SYM_PRIVATE ) { compileError("attempt to access private field '%s'",fieldname); return NULL; } if( field->flags&SYM_PROTECTED && !in_class ) { compileError("attempt to access protected field '%s'",fieldname); return NULL; } NextToken(); if( is_func_kind(field) ) { return field; } if( is_global_kind(clas) ) { vm_genI(op_getglobal,clas->num); } else if( is_local_kind(clas) ) { vm_genI(op_getlocal,clas->num); } return field; }