34#include <libFreeWRL.h>
37#include "../vrml_parser/Structs.h"
38#include "../main/headers.h"
39#include "CParseGeneral.h"
40#include "../scenegraph/Vector.h"
41#include "../vrml_parser/CFieldDecls.h"
42#include "../world_script/JScript.h"
43#include "../world_script/CScripts.h"
44#include "../world_script/fieldSet.h"
45#include "../input/EAIHeaders.h"
46#include "../input/EAIHelpers.h"
47#include "CParseParser.h"
48#include "CParseLexer.h"
51#include "../opengl/OpenGL_Utils.h"
52#include "../scenegraph/LinearAlgebra.h"
54#define PARSE_ERROR(msg) \
56 CPARSE_ERROR_CURID(msg); \
57 FREE_IF_NZ(me->lexer->curID); \
62#define DEFMEM_INIT_SIZE 16
64#define DJ_KEEP_COMPILER_WARNING 0
67 char fw_outline[2000];
69 int latest_protoDefNumber;
71void *CParseParser_constructor(){
76void CParseParser_init(
struct tCParseParser *t){
79 t->prv = CParseParser_constructor();
82 p->foundInputErrors = 0;
83 p->latest_protoDefNumber = 1;
89void resetParseSuccessfullyFlag(
void) {
91 p->foundInputErrors = 0;
93int parsedSuccessfully(
void) {
95 return p->foundInputErrors == 0;
148static BOOL parser_routeStatement(
struct VRMLParser*);
149static BOOL parser_componentStatement(
struct VRMLParser*);
150static BOOL parser_exportStatement(
struct VRMLParser*);
151static BOOL parser_importStatement(
struct VRMLParser*);
152static BOOL parser_metaStatement(
struct VRMLParser*);
153static BOOL parser_unitStatement(
struct VRMLParser*);
154static BOOL parser_profileStatement(
struct VRMLParser*);
163static BOOL parser_sffloatValue_ (
struct VRMLParser *,
void *);
164static BOOL parser_sfint32Value_ (
struct VRMLParser *,
void *);
165static BOOL parser_sftimeValue (
struct VRMLParser *,
void *);
166static BOOL parser_sfboolValue (
struct VRMLParser *,
void *);
167static BOOL parser_sfnodeValue (
struct VRMLParser *,
void *);
168static BOOL parser_sfrotationValue (
struct VRMLParser *,
void *);
169static BOOL parser_sfcolorValue (
struct VRMLParser *,
void *);
170static BOOL parser_sfcolorrgbaValue (
struct VRMLParser *,
void *);
171static BOOL parser_sfmatrix3fValue (
struct VRMLParser *,
void *);
172static BOOL parser_sfmatrix4fValue (
struct VRMLParser *,
void *);
173static BOOL parser_sfvec2fValue (
struct VRMLParser *,
void *);
174static BOOL parser_sfvec4fValue (
struct VRMLParser *,
void *);
175static BOOL parser_sfvec2dValue (
struct VRMLParser *,
void *);
176static BOOL parser_sfvec3dValue (
struct VRMLParser *,
void *);
177static BOOL parser_sfvec4dValue (
struct VRMLParser *,
void *);
178static BOOL parser_sfmatrix3dValue (
struct VRMLParser *,
void *);
179static BOOL parser_sfmatrix4dValue (
struct VRMLParser *,
void *);
180static BOOL parser_mfboolValue(
struct VRMLParser*,
void*);
181static BOOL parser_mfcolorValue(
struct VRMLParser*,
void*);
182static BOOL parser_mfcolorrgbaValue(
struct VRMLParser*,
void*);
183static BOOL parser_mffloatValue(
struct VRMLParser*,
void*);
184static BOOL parser_mfint32Value(
struct VRMLParser*,
void*);
185static BOOL parser_mfnodeValue(
struct VRMLParser*,
void*);
186static BOOL parser_mfrotationValue(
struct VRMLParser*,
void*);
187static BOOL parser_mfstringValue(
struct VRMLParser*,
void*);
188static BOOL parser_mftimeValue(
struct VRMLParser*,
void*);
189static BOOL parser_mfvec2fValue(
struct VRMLParser*,
void*);
190static BOOL parser_mfvec3fValue(
struct VRMLParser*,
void*);
191static BOOL parser_mfvec3dValue(
struct VRMLParser*,
void*);
192static BOOL parser_sfstringValue_(
struct VRMLParser*,
void*);
193static BOOL parser_sfimageValue(
struct VRMLParser*,
void*);
194static BOOL parser_mfvec2dValue(
struct VRMLParser*,
void*);
195static BOOL parser_mfvec4fValue(
struct VRMLParser*,
void*);
196static BOOL parser_mfvec4dValue(
struct VRMLParser*,
void*);
201#define parser_sfvec3fValue(me, ret) \
202 parser_sfcolorValue(me, ret)
206static BOOL parser_fieldTypeNotParsedYet(
struct VRMLParser* me,
void* ret);
209BOOL (*PARSE_TYPE[])(
struct VRMLParser*,
void*)={
210 &parser_sffloatValue_, &parser_mffloatValue,
211 &parser_sfrotationValue, &parser_mfrotationValue,
212 &parser_sfcolorValue, &parser_mfvec3fValue,
213 &parser_sfboolValue, &parser_mfboolValue,
214 &parser_sfint32Value_, &parser_mfint32Value,
215 &parser_sfnodeValue, &parser_mfnodeValue,
216 &parser_sfcolorValue, &parser_mfcolorValue,
217 &parser_sfcolorrgbaValue, &parser_mfcolorrgbaValue,
218 &parser_sftimeValue, &parser_mftimeValue,
219 &parser_sfstringValue_, &parser_mfstringValue,
220 &parser_sfvec2fValue, &parser_mfvec2fValue,
221 &parser_fieldTypeNotParsedYet,
222 &parser_sfimageValue,
223 &parser_sfvec3dValue, &parser_mfvec3dValue,
224 &parser_sftimeValue, &parser_mftimeValue,
225 &parser_sfmatrix3fValue, &parser_fieldTypeNotParsedYet,
226 &parser_sfmatrix3dValue, &parser_fieldTypeNotParsedYet,
227 &parser_sfmatrix4fValue, &parser_fieldTypeNotParsedYet,
228 &parser_sfmatrix4dValue, &parser_fieldTypeNotParsedYet,
229 &parser_sfvec2dValue, &parser_mfvec2dValue,
230 &parser_sfvec4fValue, &parser_mfvec4fValue,
231 &parser_sfvec4dValue, &parser_mfvec4dValue,
232 &parser_fieldTypeNotParsedYet,
239 ASSERT(PARSE_TYPE[type]);
242 if (type == ID_UNDEFINED)
return false;
244 return PARSE_TYPE[type](me, (
void*)defaultVal);
255struct ProtoFieldDecl* newProtoFieldDecl(indexT mode, indexT type, indexT name)
263 ret->alreadySet=FALSE;
264 ret->fieldString = NULL;
266 ret->scriptDests = NULL;
267 ret->defaultVal.mfnode.p = NULL;
268 ret->defaultVal.mfnode.n = 0;
273 ddecl = newProtoFieldDecl(sdecl->mode,sdecl->type,sdecl->name);
275 ddecl->cname = STRDUP(sdecl->cname);
278 shallow_copy_field(sdecl->type,&(sdecl->defaultVal),&(ddecl->defaultVal));
286void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr)
292 if(type == FIELDTYPE_FreeWRLPTR){
293 if(0) FREE_IF_NZ(fieldPtr->sfstring);
294 }
else if(type == FIELDTYPE_SFString){
297 us = fieldPtr->sfstring;
298 clearASCIIString(us);
299 FREE_IF_NZ(fieldPtr->sfstring);
301 }
else if(type == FIELDTYPE_MFString){
302 clearMFString(&fieldPtr->mfstring);
303 fieldPtr->mfstring.n = 0;
306 FREE_IF_NZ(fieldPtr->mfnode.p);
307 fieldPtr->mfnode.n = 0;
316 FREE_IF_NZ(me->cname);
317 FREE_IF_NZ(me->fieldString);
318 fieldPtr = &(me->defaultVal);
320 deleteMallocedFieldValue(type,fieldPtr);
351 ret->deconstructedProtoBody = NULL;
355 ret->protoDefNumber = p->latest_protoDefNumber++;
356 ret->estimatedBodyLen = 0;
357 ret->protoName = NULL;
359 ret->isExtern = FALSE;
367 for(i=0;i<vectorSize(ret->iface);i++) {
370 deleteProtoFieldDecl(iface);
375 FREE_IF_NZ(ret->protoName);
384 indexT ind, indexT mode)
389 if (!me)
return NULL;
390 for(i=0; i!=vectorSize(me->iface); ++i)
393 if(f->name==ind && f->mode==mode) {
411 if(node->_nodeType == NODE_Proto){
423struct VRMLParser* newParser(
void *ectx,
void* ptr,
unsigned ofs,
int parsingX3DfromXML) {
425 ret->lexer=newLexer();
431 ret->DEFedNodes = NULL;
433 ret->parsingX3DfromXML = parsingX3DfromXML;
434 ret->brotoDEFedNodes = NULL;
438struct VRMLParser* reuseParser(
void *ectx,
void* ptr,
unsigned ofs) {
465 deleteLexer(me->lexer);
470static void parser_scopeOut_DEFUSE();
471static void parser_scopeOut_PROTO();
480 while(!stack_empty(me->DEFedNodes))
481 parser_scopeOut_DEFUSE(me);
482 deleteStack(
struct Vector*, me->DEFedNodes);
485 ASSERT(!me->DEFedNodes);
491 while(!stack_empty(me->PROTOs))
492 parser_scopeOut_PROTO(me);
493 deleteStack(
struct Vector*, me->PROTOs);
498 lexer_destroyData(me->lexer);
502 zeroScriptHandles ();
507static void parser_scopeIn_DEFUSE(
struct VRMLParser* me)
510 me->DEFedNodes=newStack(
struct Vector*);
512 ASSERT(me->DEFedNodes);
513 stack_push(
struct Vector*, me->DEFedNodes,
514 newVector(
struct X3D_Node*, DEFMEM_INIT_SIZE));
515 ASSERT(!stack_empty(me->DEFedNodes));
526static void parser_scopeIn_PROTO(
struct VRMLParser* me)
533static void parser_scopeOut_DEFUSE(
struct VRMLParser* me)
535 ASSERT(!stack_empty(me->DEFedNodes));
537 deleteVector(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes));
538 stack_pop(
struct Vector*, me->DEFedNodes);
545static void parser_scopeOut_PROTO(
struct VRMLParser* me)
550 vector_popBackN(
struct ProtoDefinition*, me->PROTOs, lexer_getProtoPopCnt(me->lexer));
551 lexer_scopeOut_PROTO(me->lexer);
556 lexer_scopeIn(me->lexer);
557 parser_scopeIn_DEFUSE(me);
558 parser_scopeIn_PROTO(me);
562 parser_scopeOut_DEFUSE(me);
563 parser_scopeOut_PROTO(me);
564 lexer_scopeOut(me->lexer);
568#define STRDUP_IF_NZ(_ptr) ((_ptr) ? STRDUP(_ptr) : NULL)
569#define DECLAREUP char *saveNextIn, *saveCurID = NULL;
570#define SAVEUP { FREE_IF_NZ(saveCurID); \
571 saveCurID = STRDUP_IF_NZ(me->lexer->curID); \
572 saveNextIn = me->lexer->nextIn;}
573#define BACKUP {FREE_IF_NZ(me->lexer->curID); \
574 me->lexer->curID = saveCurID; \
575 me->lexer->nextIn = saveNextIn; }
576#define FREEUP {FREE_IF_NZ(saveCurID);}
578static BOOL parser_brotoStatement(
struct VRMLParser* me);
597 printf(
"parser_vrmlScene: Try node\n");
599 if(parser_nodeStatement(me, &node))
603 AddRemoveChildren(me->ptr, offsetPointer_deref(
void *,me->ptr,me->ofs), &node, 1, 1,__FILE__,__LINE__);
605 printf(
"parser_vrmlScene: node parsed\n");
617 printf(
"parser_vrmlScene: Try route\n");
622 BLOCK_STATEMENT(parser_vrmlScene)
633 printf(
"parser_vrmlScene: Try proto\n");
642 if(parser_brotoStatement(me)) {
644 printf(
"parser_vrmlScene: BROTO parsed\n");
653void broto_store_DEF(
struct X3D_Proto* proto,
struct X3D_Node* node,
const char *name);
658 return parser_node_B(me,node,ival);
669 parse_proto_body(me);
674 return lexer_eof(me->lexer);
697 return parser_vrmlScene_B(me);
722 char *startOfField = NULL;
723 int startOfFieldLexerLevel = INT_ID_UNDEFINED;
727 printf (
"start of parser_interfaceDeclaration\n");
730 bzero (&defaultVal,
sizeof (
union anyVrml));
733 ASSERT((proto || script) && !(proto && script));
740 if(!lexer_protoFieldMode(me->lexer, &mode)) {
742 printf (
"parser_interfaceDeclaration, not lexer_protoFieldMode, returning\n");
750 if (script != NULL) {
751 if(script->ShaderScriptNode->_nodeType==NODE_Script && mode==PKW_inputOutput)
753 PARSE_ERROR(
"Scripts must not have inputOutputs!")
760 if(!lexer_fieldType(me->lexer, &type))
761 PARSE_ERROR(
"Expected fieldType after proto-field keyword!")
764 printf (
"parser_interfaceDeclaration, switching on mode %s\n",PROTOKEYWORDS[mode]);
770#define LEX_DEFINE_FIELDID(suff) \
772 if(!lexer_define_##suff(me->lexer, &name)) \
773 PARSE_ERROR("Expected fieldNameId after field type!") \
776 LEX_DEFINE_FIELDID(initializeOnly)
777 LEX_DEFINE_FIELDID(inputOnly)
778 LEX_DEFINE_FIELDID(outputOnly)
779 LEX_DEFINE_FIELDID(inputOutput)
794 printf (
"parser_interfaceDeclaration, calling newProtoFieldDecl\n");
797 pdecl=newProtoFieldDecl(mode, type, name);
798 pdecl->cname = STRDUP(protoFieldDecl_getStringName(me->lexer, pdecl));
800 externproto = proto->isExtern;
802 printf (
"parser_interfaceDeclaration, finished calling newProtoFieldDecl\n");
806 printf (
"parser_interfaceDeclaration, calling newScriptFieldDecl\n");
809 sdecl=newScriptFieldDecl(me->lexer, mode, type, name);
817 if((mode==PKW_initializeOnly || mode==PKW_inputOutput) ) {
819 printf (
"parser_interfaceDeclaration, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
825 if (script && lexer_keyword(me->lexer, KW_IS)) {
831 if(!lexer_field(me->lexer, NULL, NULL, &fieldO, &fieldE))
832 PARSE_ERROR(
"Expected fieldId after IS!")
834 if(fieldO!=ID_UNDEFINED)
837 pField=protoDefinition_getField(me->curPROTO, fieldO, PKW_initializeOnly);
839 PARSE_ERROR(
"IS source is no field of current PROTO!")
840 ASSERT(pField->mode==PKW_initializeOnly);
843 ASSERT(fieldE!=ID_UNDEFINED);
845 pField=protoDefinition_getField(me->curPROTO, fieldE, PKW_inputOutput);
847 PARSE_ERROR(
"IS source is no field of current PROTO!")
848 ASSERT(pField->mode==PKW_inputOutput);
853 sfield = newScriptFieldInstanceInfo(sdecl, script);
855 defaultVal = pField->defaultVal;
860 startOfField = (
char *)me->lexer->nextIn;
861 startOfFieldLexerLevel = me->lexer->lexerInputLevel;
865 bzero (&defaultVal,
sizeof (
union anyVrml));
867 if (!parseType(me, type, &defaultVal)) {
869 CPARSE_ERROR_CURID(
"Expected default value for field!");
870 if(pdecl) deleteProtoFieldDecl(pdecl);
871 if(sdecl) deleteScriptFieldDecl(sdecl);
879 pdecl->defaultVal=defaultVal;
884 scriptFieldDecl_setFieldValue(sdecl, defaultVal);
888 printf (
"parser_interfaceDeclaration, NOT mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
892 if (script && lexer_keyword(me->lexer, KW_IS)) {
895 BOOL isIn = FALSE, isOut = FALSE;
898 printf (
"parser_interfaceDeclaration, got IS\n");
902 if (mode == PKW_inputOnly) {
903 if (lexer_inputOnly(me->lexer, NULL, NULL, NULL, &evO, &evE)) {
905 isOut = (evE != ID_UNDEFINED);
908 if (lexer_outputOnly(me->lexer, NULL, NULL, NULL, &evO, &evE)) {
914 if (!isIn && !isOut) {
916 printf (
"parser_interfaceDeclaration, NOT isIn Nor isOut\n");
924 pField = protoDefinition_getField(me->curPROTO, evO, isIn ? PKW_inputOnly: PKW_outputOnly);
929 sfield = newScriptFieldInstanceInfo(sdecl, script);
942 if (startOfField != NULL) {
943 if (startOfFieldLexerLevel == me->lexer->lexerInputLevel) {
945 size_t sz = (size_t) ((me->lexer->nextIn)-startOfField);
948 FREE_IF_NZ(pdecl->fieldString);
949 pdecl->fieldString = MALLOC (
char *, sz + 2);
950 if (NULL != pdecl->fieldString)
952 memcpy(pdecl->fieldString,startOfField,sz);
953 pdecl->fieldString[sz]=
'\0';
981 for (i=startOfFieldLexerLevel+1; i<me->lexer->lexerInputLevel; i++) {
982 printf (
"CAUTION: unverified code in recursive PROTO invocations in classic VRML parser\n");
983 printf (
"level %d\n",i);
984 printf (
"size of this level, %d\n",(
int) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]));
985 sz += (size_t) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]);
989 sz += (size_t)(me->lexer->nextIn - me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
996 FREE_IF_NZ(pdecl->fieldString);
997 pdecl->fieldString = MALLOC(
char *, sz);
998 curStrPtr = pdecl->fieldString;
1012 for (i=startOfFieldLexerLevel+1; i<me->lexer->lexerInputLevel; i++) {
1013 sz = (size_t) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]);
1014 memcpy(curStrPtr,me->lexer->startOfStringPtr[i],sz);
1019 sz = (size_t)(me->lexer->nextIn - me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
1020 memcpy(curStrPtr,me->lexer->startOfStringPtr[me->lexer->lexerInputLevel],sz);
1028 #ifdef CPARSERVERBOSE
1029 printf (
"pdecl->fieldString is :%s:\n",pdecl->fieldString);
1032 protoDefinition_addIfaceField(proto, pdecl);
1036 script_addField(script, sdecl);
1039 #ifdef CPARSERVERBOSE
1040 printf (
"end of parser_interfaceDeclaration\n");
1059static BOOL parser_componentStatement(
struct VRMLParser* me) {
1060 char *cname, *clevel;
1061 char cfullname[200];
1062 int myComponent = INT_ID_UNDEFINED;
1063 int myLevel = INT_ID_UNDEFINED;
1065#if DJ_KEEP_COMPILER_WARNING
1066#define COMPSTRINGSIZE 20
1070 lexer_skip(me->lexer);
1073 if(!lexer_keyword(me->lexer, KW_COMPONENT))
return FALSE;
1075#ifdef CPARSERVERBOSE
1076 printf (
"parser_componentStatement...\n");
1079 if(!lexer_setCurID(me->lexer))
return TRUE;
1080 ASSERT(me->lexer->curID);
1086 strcpy(cfullname,me->lexer->curID);
1088 FREE_IF_NZ(me->lexer->curID);
1092 len = strlen(cfullname);
1094 if(cfullname[i] ==
':'){
1095 cfullname[i] =
'\0';
1096 clevel = &cfullname[i+1];
1099 myComponent = findFieldInCOMPONENTS(cname);
1101 if(clevel) myLevel = atoi(clevel);
1103 handleComponent(myComponent,myLevel);
1116 switch(node->_nodeType){
1126struct X3D_Node *broto_search_DEFname(
struct X3D_Proto *context,
const char *name);
1128void handleExport_B (
void *ctxnodeptr,
char *nodename,
char *as) {
1130 struct X3D_Proto *context = hasContext(ctxnodeptr);
1134 if(!context->__EXPORTS) context->__EXPORTS = newVector(
struct IMEXPORT *,4);
1135 mxport->mxname = STRDUP(nodename);
1136 mxport->as = mxport->mxname;
1138 mxport->as = STRDUP(as);
1139 node = broto_search_DEFname(context,mxport->mxname);
1140 mxport->nodeptr = node;
1141 vector_pushBack(
struct IMEXPORT*,context->__EXPORTS,mxport);
1143 #ifdef CAPABILITIESVERBOSE
1144 printf (
"handleExport: node :%s: ",node);
1145 if (as != NULL) printf (
" AS :%s: ",node);
1151void handleImport_B (
struct X3D_Node *nodeptr,
char *nodeName,
char *nodeImport,
char *as) {
1157 struct X3D_Proto *context = hasContext(nodeptr);
1160 if(!context->__IMPORTS) context->__IMPORTS = newVector(
struct IMEXPORT *,4);
1161 mxport->mxname = STRDUP(nodeImport);
1162 mxport->inlinename = STRDUP(nodeName);
1163 mxport->as = mxport->mxname;
1165 mxport->as = STRDUP(as);
1166 mxport->nodeptr = NULL;
1167 vector_pushBack(
struct IMEXPORT*,context->__IMPORTS,mxport);
1170 #ifdef CAPABILITIESVERBOSE
1171 printf (
"handleImport: inlineNodeName :%s: nodeToImport :%s:",nodeName, nodeImport);
1172 if (as != NULL) printf (
" AS :%s: ",as);
1177static BOOL parser_exportStatement(
struct VRMLParser* me) {
1178 char *nodeToExport = NULL;
1182 lexer_skip(me->lexer);
1185 if(!lexer_keyword(me->lexer, KW_EXPORT))
return FALSE;
1187#ifdef CPARSERVERBOSE
1188 printf (
"parser_exportStatement...\n");
1191 if(!lexer_setCurID(me->lexer))
return TRUE;
1192 ASSERT(me->lexer->curID);
1195 nodeToExport = me->lexer->curID;
1196 me->lexer->curID = NULL;
1198 if(!lexer_setCurID(me->lexer))
return TRUE;
1199 ASSERT(me->lexer->curID);
1202 if (strcmp(
"AS",me->lexer->curID) == 0) {
1203 FREE_IF_NZ(me->lexer->curID);
1204 if(!lexer_setCurID(me->lexer))
return TRUE;
1205 ASSERT(me->lexer->curID);
1206 alias = me->lexer->curID;
1210 handleExport_B(me->ectx,nodeToExport, alias);
1213 FREE_IF_NZ(nodeToExport);
1214 if (alias != NULL) {FREE_IF_NZ(me->lexer->curID);}
1218static BOOL parser_importStatement(
struct VRMLParser* me) {
1219 char *inlineNodeName = NULL;
1221 char *nodeToImport = NULL;
1224 lexer_skip(me->lexer);
1227 if(!lexer_keyword(me->lexer, KW_IMPORT))
return FALSE;
1229#ifdef CPARSERVERBOSE
1230 printf (
"parser_importStatement...\n");
1233 if(!lexer_setCurID(me->lexer))
return TRUE;
1234 ASSERT(me->lexer->curID);
1237 inlineNodeName = STRDUP(me->lexer->curID);
1238 FREE_IF_NZ(me->lexer->curID);
1241 if (!lexer_point(me->lexer)) {
1242 CPARSE_ERROR_CURID(
"expected period in IMPORT statement")
1246 if(!lexer_setCurID(me->lexer)) return TRUE;
1247 ASSERT(me->lexer->curID);
1250 nodeToImport = STRDUP(me->lexer->curID);
1251 FREE_IF_NZ(me->lexer->curID);
1254 if(!lexer_setCurID(me->lexer)) return TRUE;
1255 ASSERT(me->lexer->curID);
1258 if (strcmp("AS",me->lexer->curID) == 0) {
1259 FREE_IF_NZ(me->lexer->curID);
1260 if(!lexer_setCurID(me->lexer))
return TRUE;
1261 ASSERT(me->lexer->curID);
1262 alias = STRDUP(me->lexer->curID);
1263 FREE_IF_NZ(me->lexer->curID);
1267 handleImport_B(me->ectx,inlineNodeName, nodeToImport, alias);
1269 FREE_IF_NZ (inlineNodeName);
1270 FREE_IF_NZ (nodeToImport);
1274static BOOL parser_metaStatement(
struct VRMLParser* me) {
1278 lexer_skip(me->lexer);
1281 if(!lexer_keyword(me->lexer, KW_META))
return FALSE;
1283#ifdef CPARSERVERBOSE
1284 printf (
"parser_metaStatement...\n");
1290 val1=NULL; val2 = NULL;
1292 if(!parser_sfstringValue (me, &val1)) {
1293 CPARSE_ERROR_CURID(
"Expected a string after a META keyword")
1296 if(!parser_sfstringValue (me, &val2)) {
1297 CPARSE_ERROR_CURID(
"Expected a string after a META keyword")
1300 if ((val1 != NULL) && (val2 != NULL)) { handleMetaDataStringString(val1,val2); }
1303 if (val1 != NULL) {FREE_IF_NZ(val1->strptr); FREE_IF_NZ(val1);}
1304 if (val2 != NULL) {FREE_IF_NZ(val2->strptr); FREE_IF_NZ(val2);}
1307static BOOL parser_unitStatement(
struct VRMLParser* me) {
1309 double conversionfactor;
1310 char *categoryname = NULL;
1311 char *unitname = NULL;
1315 lexer_skip(me->lexer);
1318 if(!lexer_keyword(me->lexer, KW_UNIT))
return FALSE;
1320#ifdef CPARSERVERBOSE
1321 printf (
"parser_unitStatement...\n");
1327 categoryname=NULL; unitname = NULL; conversionfactor = 0.0;
1329 if(!lexer_setCurID(me->lexer))
return TRUE;
1330 ASSERT(me->lexer->curID);
1332 categoryname = STRDUP(me->lexer->curID);
1333 FREE_IF_NZ(me->lexer->curID);
1335 if(!lexer_setCurID(me->lexer))
return TRUE;
1336 ASSERT(me->lexer->curID);
1338 unitname = STRDUP(me->lexer->curID);
1339 FREE_IF_NZ(me->lexer->curID);
1341 if(!parser_sftimeValue(me,&conversionfactor)) {
1342 CPARSE_ERROR_CURID(
"Expected a numeric string after a UNIT keyword")
1345 if ((categoryname != NULL) && (unitname != NULL) && (conversionfactor != 0.0)) {
1346 handleUnitDataStringString(me->ectx,categoryname,unitname,conversionfactor);
1350 if (categoryname != NULL) FREE_IF_NZ(categoryname);
1351 if (unitname != NULL) FREE_IF_NZ(unitname);
1356static BOOL parser_profileStatement(
struct VRMLParser* me) {
1357 int myProfile = INT_ID_UNDEFINED;
1360 lexer_skip(me->lexer);
1363 if(!lexer_keyword(me->lexer, KW_PROFILE))
return FALSE;
1365#ifdef CPARSERVERBOSE
1366 printf (
"parser_profileStatement...\n");
1369 if(!lexer_setCurID(me->lexer))
return TRUE;
1370 ASSERT(me->lexer->curID);
1372 myProfile = findFieldInPROFILES(me->lexer->curID);
1374 if (myProfile != ID_UNDEFINED) {
1375 handleProfile(myProfile);
1377 CPARSE_ERROR_CURID(
"Expected a profile after a PROFILE keyword")
1382#ifdef CPARSERVERBOSE
1383 printf (
"my profile is %d\n",myProfile);
1386 FREE_IF_NZ(me->lexer->curID);
1395static BOOL parser_routeStatement_B(
struct VRMLParser* me);
1397static BOOL parser_routeStatement(
struct VRMLParser* me)
1399 return parser_routeStatement_B(me);
1405void parser_registerRoute(
struct VRMLParser* me,
1406 struct X3D_Node* fromNode,
int fromOfs,
1407 struct X3D_Node* toNode,
int toOfs,
1411 if ((fromOfs == ID_UNDEFINED) || (toOfs == ID_UNDEFINED)) {
1412 ConsoleMessage (
"problem registering route - either fromField or toField invalid");
1414 CRoutes_RegisterSimple(fromNode, fromOfs, toNode, toOfs, ft);
1421 int ind = ID_UNDEFINED;
1426 if(!lexer_defineNodeName(me->lexer, &ind))
1427 PARSE_ERROR(
"Expected nodeNameId after DEF!\n")
1428 ASSERT(ind!=ID_UNDEFINED);
1432 if(!me->DEFedNodes || stack_empty(me->DEFedNodes)) {
1434 parser_scopeIn_DEFUSE(me);
1436 ASSERT(me->DEFedNodes);
1437 ASSERT(!stack_empty(me->DEFedNodes));
1441 ASSERT(ind<=vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1442 if(ind==vectorSize(stack_top(
struct Vector*, me->DEFedNodes))) {
1443 vector_pushBack(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), NULL);
1445 ASSERT(ind<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1451#ifdef CPARSERVERBOSE
1452 printf(
"parser_KW_DEF: parsing DEFed node \n");
1454 if(!parser_node(me, &node,ind)) {
1457 CPARSE_ERROR_CURID(
"ERROR:Expected an X3D node in a DEF statement, got \"");
1461#ifdef CPARSERVERBOSE
1462 printf(
"parser_KW_DEF: DEFed node successfully parsed\n");
1478 if(!lexer_nodeName(me->lexer, &ind)) {
1479 CPARSE_ERROR_CURID(
"ERROR:Expected valid DEF name after USE; found: ");
1480 FREE_IF_NZ(me->lexer->curID);
1483#ifdef CPARSERVERBOSE
1484 printf(
"parser_KW_USE: parsing USE\n");
1488 ASSERT(ind!=ID_UNDEFINED);
1491 ASSERT(me->DEFedNodes && !stack_empty(me->DEFedNodes) &&
1492 ind<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1494 #ifdef CPARSERVERBOSE
1495 printf (
"parser_KW_USE, returning vector %u\n", vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind));
1519void push_binding_stack_set(
struct X3D_Node* layersetnode);
1520void push_next_layerId_from_binding_stack_set(
struct X3D_Node *layer);
1521void pop_binding_stack_set();
1528 if(lexer_keyword(me->lexer, KW_DEF)) {
1531 *ret = parse_KW_DEF(me);
1536 if(lexer_keyword(me->lexer, KW_USE)) {
1537 *ret= parse_KW_USE(me);
1542 return parser_node(me, ret, ID_UNDEFINED);
1552 for(i=0; i!=node->n; ++i) {
1553 ADD_PARENT(node->p[i], parent);
1563void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr);
1567#undef PARSER_FINALLY
1568#define PARSER_FINALLY
1570#ifdef CPARSERVERBOSE
1571 printf (
"start of parser_fieldValue\n");
1572 printf (
"me->curPROTO = %u\n",me->curPROTO);
1576#ifdef CPARSERVERBOSE
1577 printf (
"parser_fieldValue, not an IS\n");
1580#define myOffsetPointer_deref(t, me) \
1581 ((t)(((char*)(node))+offs))
1583 void* directRet=myOffsetPointer_deref(
void*, ret);
1584 deleteMallocedFieldValue(type,directRet);
1599 #ifdef CPARSERVERBOSE
1600 printf (
"parser_fieldValue, me %u, directRet %u\n",me,directRet);
1604 return PARSE_TYPE[type](me, directRet);
1607#undef PARSER_FINALLY
1608#define PARSER_FINALLY
1615#define NODE_SPECIFIC_INIT(type, code) \
1618 struct X3D_##type* node=(struct X3D_##type*)n; \
1623 switch(n->_nodeType)
1626 NODE_SPECIFIC_INIT(Script, node->__scriptObj=new_Shader_ScriptB(X3D_NODE(node));)
1627 NODE_SPECIFIC_INIT(ShaderProgram, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1628 NODE_SPECIFIC_INIT(PackagedShader, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1629 NODE_SPECIFIC_INIT(ComposedShader, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1630 NODE_SPECIFIC_INIT(Effect, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1716#define UNCA_BASE 0X01
1717#define UNCA_DRVD 0x10
1718#define UNCA_BOTH 0x11
1730 {
"length", UNCA_LENGTH, 1,UNCA_BASE,0,1.0,
"meters", },
1731 {
"angle", UNCA_ANGLE, 0,UNCA_BASE,0,1.0,
"radians", },
1732 {
"mass", UNCA_MASS, 0,UNCA_BASE,0,1.0,
"kilograms", },
1734 {
"force", UNCA_FORCE, 1,UNCA_BOTH,0,1.0,
"newtons", },
1736 {
"acceleration",UNCA_ACCEL, 1,UNCA_DRVD,0,1.0,
"meters/second**2", },
1737 {
"angular_rate",UNCA_ANGLERATE,0,UNCA_DRVD,0,1.0,
"radians/second", },
1738 {
"area", UNCA_AREA, 2,UNCA_DRVD,0,1.0,
"meters**2", },
1739 {
"speed", UNCA_SPEED, 1,UNCA_DRVD,0,1.0,
"meters/seccond", },
1740 {
"volume", UNCA_VOLUME, 3,UNCA_DRVD,0,1.0,
"meters**3", },
1741 {
"torque", UNCA_TORQUE, 2,UNCA_DRVD,0,1.0,
"kg*meters**2/second**2",},
1742 {
"moment", UNCA_MOMENT, 2,UNCA_DRVD,0,1.0,
"kg*meters**2", },
1748#define strcasecmp _stricmp
1750#define UNITMETHOD_ONESTEP 1
1751#define UNITMETHOD_TWOSTEP 2
1752static int unitmethod = UNITMETHOD_ONESTEP;
1753static int UNITSTRICT33 = TRUE;
1755static int isunits = 0;
1756static double unitlengthfactor = 1.0;
1757double getunitlengthfactor(){
1758 return unitlengthfactor;
1763void setUnits(
int isOn){
1766static Stack * units2vec = NULL;
1769 if(units2vec) units2vec->n = 0;
1770 unitlengthfactor = 1.0;
1772static int do_lengthunits = 0;
1784 LENGTHMETHOD_NONE = 0,
1786 LENGTHMETHOD_MINUSONE,
1788void addUnits(
void *ecx,
char *category,
char *unit,
double factor){
1790 struct unitsB *uptr, *u2length, *u2mass, *u2force, *u2angle;
1792 int i, iuc, lengthmethod;
1794 if(!units2vec || (units2vec->n == 0)){
1798 units2vec = newVector(
struct unitsB,20);
1802 memcpy(&u2,uc,
sizeof(
struct unca));
1803 memset(&u2.uname,0,20);
1804 memcpy(&u2.uname[0],uc->uname,min(39,strlen(uc->uname)+1));
1805 vector_pushBack(
struct unitsB,units2vec,u2);
1807 }
while(uncas[iuc].catname);
1810 for(i=0;i<vectorSize(units2vec);i++){
1811 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1812 if(!strcasecmp(uptr->catname,category)){
1814 if(uptr->derived & UNCA_BASE){
1815 memcpy(&uptr->uname[0],unit,min(39,strlen(unit)+1));
1816 uptr->factor = factor;
1817 uptr->ichanged = TRUE;
1818 if(uptr->iunca == UNCA_LENGTH) {
1821 unitlengthfactor = factor;
1822 ec->__unitlengthfactor = unitlengthfactor;
1823 do_lengthunits = TRUE;
1831 u2mass = u2angle = u2length = u2force = NULL;
1832 for(i=0;i<vectorSize(units2vec);i++){
1833 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1834 if(uptr->derived & UNCA_BASE){
1835 switch(uptr->iunca){
1837 u2mass = uptr;
break;
1839 u2angle = uptr;
break;
1841 u2length = uptr;
break;
1843 u2force = uptr;
break;
1853 lengthmethod = LENGTHMETHOD_FULL;
1854 if(unitmethod == UNITMETHOD_TWOSTEP)
1855 lengthmethod = LENGTHMETHOD_MINUSONE;
1856 for(i=0;i<vectorSize(units2vec);i++){
1857 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1858 if(uptr->derived & UNCA_DRVD){
1859 double factor = uptr->factor;
1860 switch(uptr->iunca){
1862 if(!uptr->ichanged){
1866 if(lengthmethod == LENGTHMETHOD_FULL)
1867 factor = u2mass->factor * u2length->factor;
1868 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1869 factor = u2mass->factor;
1873 if(lengthmethod == LENGTHMETHOD_FULL)
1874 factor = u2length->factor;
1876 case UNCA_ANGLERATE:
1877 factor = u2angle->factor;
1880 if(lengthmethod == LENGTHMETHOD_FULL)
1881 factor = u2length->factor * u2length->factor;
1882 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1883 factor = u2length->factor;
1886 if(lengthmethod == LENGTHMETHOD_FULL)
1887 factor = u2length->factor;
1892 if(lengthmethod == LENGTHMETHOD_FULL)
1893 factor = u2length->factor * u2length->factor * u2mass->factor;
1894 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1895 factor = u2length->factor * u2mass->factor;
1896 if(lengthmethod == LENGTHMETHOD_NONE)
1897 factor = u2mass->factor;
1902 if(lengthmethod == LENGTHMETHOD_FULL)
1904 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1906 factor = pow(u2length->factor,dpow);
1911 if(lengthmethod == LENGTHMETHOD_FULL)
1912 factor = u2force->factor * u2length->factor;
1913 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1914 factor = u2force->factor;
1919 uptr->factor = factor;
1928 return ( do_lengthunits && unitmethod == UNITMETHOD_TWOSTEP ) ? TRUE : FALSE;
1930int isUnitSpecVersionOK(
int specversion){
1935 return (!UNITSTRICT33 || specversion > 320) ? TRUE : FALSE;
1941void sfunitf(
int nodetype,
char *fieldname,
float *var,
int n,
int iunca) {
1942 int i,k,specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
1943 if(isUnits() && isUnitSpecVersionOK(specversion)){
1945 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
1948 for(i=0;i<vectorSize(units2vec);i++){
1949 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1950 if(uptr->iunca == iunca){
1952 var[k] *= (float)uptr->factor;
1960void mfunitrotation(
int nodetype,
char *fieldname,
struct SFRotation *var,
int n,
int iunca){
1961 int i,k, specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
1962 if(isUnits() && isUnitSpecVersionOK(specversion)){
1965 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
1968 for(i=0;i<vectorSize(units2vec);i++){
1969 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1970 if(uptr->iunca == iunca){
1972 var[k].c[3] *= (float)uptr->factor;
1981void mfunit3f(
int nodetype,
char *fieldname,
struct SFVec3f *var,
int n,
int iunca){
1982 int i,k, specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
1983 if(isUnits() && isUnitSpecVersionOK(specversion)){
1985 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
1988 for(i=0;i<vectorSize(units2vec);i++){
1989 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1990 if(uptr->iunca == iunca){
1992 vecscale3f(var[k].c,var[k].c,(
float)uptr->factor);
2002void sfunitd(
int nodeType,
char *fieldname,
double *var,
int n,
int iunca) {
2006int isNodeGeospatial(
struct X3D_Node* node);
2007void applyUnitsToNode(
struct X3D_Node *node){
2015 int specversion = X3D_PROTO(node->_executionContext)->__specversion;
2016 if(isUnits() && isUnitSpecVersionOK(specversion)){
2020 if(isNodeGeospatial(node)){
2023 double factorA, factorL, factorC;
2026 factorA = factorL = factorC = 1.0;
2027 for(i=0;i<vectorSize(units2vec);i++){
2028 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2029 if(uptr->iunca == UNCA_ANGLE) factorA = uptr->factor;
2030 if(uptr->iunca == UNCA_LENGTH) factorL = uptr->factor;
2035 offsets = (
fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2037 field = &offsets[ifield];
2039 isgeosystemGD = TRUE;
2040 while( field->nameIndex > -1)
2042 const char *name = FIELDNAMES[field->nameIndex];
2043 if(!strcmp(name,
"geoSystem")){
2044 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2045 struct Uni_String *ustring = value->mfstring.p[0];
2046 if(strcmp(ustring->strptr,
"GD"))
2047 isgeosystemGD = FALSE;
2051 field = &offsets[ifield];
2062 offsets = (
fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2064 field = &offsets[ifield];
2066 while( field->nameIndex > -1)
2068 int iunca = field->unca;
2069 const char *name = FIELDNAMES[field->nameIndex];
2070 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2071 if(iunca == UNCA_GEO){
2075 switch(field->typeIndex){
2076 case FIELDTYPE_SFDouble:
2078 value->sfdouble *= factorC;
2080 case FIELDTYPE_MFDouble:
2082 printf(
"mfdouble nixpa7 ");
2084 case FIELDTYPE_SFVec3d:
2085 dvar = value->sfvec2d.c;
2090 case FIELDTYPE_MFVec3d:
2091 for(k=0;k<value->mfvec3d.n;k++){
2092 sfvar = &value->mfvec3d.p[k];
2104 field = &offsets[ifield];
2109 offsets = (
fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2111 field = &offsets[ifield];
2113 while( field->nameIndex > -1)
2115 int iunca = field->unca;
2116 if(iunca == UNCA_PLANE) iunca = UNCA_LENGTH;
2117 const char *name = FIELDNAMES[field->nameIndex];
2118 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2119 if(iunca != UNCA_NONE && iunca != UNCA_ANGLE && iunca != UNCA_ANGLERATE && iunca != UNCA_GEO){
2122 if(!(iunca == UNCA_LENGTH && unitmethod == UNITMETHOD_TWOSTEP)){
2127 for(i=0;i<vectorSize(units2vec);i++){
2128 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2129 if(uptr->iunca == iunca){
2130 factor = (float)uptr->factor;
2134 iunca = field->unca;
2135 switch(field->typeIndex){
2136 case FIELDTYPE_SFRotation:
2137 value->sfrotation.c[3] *= factor;
2139 case FIELDTYPE_SFFloat:
2140 value->sffloat *= factor;
2142 case FIELDTYPE_MFFloat:
2143 for(i=0;i<value->mffloat.n;i++)
2144 value->mffloat.p[i] *= factor;
2146 case FIELDTYPE_SFVec3f:
2147 vecscale3f(value->sfvec3f.c,value->sfvec3f.c,(
float)factor);
2149 case FIELDTYPE_SFVec4f:
2150 if(iunca == UNCA_PLANE)
2151 value->sfvec4f.c[3] *= factor;
2153 vecscale4f(value->sfvec4f.c,value->sfvec4f.c,(
float)factor);
2155 case FIELDTYPE_SFVec2f:
2156 vecscale2f(value->sfvec2f.c,value->sfvec2f.c,(
float)factor);
2158 case FIELDTYPE_MFVec3f:
2159 for(i=0;i<value->mfvec3f.n;i++)
2160 vecscale3f(value->mfvec3f.p[i].c,value->mfvec3f.p[i].c,(
float)factor);
2162 case FIELDTYPE_SFMatrix3f:
2164 value->sfmatrix3f.c[i] *= factor;
2166 case FIELDTYPE_MFRotation:
2167 for(i=0;i<value->mfrotation.n;i++)
2168 value->mfrotation.p[i].c[3] *= factor;
2170 case FIELDTYPE_SFDouble:
2171 value->sfdouble *= factor;
2180 field = &offsets[ifield];
2187#define INIT_CODE_sfnode(var,fieldname) \
2188 ADD_PARENT(node2->var, X3D_NODE(node2));
2189#define INIT_CODE_mfnode(var,fieldname) \
2190 mfnode_add_parent(&node2->var, X3D_NODE(node2));
2191#define INIT_CODE_sfbool(var,fieldname)
2192#define INIT_CODE_sfcolor(var,fieldname)
2193#define INIT_CODE_sfcolorrgba(var,fieldname)
2194#define INIT_CODE_sffloat(var,fieldname) sfunitf(node2->_nodeType,fieldname, (float*)&node2->var, 1,iunca);
2195#define INIT_CODE_sfimage(var,fieldname)
2196#define INIT_CODE_sfint32(var,fieldname)
2197#define INIT_CODE_sfrotation(var,fieldname) sfunitf(node2->_nodeType,fieldname, &node2->var.c[3], 1,iunca);
2198#define INIT_CODE_sfstring(var,fieldname)
2199#define INIT_CODE_sftime(var,fieldname)
2200#define INIT_CODE_sfvec2f(var,fieldname) sfunitf(node2->_nodeType,fieldname, node2->var.c, 2, iunca);
2201#define INIT_CODE_sfvec3f(var,fieldname) sfunitf(node2->_nodeType,fieldname, node2->var.c, 3, iunca);
2202#define INIT_CODE_sfvec3d(var,fieldname)
2203#define INIT_CODE_mfbool(var,fieldname)
2204#define INIT_CODE_mfcolor(var,fieldname)
2205#define INIT_CODE_mfcolorrgba(var,fieldname)
2206#define INIT_CODE_mffloat(var,fieldname) sfunitf(node2->_nodeType,fieldname,node2->var.p, node2->var.n,iunca);
2207#define INIT_CODE_mfint32(var,fieldname)
2208#define INIT_CODE_mfrotation(var,fieldname) mfunitrotation(node2->_nodeType,fieldname, node2->var.p, node2->var.n,iunca);
2209#define INIT_CODE_mfstring(var,fieldname)
2210#define INIT_CODE_mftime(var,fieldname)
2211#define INIT_CODE_mfvec2f(var,fieldname)
2212#define INIT_CODE_mfvec3f(var,fieldname) mfunit3f(node2->_nodeType,fieldname, node2->var.p, node2->var.n, iunca);
2213#define INIT_CODE_mfvec3d(var,fieldname)
2214#define INIT_CODE_sfdouble(var,fieldname)
2215#define INIT_CODE_mfdouble(var,fieldname)
2216#define INIT_CODE_sfvec4d(var,fieldname)
2217#define INIT_CODE_mfmatrix3f(var,fieldname)
2218#define INIT_CODE_mfmatrix4f(var,fieldname)
2220#define INIT_CODE_mfmatrix3d(var,fieldname)
2221#define INIT_CODE_mfmatrix4d(var,fieldname)
2222#define INIT_CODE_mfvec2d(var,fieldname)
2223#define INIT_CODE_mfvec4d(var,fieldname)
2224#define INIT_CODE_mfvec4f(var,fieldname)
2225#define INIT_CODE_sfmatrix3d(var,fieldname)
2226#define INIT_CODE_sfmatrix3f(var,fieldname) sfunitf(node2->_nodeType,fieldname,node2->var.c, 9,iunca);
2227#define INIT_CODE_sfmatrix4d(var,fieldname)
2228#define INIT_CODE_sfmatrix4f(var,fieldname)
2229#define INIT_CODE_sfvec2d(var,fieldname)
2230#define INIT_CODE_sfvec4f(var,fieldname) {if(iunca==UNCA_PLANE) sfunitf(node2->_nodeType,fieldname, &node2->var.c[3], 1, UNCA_LENGTH); else sfunitf(node2->_nodeType,fieldname, node2->var.c, 4, iunca); }
2250 if(!lexer_field(me->lexer, &fieldO, &fieldE, NULL, NULL))
2268#define EVENT_IN(n, f, t, v, realType)
2269#define EVENT_OUT(n, f, t, v, realType)
2272#define END_NODE(type) \
2278#define FTIND_sfnode FIELDTYPE_SFNode
2279#define FTIND_sfbool FIELDTYPE_SFBool
2280#define FTIND_sfcolor FIELDTYPE_SFColor
2281#define FTIND_sfcolorrgba FIELDTYPE_SFColorRGBA
2282#define FTIND_sffloat FIELDTYPE_SFFloat
2283#define FTIND_sfimage FIELDTYPE_SFImage
2284#define FTIND_sfint32 FIELDTYPE_SFInt32
2285#define FTIND_sfrotation FIELDTYPE_SFRotation
2286#define FTIND_sfstring FIELDTYPE_SFString
2287#define FTIND_sftime FIELDTYPE_SFTime
2288#define FTIND_sfdouble FIELDTYPE_SFDouble
2289#define FTIND_sfvec2f FIELDTYPE_SFVec2f
2290#define FTIND_sfvec2d FIELDTYPE_SFVec2d
2291#define FTIND_sfvec3f FIELDTYPE_SFVec3f
2292#define FTIND_sfvec3d FIELDTYPE_SFVec3d
2293#define FTIND_sfvec4f FIELDTYPE_SFVec4f
2294#define FTIND_sfvec4d FIELDTYPE_SFVec4d
2295#define FTIND_sfmatrix3f FIELDTYPE_SFMatrix3f
2296#define FTIND_sfmatrix4f FIELDTYPE_SFMatrix4f
2297#define FTIND_sfmatrix3d FIELDTYPE_SFMatrix3d
2298#define FTIND_sfmatrix4d FIELDTYPE_SFMatrix4d
2300#define FTIND_mfnode FIELDTYPE_MFNode
2301#define FTIND_mfbool FIELDTYPE_MFBool
2302#define FTIND_mfcolor FIELDTYPE_MFColor
2303#define FTIND_mfcolorrgba FIELDTYPE_MFColorRGBA
2304#define FTIND_mffloat FIELDTYPE_MFFloat
2305#define FTIND_mfint32 FIELDTYPE_MFInt32
2306#define FTIND_mfrotation FIELDTYPE_MFRotation
2307#define FTIND_mfstring FIELDTYPE_MFString
2308#define FTIND_mftime FIELDTYPE_MFTime
2309#define FTIND_mfvec2f FIELDTYPE_MFVec2f
2310#define FTIND_mfvec2d FIELDTYPE_MFVec2d
2311#define FTIND_mfvec3f FIELDTYPE_MFVec3f
2312#define FTIND_mfvec3d FIELDTYPE_MFVec3d
2313#define FTIND_mfvec4d FIELDTYPE_MFVec4d
2314#define FTIND_mfvec4f FIELDTYPE_MFVec4f
2315#define FTIND_mfdouble FIELDTYPE_MFDouble
2316#define FTIND_mfmatrix3f FIELDTYPE_MFMatrix3f
2317#define FTIND_mfmatrix4f FIELDTYPE_MFMatrix4f
2318#define FTIND_mfmatrix3d FIELDTYPE_MFMatrix3d
2319#define FTIND_mfmatrix4d FIELDTYPE_MFMatrix4d
2325#define PROCESS_FIELD_B(exposed, node, field, fieldType, var, fe, junca) \
2326 case exposed##FIELD_##field: \
2327 if(!parser_fieldValue(me, \
2328 X3D_NODE(node2), (int) offsetof(struct X3D_##node, var), \
2329 FTIND_##fieldType, fe, FALSE, NULL, NULL)) {\
2330 PARSE_ERROR("Expected " #fieldType " Value for a fieldtype!") }\
2332 INIT_CODE_##fieldType(var,#field) \
2339#define NODE_DEFAULT_B \
2341 PARSE_ERROR("Parser PROCESS_FIELD_B, Unsupported node!")
2348if(fieldE!=ID_UNDEFINED)
2349 switch(node->_nodeType)
2353#define BEGIN_NODE(type) \
2356 struct X3D_##type* node2=(struct X3D_##type*)node; \
2363#define EXPOSED_FIELD(node, field, fieldType, var, realType,iunca) \
2364 PROCESS_FIELD_B(EXPOSED_, node, field, fieldType, var, fieldE,iunca)
2367#define FIELD(n, f, t, v, realType,iunca)
2370#include "NodeFields.h"
2382if(fieldO!=ID_UNDEFINED)
2383 switch(node->_nodeType)
2387#define BEGIN_NODE(type) \
2390 struct X3D_##type* node2=(struct X3D_##type*)node; \
2396#define FIELD(node, field, fieldType, var, realType,iunca) \
2397 PROCESS_FIELD_B(, node, field, fieldType, var, ID_UNDEFINED,iunca)
2400#define EXPOSED_FIELD(n, f, t, v, realType,iunca)
2403#include "NodeFields.h"
2420PARSE_ERROR(
"Unsupported field for node!")
2427 return parser_field_B(me,node);
2443 case FIELDTYPE_MFNode:
2446 outMF->p=MALLOC(
void *,
sizeof(
struct X3D_Node*));
2450 case FIELDTYPE_MFFloat:
2451 case FIELDTYPE_MFRotation:
2452 case FIELDTYPE_MFVec3f:
2453 case FIELDTYPE_MFBool:
2454 case FIELDTYPE_MFInt32:
2455 case FIELDTYPE_MFColor:
2456 case FIELDTYPE_MFColorRGBA:
2457 case FIELDTYPE_MFTime:
2458 case FIELDTYPE_MFDouble:
2459 case FIELDTYPE_MFString:
2460 case FIELDTYPE_MFVec2f:
2462 localSize = returnRoutingElementLength(convertToSFType(type));
2466 outMF->p=MALLOC(
void *, localSize);
2467 memcpy (&outMF->p[0], &in, localSize);
2471 ConsoleMessage(
"VRML Parser; stuffDEFUSE, unhandled type");
2486 rsz = returnElementRowSize(type);
2487 elelen = returnElementLength(type);
2502 for (i=0; i<outMF->n; i++) {
2503 if (type == FIELDTYPE_MFString) {
2506 FREE_IF_NZ(m->strptr);
2511 if (outMF->n != 1) {
2513 FREE_IF_NZ(outMF->p);
2515 outMF->p=MALLOC(
void *, rsz * elelen);
2520 memcpy (outMF->p, inSF, rsz * elelen);
2524#define PARSER_MFFIELD(name, type) \
2525 static BOOL parser_mf##name##Value(struct VRMLParser* me, void *ret) { \
2526 struct Vector* vec; \
2528 struct Multi_##type *rv; \
2536 if (!(me->parsingX3DfromXML)) { \
2538 if(lexer_keyword(me->lexer, KW_USE)) { \
2541 RCX=parse_KW_USE(me); \
2542 if (RCX == NULL) return FALSE; \
2544 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2548 else if (lexer_keyword(me->lexer, KW_DEF)) { \
2551 RCX=parse_KW_DEF(me); \
2552 if (RCX == NULL) return FALSE; \
2555 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2562if (me->lexer->curID != NULL) { \
2564 if (!parser_node(me, &RCX, ID_UNDEFINED)) { \
2567 if (RCX == NULL) return FALSE; \
2569 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2574if((!lexer_openSquare(me->lexer)) && (!(me->parsingX3DfromXML))) { \
2575 vrml##type##T RCXRet; \
2577 if(!parser_sf##name##Value(me, &RCXRet)) { \
2584 stuffSFintoMF(ret, (vrmlNodeT *)&RCXRet, FIELDTYPE_MF##type); \
2590 vec=newVector(vrml##type##T, 128); \
2591 if (!me->parsingX3DfromXML) { \
2592 while(!lexer_closeSquare(me->lexer)) { \
2593 vrml##type##T val; \
2594 if(!parser_sf##name##Value(me, &val)) { \
2595 CPARSE_ERROR_CURID("ERROR:Expected \"]\" before end of MF-Value") \
2598 vector_pushBack(vrml##type##T, vec, val); \
2601 lexer_skip(me->lexer); \
2602 while(*me->lexer->nextIn != '\0') { \
2603 vrml##type##T val; \
2604 if(!parser_sf##name##Value(me, &val)) { \
2605 CPARSE_ERROR_CURID("ERROR:Expected \"]\" before end of MF-Value") \
2608 vector_pushBack(vrml##type##T, vec, val); \
2609 lexer_skip(me->lexer); \
2612 rv = (struct Multi_##type*) ret; \
2613 rv->n=vectorSize(vec); \
2614 rv->p=vector_releaseData(vrml##type##T, vec); \
2616 deleteVector(vrml##type##T, vec); \
2621 PARSER_MFFIELD(
bool, Bool)
2622 PARSER_MFFIELD(color, Color)
2623 PARSER_MFFIELD(colorrgba, ColorRGBA)
2624 PARSER_MFFIELD(
float, Float)
2625 PARSER_MFFIELD(int32, Int32)
2626 PARSER_MFFIELD(node, Node)
2627 PARSER_MFFIELD(rotation, Rotation)
2628 PARSER_MFFIELD(
string, String)
2629 PARSER_MFFIELD(time, Time)
2630 PARSER_MFFIELD(vec2f, Vec2f)
2631 PARSER_MFFIELD(vec3f, Vec3f)
2632 PARSER_MFFIELD(vec3d, Vec3d)
2633 PARSER_MFFIELD(vec2d, Vec2d)
2634 PARSER_MFFIELD(vec4f, Vec4f)
2635 PARSER_MFFIELD(vec4d, Vec4d)
2641#define PARSER_FIXED_VEC(name, type, cnt) \
2642 BOOL parser_sf##name##Value(struct VRMLParser* me, void* ret) \
2645 vrml##type##T *rv; \
2646 ASSERT(me->lexer); \
2647 rv = (vrml##type##T *) ret; \
2648 for(i=0; i!=cnt; ++i) {\
2649 if(!parser_sffloatValue(me, rv->c+i)) \
2656#define PARSER_FIXED_DOUBLE_VEC(name, type, cnt) \
2657 BOOL parser_sf##name##Value(struct VRMLParser* me, void* ret) \
2660 vrml##type##T *rv; \
2661 ASSERT(me->lexer); \
2662 rv = (vrml##type##T *) ret; \
2663 for(i=0; i!=cnt; ++i) {\
2664 if(!parser_sfdoubleValue_(me, rv->c+i)) \
2670 BOOL parser_sfdoubleValue_(
struct VRMLParser* me, vrmlDoubleT* ret)
2672 return lexer_double(me->lexer, ret);
2674static BOOL parser_sffloatValue_(
struct VRMLParser* me,
void* ret)
2677 rf = (vrmlFloatT*)ret;
2678 return lexer_float(me->lexer, rf);
2680static BOOL parser_sfint32Value_(
struct VRMLParser* me,
void* ret)
2683 rf = (vrmlInt32T*)ret;
2684 return lexer_int32(me->lexer, rf);
2691 *ret=newASCIIString((
char *)me->startOfStringPtr[me->lexerInputLevel]);
2695static BOOL parser_sfstringValue_(
struct VRMLParser* me,
void* ret) {
2702 if (!me->parsingX3DfromXML)
return lexer_string(me->lexer, rv);
2704 else return set_X3Dstring(me->lexer, rv);
2709static BOOL parser_sfboolValue(
struct VRMLParser* me,
void* ret) {
2712 rv = (vrmlBoolT*)ret;
2715 if (!me->parsingX3DfromXML) {
2717 if(lexer_keyword(me->lexer, KW_TRUE)) {
2721 if(lexer_keyword(me->lexer, KW_FALSE)) {
2726 if(lexer_keyword(me->lexer, KW_true)) {
2730 if(lexer_keyword(me->lexer, KW_false)) {
2737 if(lexer_keyword(me->lexer, KW_true)) {
2741 if(lexer_keyword(me->lexer, KW_false)) {
2746 if(lexer_keyword(me->lexer, KW_TRUE)) {
2750 if(lexer_keyword(me->lexer, KW_FALSE)) {
2788 PARSER_FIXED_VEC(color, Color, 3)
2789 PARSER_FIXED_VEC(colorrgba, ColorRGBA, 4)
2790 PARSER_FIXED_VEC(matrix3f, Matrix3f, 9)
2791 PARSER_FIXED_VEC(matrix4f, Matrix4f, 16)
2792 PARSER_FIXED_VEC(vec2f, Vec2f, 2)
2793 PARSER_FIXED_VEC(vec4f, Vec4f, 4)
2794 PARSER_FIXED_VEC(rotation, Rotation, 4)
2795 PARSER_FIXED_DOUBLE_VEC(vec2d, Vec2d, 2)
2796 PARSER_FIXED_DOUBLE_VEC(vec3d, Vec3d, 3)
2797 PARSER_FIXED_DOUBLE_VEC(vec4d, Vec4d, 4)
2798 PARSER_FIXED_DOUBLE_VEC(matrix3d, Matrix3d, 9)
2799 PARSER_FIXED_DOUBLE_VEC(matrix4d, Matrix4d, 16)
2804 static BOOL parser_sfimageValue(struct
VRMLParser* me,
void* ret)
2807 vrmlInt32T width, height, depth;
2812 if(!lexer_int32(me->lexer, &width))
2814 if(!lexer_int32(me->lexer, &height))
2816 if(!lexer_int32(me->lexer, &depth))
2820 rv->n=3+width*height;
2821 rv->p=MALLOC(
int *,
sizeof(
int) * rv->n);
2826 for(ptr=rv->p+3; ptr!=rv->p+rv->n; ++ptr)
2827 if(!lexer_int32(me->lexer, ptr))
2838static BOOL parser_sfnodeValue(
struct VRMLParser* me,
void* ret) {
2845 if(lexer_keyword(me->lexer, KW_NULL)) {
2851 if (!me->parsingX3DfromXML) {
2852 return parser_nodeStatement(me, rv);
2855 if (sscanf(me->lexer->startOfStringPtr[me->lexer->lexerInputLevel],
"%lu", &tmp) != 1) {
2856 CPARSE_ERROR_FIELDSTRING (
"error finding SFNode id on line :%s:",
2857 me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
2867static BOOL parser_sftimeValue(
struct VRMLParser* me,
void* ret)
2870 rv = (vrmlTimeT*)ret;
2871 return lexer_double(me->lexer, rv);
2875static BOOL parser_fieldTypeNotParsedYet(
struct VRMLParser* me,
void* ret) {
2876 CPARSE_ERROR_CURID (
"received a request to parse a type not supported yet");
2882 #define OUTLINELEN 800
2884void cParseErrorCurID(
struct VRMLParser *me,
char *str) {
2885 char fw_outline[OUTLINELEN];
2888 if (strlen(str) > FROMSRC) {
2889 memcpy(fw_outline,str,FROMSRC);
2890 fw_outline[FROMSRC-1] =
'\0';
2892 strcpy(fw_outline,str);
2894 if (me->lexer->curID != ((
void *)0)) {
2895 strcat (fw_outline,
"; current token :");
2896 strcat (fw_outline, me->lexer->curID);
2897 strcat (fw_outline,
": ");
2899 if (me->lexer->nextIn != NULL) {
2900 strcat (fw_outline,
" at: \"");
2901 strncat(fw_outline,me->lexer->nextIn,FROMSRC);
2902 if (strlen(me->lexer->nextIn) > FROMSRC)
2903 strcat (fw_outline,
"...");
2904 strcat (fw_outline,
"\"");
2907 p->foundInputErrors++;
2908 ConsoleMessage(fw_outline);
2911void cParseErrorFieldString(
struct VRMLParser *me,
char *str,
const char *str2) {
2913 char fw_outline[OUTLINELEN];
2914 int str2len = (int) strlen(str2);
2917 if (strlen(str) > FROMSRC) str[FROMSRC] =
'\0';
2918 strcpy(fw_outline,str);
2919 strcat (fw_outline,
" (");
2920 strncat (fw_outline,str2,str2len);
2921 strcat (fw_outline,
") ");
2922 if (me->lexer->curID != ((
void *)0)) strcat (fw_outline, me->lexer->curID);
2923 if (me->lexer->nextIn != NULL) {
2924 strcat (fw_outline,
" at: \"");
2925 strncat(fw_outline,me->lexer->nextIn,FROMSRC);
2926 if (strlen(me->lexer->nextIn) > FROMSRC)
2927 strcat (fw_outline,
"...");
2928 strcat (fw_outline,
"\"");
2931 p->foundInputErrors++;
2932 ConsoleMessage(fw_outline);
3014void add_node_to_broto_context(
struct X3D_Proto *currentContext,
struct X3D_Node *node);
3016static BOOL parser_externbrotoStatement(
struct VRMLParser* me);
3018 int nodeTypeB, nodeTypeU, isBroto;
3026 currentContext = (
struct X3D_Proto*)me->ectx;
3027 pflagdepth = ciflag_get(currentContext->__protoFlags,0);
3038#ifdef CPARSERVERBOSE
3039 printf (
"parser_node START, curID :%s: nextIn :%s:\n",me->lexer->curID, me->lexer->nextIn);
3044 if(parser_routeStatement(me)) {
3048 if (parser_componentStatement(me)) {
3052 if (parser_exportStatement(me)) {
3056 if (parser_importStatement(me)) {
3060 if (parser_metaStatement(me)) {
3064 if (parser_profileStatement(me)) {
3067 if(parser_brotoStatement(me)) {
3070 if(parser_externbrotoStatement(me)) {
3077 if(!lexer_node(me->lexer, &nodeTypeB, &nodeTypeU)) {
3078#ifdef CPARSERVERBOSE
3079 printf (
"parser_node, not lexed - is this one of those special nodes?\n");
3088 if(!lexer_openCurly(me->lexer))
3089 PARSE_ERROR(
"Expected { after node-type id!")
3091#ifdef CPARSERVERBOSE
3092 printf (
"parser_node: have nodeTypeB %d nodeTypeU %d\n",nodeTypeB, nodeTypeU);
3095 if (nodeTypeU != ID_UNDEFINED) {
3101 char *protoname = vector_get(
char*, me->lexer->userNodeTypesVec, nodeTypeU);
3105 if( isAvailableBroto(protoname, currentContext , &proto))
3109 idepth = pflagdepth == 1;
3110 node=X3D_NODE(brotoInstance(proto,idepth));
3111 node->_executionContext = X3D_NODE(currentContext);
3112 add_node_to_broto_context(currentContext,node);
3116 if (ind != ID_UNDEFINED) {
3119 vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind)=node;
3120#ifdef CPARSERVERBOSE
3121 printf(
"parser_node: adding DEFed node (pointer %p) to DEFedNodes vector\n", node);
3123 name = vector_get(
char*, stack_top(
struct Vector*, me->lexer->userNodeNames), ind);
3124 broto_store_DEF((
struct X3D_Proto*)(me->ectx),node, name);
3131 if(nodeTypeB!=ID_UNDEFINED) {
3132#ifdef CPARSERVERBOSE
3133 printf(
"parser_node: parsing builtin node\n");
3138 node=X3D_NODE(createNewX3DNode((
int)nodeTypeB));
3139 if(node->_nodeType == NODE_Inline){
3140 if(X3D_NODE(me->ectx)->_nodeType != NODE_Inline && X3D_NODE(me->ectx)->_nodeType != NODE_Proto)
3141 printf(
"ouch trying to caste a %d nodetype to inline or proto\n",X3D_NODE(me->ectx)->_nodeType);
3142 X3D_INLINE(node)->__parentProto = me->ectx;
3145 node=X3D_NODE(createNewX3DNode0((
int)nodeTypeB));
3147 node->_executionContext = X3D_NODE(currentContext);
3148 add_node_to_broto_context(currentContext,node);
3153 if (ind != ID_UNDEFINED) {
3156 vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind)=node;
3157 name = vector_get(
char*, stack_top(
struct Vector*, me->lexer->userNodeNames), ind);
3158 broto_store_DEF((
struct X3D_Proto*)(me->ectx),node, name);
3160#ifdef CPARSERVERBOSE
3161 printf(
"parser_node: adding DEFed node (pointer %p) to DEFedNodes vector\n", node);
3168 parser_specificInitNode_B(node, me);
3171 switch (node->_nodeType) {
3172 case NODE_Script: script=X3D_SCRIPT(node)->__scriptObj;
break;
3173 case NODE_ShaderProgram: shader=(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
3174 case NODE_PackagedShader: shader=(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
3175 case NODE_ComposedShader: shader=(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
3176 case NODE_Effect: shader=(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
3178 push_binding_stack_set(node);
break;
3179 case NODE_LayoutLayer:
3181 push_next_layerId_from_binding_stack_set(node);
break;
3193 if( (nodeTypeB!=ID_UNDEFINED) || isBroto)
3195 #define SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING 1
3204#ifdef CPARSERVERBOSE
3205 printf(
"parser_node: try parsing field ... \n");
3208 if( found_IS_field(me,node) ){
3212 if(SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3213 if(parser_field_user(me,node)) {
3218 if(parser_field(me, node)) {
3219#ifdef CPARSERVERBOSE
3220 printf(
"parser_node: field parsed\n");
3229#ifdef CPARSERVERBOSE
3230 printf(
"parser_node: try parsing ROUTE ... \n");
3235 BLOCK_STATEMENT(parser_node);
3245#ifdef CPARSERVERBOSE
3246 printf(
"parser_node: try parsing PROTO ... \n");
3257 if(parser_brotoStatement(me)) {
3258#ifdef CPARSERVERBOSE
3259 printf(
"parser_vrmlScene: BROTO parsed\n");
3264#ifdef CPARSERVERBOSE
3265 printf(
"parser_node: try parsing Script or Shader field\n");
3275 if(SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3276 if(script && parser_interfaceDeclarationB(me, NULL, script)){
3279 if(!SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3280 if(script && parser_interfaceDeclaration(me, NULL, script)) {
3281#ifdef CPARSERVERBOSE
3282 printf(
"parser_node: SCRIPT field parsed\n");
3287 if(shader && parser_interfaceDeclaration(me, NULL, shader)) {
3288#ifdef CPARSERVERBOSE
3289 printf(
"parser_node: Shader field parsed\n");
3297 applyUnitsToNode(node);
3300#ifdef CPARSERVERBOSE
3301 printf(
"parser_node: try parsing SCRIPT url\n");
3305 initialize_one_script(script,&X3D_SCRIPT(node)->url);
3306#ifdef CPARSERVERBOSE
3307 printf(
"parser_node: SCRIPT url parsed\n");
3311 if(isBroto && pflagdepth){
3319 ptype = X3D_PROTO(X3D_PROTO(node)->__prototype);
3320 pdest = X3D_PROTO(node);
3321 deep_copy_broto_body2(&ptype,&pdest);
3331#ifdef CPARSERVERBOSE
3332 printf (
"calling lexer_closeCurly at B\n");
3335 if(!lexer_closeCurly(me->lexer)) {
3336 CPARSE_ERROR_CURID(
"ERROR: Expected a closing brace after fields of a node;")
3340 if(node->_nodeType == NODE_LayerSet)
3341 pop_binding_stack_set();
3345 #ifdef CPARSERVERBOSE
3346 printf (
"returning at end of parser_node, ret %u\n",node);
3347 if (node != NULL) printf (
"and, node type is %s\n",stringNodeType(node->_nodeType));
3377#ifdef CPARSERVERBOSE
3378 printf (
"start of parser_interfaceDeclaration\n");
3383 ASSERT((proto || script) && !(proto && script));
3390 if(!lexer_protoFieldMode(me->lexer, &mode)) {
3391#ifdef CPARSERVERBOSE
3392 printf (
"parser_interfaceDeclaration, not lexer_protoFieldMode, returning\n");
3400 if (script != NULL) {
3401 if(script->ShaderScriptNode->_nodeType==NODE_Script && mode==PKW_inputOutput)
3403 PARSE_ERROR(
"Scripts must not have inputOutputs!")
3410 if(!lexer_fieldType(me->lexer, &type))
3411 PARSE_ERROR(
"Expected fieldType after proto-field keyword!")
3413#ifdef CPARSERVERBOSE
3414 printf (
"parser_interfaceDeclaration, switching on mode %s\n",PROTOKEYWORDS[mode]);
3423#define LEX_DEFINE_FIELDID(suff) \
3425 if(!lexer_define_##suff(me->lexer, &name)) \
3426 PARSE_ERROR("Expected fieldNameId after field type!") \
3429 LEX_DEFINE_FIELDID(initializeOnly)
3430 LEX_DEFINE_FIELDID(inputOnly)
3431 LEX_DEFINE_FIELDID(outputOnly)
3432 LEX_DEFINE_FIELDID(inputOutput)
3445#ifdef CPARSERVERBOSE
3446 printf (
"parser_interfaceDeclaration, calling newProtoFieldDecl\n");
3449 pdecl=newProtoFieldDecl(mode, type, name);
3452#ifdef CPARSERVERBOSE
3453 printf (
"parser_interfaceDeclaration, finished calling newProtoFieldDecl\n");
3456#ifdef CPARSERVERBOSE
3457 printf (
"parser_interfaceDeclaration, calling newScriptFieldDecl\n");
3460 sdecl=newScriptFieldDecl(me->lexer, mode, type, name);
3468 if(mode==PKW_initializeOnly || mode==PKW_inputOutput) {
3469#ifdef CPARSERVERBOSE
3470 printf (
"parser_interfaceDeclaration, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
3472 bzero (&defaultVal,
sizeof (
union anyVrml));
3476 pdecl->defaultVal=defaultVal;
3482 scriptFieldDecl_setFieldValue(sdecl, defaultVal);
3492 protoDefinition_addIfaceField(proto, pdecl);
3500 #ifdef CPARSERVERBOSE
3501 printf (
"end of parser_interfaceDeclaration\n");
3513BOOL find_anyfield_by_name(
struct VRMLLexer* lexer,
struct X3D_Node* node,
union anyVrml **anyptr,
int *imode,
int *itype,
char* nodeFieldName,
int *isource,
void **fdecl,
int *ifield);
3530 char *nodeFieldName;
3542#ifdef CPARSERVERBOSE
3543 printf (
"start of parser_field_user\n");
3553 if(!lexer_setCurID(me->lexer))
return FALSE;
3554 ASSERT(me->lexer->curID);
3559 nodeFieldName = STRDUP(me->lexer->curID);
3566 FREE_IF_NZ(me->lexer->curID);
3570 if(!find_anyfield_by_name(me->lexer,node,&targetVal,&mode,&type,nodeFieldName,&source,&fdecl,&ifield)){
3573 FREE_IF_NZ(nodeFieldName);
3578 FREE_IF_NZ(nodeFieldName);
3583 if(mode==PKW_initializeOnly || mode==PKW_inputOutput) {
3584#ifdef CPARSERVERBOSE
3585 printf (
"parser_field_user, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
3591 deleteMallocedFieldValue(type,targetVal);
3592 if (!parseType(me, type, targetVal)) {
3594 CPARSE_ERROR_CURID(
"Expected default value for field!");
3597 FREE_IF_NZ(nodeFieldName);
3606 struct X3D_Proto *pnode = X3D_PROTO(node);
3609 struct ProtoFieldDecl * pf = protoDefinition_getFieldByNum(pd, ifield);
3633 #ifdef CPARSERVERBOSE
3634 printf (
"end of parser_user_field\n");
3637 FREE_IF_NZ(nodeFieldName);
3647static BOOL parser_brotoStatement(
struct VRMLParser* me)
3664 if(!lexer_keyword(me->lexer, KW_PROTO))
3673 if(!lexer_defineNodeType(me->lexer, &name))
3674 PARSE_ERROR(
"Expected nodeTypeId after PROTO!\n")
3675 ASSERT(name!=ID_UNDEFINED);
3678 obj=newProtoDefinition();
3681 if (vectorSize(me->lexer->userNodeTypesVec) != ID_UNDEFINED) {
3682 obj->protoName = STRDUP(vector_get(
const char*, me->lexer->userNodeTypesVec, vectorSize(me->lexer->userNodeTypesVec)-1));
3684 printf (
"warning - have proto but no name, so just copying a default string in\n");
3685 obj->protoName = STRDUP(
"noProtoNameDefined");
3688 #ifdef CPARSERVERBOSE
3689 printf (
"parser_protoStatement, working on proto :%s:\n",obj->protoName);
3694 parser_scopeIn_PROTO(me);
3708 if(!lexer_openSquare(me->lexer))
3709 PARSE_ERROR(
"Expected [ to start interface declaration!")
3715 while(parser_interfaceDeclaration(me, obj, NULL));
3718 if(!lexer_closeSquare(me->lexer))
3719 PARSE_ERROR("Expected ] after interface declaration!")
3729 proto = createNewX3DNode0(NODE_Proto);
3731 if(X3D_NODE(me->ectx)->_nodeType != NODE_Proto && X3D_NODE(me->ectx)->_nodeType != NODE_Inline )
3732 printf("ouch trying to caste node type %d to proto\n",X3D_NODE(me->ectx)->_nodeType);
3734 if(parent->__protoDeclares == NULL)
3735 parent->__protoDeclares = newVector(struct
X3D_Proto*,4);
3736 vector_pushBack(struct
X3D_Proto*,parent->__protoDeclares,proto);
3739 proto->__parentProto = X3D_NODE(parent);
3740 proto->__protoFlags = parent->__protoFlags;
3741 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,0);
3743 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,2);
3744 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,3);
3746 proto->__protoDef = obj;
3747 proto->__prototype = X3D_NODE(proto);
3748 proto->__typename = STRDUP(obj->protoName);
3749 proto->__unitlengthfactor = getunitlengthfactor();
3750 proto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
3754 if(!lexer_openCurly(me->lexer))
3755 PARSE_ERROR("Expected { to start PROTO body!
")
3757 /* record the start of this proto body - keep the text around */
3758 //startOfBody = (char *) me->lexer->nextIn;
3759 //initCP = (char *) me->lexer->startOfStringPtr[me->lexer->lexerInputLevel];
3761 /* Create a new vector of nodes and push it onto the DEFedNodes stack */
3762 /* This is the list of nodes defined for this scope */
3763 /* Also checks that the PROTOs vector exists, and creates it if it does not */
3769#ifdef CPARSERVERBOSE
3770 printf ("about to parse PROTO body;
new proto def %p\n
",obj);
3776 ofs = me->ofs; //Q. does this change? Or are we always ofs of children in Proto? H: parseFromString different
3779 me->ofs = offsetof(struct X3D_Proto, __children);
3780 parse_proto_body(me);
3785 /* We are done parsing this proto. Set the curPROTO to the last proto we were parsing. */
3786 // me->curPROTO=oldCurPROTO;
3788 if(!lexer_closeCurly(me->lexer))
3789 PARSE_ERROR("Expected } to end PROTO body!
")
3791 /* Takes the top DEFedNodes vector off of the stack. The local scope now refers to the next vector in the DEFedNodes stack */
3792 parser_scopeOut(me);
3794 /* Make sure that the next token is a '}'. Skip over it. */
3795#ifdef CPARSERVERBOSE
3796 printf ("calling lexer_closeCurly at A\n
");
3797printf ("parser_protoStatement, FINISHED proto :%s:\n
",obj->protoName);
3803/* EXTERNPROTO keyword handling.
3804 Like PROTO above: parses ExternProtoDeclare Interface as a X3D_Proto
3805 - with __url and resource for fetching the definition
3807#define LOAD_INITIAL_STATE 0
3808static BOOL parser_externbrotoStatement(struct VRMLParser* me)
3811 struct ProtoDefinition* obj;
3812 //char *startOfBody;
3816 struct X3D_Proto *proto, *parent;
3822 /* Really a EXTERNPROTO? */
3824 if(!lexer_keyword(me->lexer, KW_EXTERNPROTO))
3831 /* lexer_defineNodeType is #defined as lexer_defineID(me, ret, userNodeTypesVec, FALSE) */
3832 /* Add the EXTERNPROTO name to the userNodeTypesVec list of names return the index of the name in the list in name */
3833 if(!lexer_defineNodeType(me->lexer, &name))
3834 PARSE_ERROR("Expected nodeTypeId after EXTERNPROTO!\n
")
3835 ASSERT(name!=ID_UNDEFINED);
3837 /* Create a new blank ProtoDefinition structure to contain the data for this EXTERNPROTO */
3838 obj=newProtoDefinition();
3839 obj->isExtern = TRUE;
3840 /* save the name, if we can get it - it will be the last name on the list, because we will have JUST parsed it. */
3841 if (vectorSize(me->lexer->userNodeTypesVec) != ID_UNDEFINED) {
3842 obj->protoName = STRDUP(vector_get(const char*, me->lexer->userNodeTypesVec, vectorSize(me->lexer->userNodeTypesVec)-1));
3844 printf ("warning - have proto but no name, so just copying a
default string in\n
");
3845 obj->protoName = STRDUP("noProtoNameDefined
");
3848 #ifdef CPARSERVERBOSE
3849 printf ("parser_protoStatement, working on proto :%s:\n
",obj->protoName);
3852 /* If the PROTOs stack has not yet been created, create it */
3854 parser_scopeIn_PROTO(me);
3858 /* ASSERT(name==vectorSize(me->PROTOs)); */
3860 /* Add the empty ProtoDefinition structure we just created onto the PROTOs stack */
3861 vector_pushBack(struct ProtoDefinition*, me->PROTOs, obj);
3863 /* Now we want to fill in the information in the ProtoDefinition */
3865 /* Interface declarations */
3867 /* Make sure that the next token is a '['. Skip over it. */
3868 if(!lexer_openSquare(me->lexer))
3869 PARSE_ERROR("Expected [ to start
interface declaration!")
3875 while(parser_interfaceDeclaration(me, obj, NULL));
3878 if(!lexer_closeSquare(me->lexer))
3879 PARSE_ERROR(
"Expected ] after interface declaration!")
3889 proto = createNewX3DNode0(NODE_Proto);
3892 if(parent->__externProtoDeclares == NULL)
3893 parent->__externProtoDeclares = newVector(struct
X3D_Proto*,4);
3894 vector_pushBack(struct
X3D_Proto*,parent->__externProtoDeclares,proto);
3897 proto->__parentProto = X3D_NODE(parent);
3898 proto->__protoFlags = parent->__protoFlags;
3899 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,0);
3901 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,2);
3902 proto->__protoFlags = ciflag_set(proto->__protoFlags,1,3);
3904 proto->__protoDef = obj;
3905 proto->__prototype = X3D_NODE(proto);
3906 proto->__typename = (
void *)STRDUP(obj->protoName);
3907 proto->__unitlengthfactor = getunitlengthfactor();
3908 proto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
3918 if (!parser_mfstringValue(me,&proto->url)) {
3919 PARSE_ERROR (
"EXTERNPROTO - problem reading URL string");
3921 proto->__loadstatus = LOAD_INITIAL_STATE;
3944void broto_store_route(
struct X3D_Proto* proto,
3945 struct X3D_Node* fromNode,
int fromIndex,
int fromBuiltIn,
3946 struct X3D_Node* toNode,
int toIndex,
int toBuiltIn,
3953 if ((fromIndex == ID_UNDEFINED) || (toIndex == ID_UNDEFINED)) {
3954 ConsoleMessage (
"problem registering route - either fromField or toField invalid");
3958 route = createNewBrotoRoute();
3959 route->from.node = fromNode;
3960 route->from.ifield = fromIndex;
3961 route->from.builtIn = fromBuiltIn;
3962 route->to.node = toNode;
3963 route->to.ifield = toIndex;
3964 route->to.builtIn = toBuiltIn;
3965 route->lastCommand = 1;
3968 routes = proto->__ROUTES;
3969 if( routes == NULL){
3971 proto->__ROUTES = routes;
3973 stack_push(
struct brotoRoute *, routes, route);
3995void broto_store_ImportRoute_obsolete(
struct X3D_Proto* proto,
char *fromNode,
char *fromField,
char *toNode,
char* toField)
3999 if( proto->__ROUTES == NULL)
4000 proto->__ROUTES= newStack(
struct brotoRoute *);
4001 route = createNewBrotoRoute();
4003 route->lastCommand = 0;
4004 route->from.weak = 2;
4005 route->from.cnode = STRDUP(fromNode);
4006 route->from.cfield = STRDUP(fromField);
4007 route->from.ftype = -1;
4009 route->to.cnode = STRDUP(toNode);
4010 route->to.cfield = STRDUP(toField);
4011 route->to.ftype = -1;
4012 stack_push(
struct brotoRoute *, proto->__ROUTES, route);
4021 if( context->__ROUTES == NULL)
4022 context->__ROUTES= newStack(
struct brotoRoute *);
4023 stack_push(
struct brotoRoute *, context->__ROUTES, route);
4025void free_brouteEnd(
struct brouteEnd *bend){
4026 FREE_IF_NZ(bend->cnode);
4027 FREE_IF_NZ(bend->cfield);
4030 free_brouteEnd(&route->from);
4031 free_brouteEnd(&route->to);
4036BOOL route_parse_nodefield(
struct VRMLParser* me,
int *NodeIndex,
struct X3D_Node** Node,
int KW_eventType,
4039 int PKW_eventType = PKW_outputOnly;
4046 char *nodeFieldName;
4057 if(KW_eventType == KW_outputOnly){
4058 PKW_eventType = PKW_outputOnly;
4059 cerror1 =
"Expected an event of type : outputOnly :";
4060 }
else if(KW_eventType == KW_inputOnly) {
4061 PKW_eventType = PKW_inputOnly;
4062 cerror1 =
"Expected an event of type : inputOnly :";
4068 if(!lexer_nodeName(me->lexer, NodeIndex)) {
4070 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected a valid DEF name; found \"");
4077 ASSERT(me->DEFedNodes && !stack_empty(me->DEFedNodes) && *NodeIndex<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
4080 stack_top(
struct Vector*, me->DEFedNodes),
4083 if (*Node == NULL) {
4085 CPARSE_ERROR_CURID(
"ERROR:ROUTE: no DEF name found - check scoping and \"}\"s");
4092 if(!lexer_point(me->lexer)) {
4093 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected \".\" after the NODE name")
4099 if(!lexer_setCurID(me->lexer)) return FALSE;
4100 ASSERT(me->lexer->curID);
4101 nodeFieldName = STRDUP(me->lexer->curID);
4103 FREE_IF_NZ(me->lexer->curID);
4106 foundField = find_anyfield_by_nameAndRouteDir( *Node, &fieldPtr, &mode, &type,
4107 nodeFieldName, &source, &fdecl, &ifield, PKW_eventType);
4111 *Ofs = NODE_OFFSETS[(*Node)->_nodeType][ifield*FIELDOFFSET_LENGTH + 1];
4114 *ScriptField = fdecl;
4118 if((*Node)->_nodeType==NODE_Script && !fdecl) {
4119 PARSE_ERROR(
"Event-field invalid for this PROTO/Script!")
4121 PARSE_ERROR(cerror1)
4123 FREE_IF_NZ(nodeFieldName);
4127struct IMEXPORT *broto_search_IMPORTname(
struct X3D_Proto *context,
const char *name);
4128BOOL route_parse_nodefield_B(
struct VRMLParser* me,
char **ssnode,
char **ssfield)
4136 char *snode,*sfield;
4141 if(!lexer_setCurID(me->lexer))
4143 ASSERT(me->lexer->curID);
4144 snode = STRDUP(me->lexer->curID);
4145 FREE_IF_NZ(me->lexer->curID);
4149 if(!lexer_point(me->lexer)) {
4150 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected \".\" after the NODE name")
4156 if(!lexer_setCurID(me->lexer))
4158 ASSERT(me->lexer->curID);
4159 sfield = STRDUP(me->lexer->curID);
4160 FREE_IF_NZ(me->lexer->curID);
4170void QAandRegister_parsedRoute_B(struct
X3D_Proto *context,
char* fnode,
char* ffield,
char* tnode,
char* tfield);
4174static BOOL parser_routeStatement_B(struct
VRMLParser* me)
4176 char *sfnode, *sffield;
4177 char *stnode, *stfield;
4178 int foundfrom, foundto, gotTO;
4183 lexer_skip(me->lexer);
4186 if(!lexer_keyword(me->lexer, KW_ROUTE))
4194 foundfrom = route_parse_nodefield_B(me,&sfnode, &sffield);
4198 if(!lexer_keyword(me->lexer, KW_TO)) {
4200 char *buf = p->fw_outline;
4201 strcpy (buf,
"ERROR:ROUTE: Expected \"TO\" found \"");
4202 if (me->lexer->curID != NULL) strcat (buf, me->lexer->curID);
else strcat (buf,
"(EOF)");
4203 CPARSE_ERROR_CURID(buf);
4211 foundto = route_parse_nodefield_B(me,&stnode, &stfield);
4213 if(!(foundfrom && gotTO && foundto)){
4215 FREE_IF_NZ(sffield);
4217 FREE_IF_NZ(stfield);
4222 QAandRegister_parsedRoute_B(X3D_PROTO(me->ectx), sfnode, sffield, stnode, stfield);
4224 FREE_IF_NZ(sffield);
4226 FREE_IF_NZ(stfield);
4286void broto_store_DEF(
struct X3D_Proto* proto,
struct X3D_Node* node,
const char *name)
4291 def.name = STRDUP(name);
4292 defs = proto->__DEFnames;
4296 proto->__DEFnames = defs;
4300int broto_search_DEF_index_by_node(
struct X3D_Proto* proto,
struct X3D_Node *node){
4302 Stack *defs = proto->__DEFnames;
4306 for(i=0;i<vectorSize(defs);i++){
4308 if(def.node == node){
4322 index = broto_search_DEF_index_by_node(proto,node);
4324 defs = proto->__DEFnames;
4326 FREE_IF_NZ(def.name);
4327 vector_removeElement(
sizeof(
struct brotoDefpair),defs,index);
4330struct X3D_Node *broto_search_DEFname(
struct X3D_Proto *context,
const char *name){
4331 int i, istart, iend;
4336 if(context->__DEFnames){
4337 istart = vectorSize(context->__DEFnames) -1;
4339 for(i=istart;i>=iend; i--) {
4340 def = vector_get(
struct brotoDefpair, context->__DEFnames,i);
4341 if(!strcmp(def.name, name))
return def.node;
4346struct IMEXPORT *broto_search_IMPORTname(
struct X3D_Proto *context,
const char *name){
4349 if(context->__IMPORTS)
4350 for(i=0;i<vectorSize(context->__IMPORTS);i++){
4351 def = vector_get(
struct IMEXPORT *, context->__IMPORTS,i);
4352 if(!strcmp(def->as,name))
return def;
4356struct IMEXPORT *broto_search_EXPORTname(
struct X3D_Proto *context,
const char *name){
4359 if(context->__EXPORTS)
4360 for(i=0;i<vectorSize(context->__EXPORTS);i++){
4361 def = vector_get(
struct IMEXPORT *, context->__EXPORTS,i);
4362 if(!strcmp(def->as,name))
return def;
4368BOOL isAvailableBroto(
const char *pname,
struct X3D_Proto* currentContext,
struct X3D_Proto **proto)
4381 context = currentContext;
4387 BOOL bottomUp = TRUE;
4389 plist = (
struct Vector*) context->__protoDeclares;
4391 int n = vectorSize(plist);
4395 if(bottomUp) j = n - 1 - i;
4397 p = vector_get(
struct X3D_Proto*,plist,j);
4398 obj = p->__protoDef;
4399 if(!strcmp(obj->protoName,pname))
4406 plist = (
struct Vector*) context->__externProtoDeclares;
4408 int n = vectorSize(plist);
4412 if(bottomUp) j = n - 1 - i;
4414 p = vector_get(
struct X3D_Proto*,plist,j);
4415 obj = p->__protoDef;
4416 if(!strcmp(obj->protoName,pname))
4423 context = (
struct X3D_Proto*)context->__parentProto;
4425 printf(
"ouch no broto definition found\n");
4438 for(i=0;i<p2p->n;i++)
4441 if(pair.pp == source){
4454 struct X3D_Node *fromNode, *toNode;
4455 if(routes == NULL)
return;
4456 for(i=0;i<routes->n;i++)
4458 route = vector_get(
struct brotoRoute*, routes, i);
4461 fromNode = p2p_lookup(route->from.node,p2p);
4462 toNode = p2p_lookup(route->to.node,p2p);
4463 CRoutes_RegisterSimpleB(fromNode, route->from.ifield, route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4467 broto_store_route(target,fromNode,route->from.ifield,route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4485 if(target->__DEFnames == NULL)
4491 n = vectorSize(defnames);
4494 def2.name = STRDUP(def.name);
4495 def2.node = p2p_lookup(def.node, p2p);
4497 stack_push(
struct brotoDefpair, target->__DEFnames, def2);
4502void copy_IStable(
Stack **sourceIS,
Stack** destIS);
4505void initialize_scripts(
Stack *instancedScripts);
4538 Stack *instancedScripts;
4543 p->__children.n = 0;
4544 p->__children.p = NULL;
4545 parent = (
struct X3D_Node*) (*dest);
4546 prototype = (
struct X3D_Proto*)(*proto)->__prototype;
4548 p->__prototype = X3D_NODE(prototype);
4550 p->__protoFlags = ciflag_set(p->__protoFlags,1,2);
4557 copy_IStable((
Stack **) &(prototype->__IS), (
Stack **) &(p->__IS));
4559 instancedScripts = (*dest)->__scripts;
4560 if( instancedScripts == NULL)
4562 instancedScripts = newStack(
struct X3D_Node *);
4563 (*dest)->__scripts = instancedScripts;
4567 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(prototype->__children),(
union anyVrml*)&(p->__children),
4568 p2p,instancedScripts,p,parent);
4570 copy_routes2(prototype->__ROUTES, p, p2p);
4572 copy_defnames2(prototype->__DEFnames, p, p2p);
4575 copy_IS(p->__IS, p, p2p);
4577 initialize_scripts(instancedScripts);
4597 pushInputResource(proto->_parentResource);
4598 p = createNewX3DNode(NODE_Proto);
4601 p->__children.n = 0;
4602 p->__children.p = NULL;
4605 pflags = ciflag_set(pflags,1,0);
4607 pflags = ciflag_set(pflags,1,2);
4608 pflags = ciflag_set(pflags,0,3);
4609 if(ciflag_get(proto->__protoFlags,3)==1)
4610 pflags = ciflag_set(pflags,1,3);
4612 p->__protoFlags = pflags;
4615 p = createNewX3DNode0(NODE_Proto);
4617 p->__children.n = 0;
4618 p->__children.p = NULL;
4625 p->__protoFlags = 0;
4630 p->__prototype = proto->__prototype;
4631 p->_nodeType = proto->_nodeType;
4632 p->__unitlengthfactor = proto->__unitlengthfactor;
4633 p->__specversion = proto->__specversion;
4634 p->_defaultContainer = proto->_defaultContainer;
4635 p->_renderFlags = proto->_renderFlags;
4636 pobj = proto->__protoDef;
4640 nobj->iface = newVector(
struct ProtoFieldDecl *, pobj->iface->n);
4642 nobj->protoName = STRDUP(pobj->protoName);
4643 for(i=0;i<pobj->iface->n;i++)
4645 pdecl = protoDefinition_getFieldByNum(pobj, i);
4647 ndecl=newProtoFieldDecl(pdecl->mode, pdecl->type, pdecl->name);
4651 ndecl = copy_ProtoFieldDecl(pdecl);
4653 protoDefinition_addIfaceField(nobj, ndecl);
4655 p->__protoDef = nobj;
4665 for(i=0;i<p2p->n;i++)
4668 if(pnode == pair.pp)
return pair.pn;
4677 struct X3D_Node *fromNode, *toNode;
4678 if(routes == NULL)
return;
4679 for(i=0;i<routes->n;i++)
4681 route = vector_get(
struct brotoRoute*, routes, i);
4684 fromNode = p2p_lookup(route->from.node,p2p);
4685 toNode = p2p_lookup(route->to.node,p2p);
4686 CRoutes_RegisterSimpleB(fromNode, route->from.ifield, route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4702 char *protofieldname;
4708 char* nodefieldname;
4721 if(istable == NULL)
return;
4722 for(i=0;i<istable->n;i++)
4724 int ifield, builtIn, iprotofield;
4725 is = vector_get(
struct brotoIS*, istable, i);
4728 node = p2p_lookup(is->node,p2p);
4730 pnode = X3D_NODE(target);
4731 ifield = is->ifield;
4732 builtIn = is->builtIn;
4735 iprotofield = is->iprotofield;
4738 if(is->pmode == PKW_outputOnly){
4741 CRoutes_RegisterSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4743 }
else if(is->pmode == PKW_inputOnly){
4744 CRoutes_RegisterSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4745 }
else if(is->pmode == PKW_inputOutput){
4746 CRoutes_RegisterSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4747 CRoutes_RegisterSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4753void unregister_IStableRoutes(
Stack* istable,
struct X3D_Proto* target){
4761 if(istable == NULL)
return;
4762 for(i=0;i<istable->n;i++)
4764 int ifield, builtIn, iprotofield;
4765 is = vector_get(
struct brotoIS*, istable, i);
4770 pnode = X3D_NODE(target);
4771 ifield = is->ifield;
4772 builtIn = is->builtIn;
4775 iprotofield = is->iprotofield;
4778 if(is->pmode == PKW_outputOnly){
4781 CRoutes_RemoveSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4783 }
else if(is->pmode == PKW_inputOnly){
4784 CRoutes_RemoveSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4785 }
else if(is->pmode == PKW_inputOutput){
4786 CRoutes_RemoveSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4787 CRoutes_RemoveSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4794void copy_IStable(
Stack **sourceIS,
Stack** destIS)
4799 *destIS = newStack(
struct brotoIS*);
4801 for(i=0;i<(*sourceIS)->n;i++)
4804 iss = vector_get(
struct brotoIS*,*sourceIS,i);
4805 memcpy(isd,iss,
sizeof(
struct brotoIS));
4807 stack_push(
struct brotoIS*, *destIS, isd);
4816 for(i=0;i<IStable->n;i++)
4819 if(target == record->node){
4820 if(ifield == record->ifield && source == record->source){
4837 defs = globalParser->brotoDEFedNodes;
4841 globalParser->brotoDEFedNodes = defs;
4847 n = vectorSize(defnames);
4851 def2->name = def->name;
4852 def2->node = p2p_lookup(def->node, p2p);
4857char *broto_getNameFromNode(
struct X3D_Node* node)
4864 defs = globalParser->brotoDEFedNodes;
4868 n = vectorSize(defs);
4871 if(def->node == node){
4891 isMF = typeIndex % 2;
4892 sftype = typeIndex - isMF;
4895 isize = sizeofSForMF(sftype);
4902 deleteMallocedFieldValue(typeIndex,dest);
4905 if( sftype == FIELDTYPE_SFNode ) nele = (int) upper_power_of_two(nele);
4909 mfd->p = MALLOC (
struct X3D_Node **, isize*nele);
4910 bzero(mfd->p,isize*nele);
4912 ps = (
char *)mfs->p;
4913 pd = (
char *)mfd->p;
4914 for(i=0;i<mfs->n;i++)
4916 copy_field(sftype,(
union anyVrml*)ps,(
union anyVrml*)pd,p2p,instancedScripts,ctx,parent);
4926 case FIELDTYPE_SFNode:
4929 deep_copy_node(&source->sfnode,&dest->sfnode,p2p,instancedScripts,ctx);
4930 add_parent(dest->sfnode,parent,__FILE__,__LINE__);
4932 dest->sfnode = NULL;
4936 case FIELDTYPE_SFString:
4939 deleteMallocedFieldValue(typeIndex,dest);
4943 sd->strptr = STRDUP((*ss)->strptr);
4944 dest->sfstring = sd;
4949 memcpy(dest,source,isize);
4991 p->__children.n = 0;
4992 p->__children.p = NULL;
4993 parent = (
struct X3D_Node*) (*dest);
4994 prototype = (
struct X3D_Proto*)(*proto)->__prototype;
5000 copy_IStable((
Stack **) &(prototype->__IS), (
Stack **) &(p->__IS));
5003 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(prototype->__children),(
union anyVrml*)&(p->__children),
5004 p2p,instancedScripts,p,parent);
5006 copy_routes(prototype->__ROUTES, p, p2p);
5008 copy_defnames(prototype->__DEFnames, p, p2p);
5011 copy_IS(p->__IS, p, p2p);
5022void shallow_copy_field(
int typeIndex,
union anyVrml* source,
union anyVrml* dest)
5028 isMF = typeIndex % 2;
5029 sftype = typeIndex - isMF;
5032 isize = sizeofSForMF(sftype);
5040 if(mfs->p != mfd->p){
5042 deleteMallocedFieldValue(typeIndex,dest);
5044 if( sftype == FIELDTYPE_SFNode ) nele = (int) upper_power_of_two(nele);
5049 mfd->p = MALLOC (
struct X3D_Node **, isize*nele);
5050 bzero(mfd->p,isize*nele);
5052 ps = (
char *)mfs->p;
5053 pd = (
char *)mfd->p;
5054 for(i=0;i<mfs->n;i++)
5056 shallow_copy_field(sftype,(
union anyVrml*)ps,(
union anyVrml*)pd);
5066 case FIELDTYPE_SFString:
5071 deleteMallocedFieldValue(typeIndex,dest);
5076 sd->strptr = STRDUP((*ss)->strptr);
5077 dest->sfstring = sd;
5084 memcpy(dest,source,isize);
5090int PKW_from_KW(
int KW_index)
5097 case KW_initializeOnly:
5098 pkw = PKW_initializeOnly;
break;
5100 pkw = PKW_inputOnly;
break;
5102 pkw = PKW_outputOnly;
break;
5103 case KW_inputOutput:
5104 pkw = PKW_inputOutput;
break;
5106 pkw = PKW_field;
break;
5108 pkw = PKW_eventIn;
break;
5110 pkw = PKW_eventOut;
break;
5111 case KW_exposedField:
5112 pkw = PKW_exposedField;
break;
5118BOOL isManagedField(
int mode,
int type, BOOL isPublic);
5119void registerParentIfManagedField(
int type,
int mode, BOOL isPublic,
union anyVrml* any,
struct X3D_Node* parent)
5128 if(isManagedField(mode,type,isPublic))
5130 int n,k,haveSomething;
5132 haveSomething = (type==FIELDTYPE_SFNode && any->sfnode) || (type==FIELDTYPE_MFNode && any->mfnode.n);
5133 haveSomething = haveSomething && parent;
5135 if(type==FIELDTYPE_SFNode){
5136 plist = &any->sfnode;
5139 plist = any->mfnode.p;
5146 if( !sfn->_parentVector)
5147 sfn->_parentVector = newVector(
struct X3D_Node*,2);
5148 vector_pushBack(
struct X3D_Node*, sfn->_parentVector, parent);
5154void freeMallocedNodeFields(
struct X3D_Node* node);
5156void freePublicBuiltinNodeFields(
struct X3D_Node* node);
5157void **shaderFields(
struct X3D_Node* node);
5163 void **shaderfield = NULL;
5164 if(*source == NULL){
5168 *dest = inPointerTable(*source,p2p);
5175 if((*source)->_nodeType == NODE_Proto){
5176 *dest = X3D_NODE(brotoInstance(X3D_PROTO(X3D_PROTO(*source)->__prototype),ciflag_get(ctx->__protoFlags,0)));
5178 *dest=X3D_NODE(createNewX3DNode( (*source)->_nodeType));
5180 add_node_to_broto_context(ctx,(*dest));
5183 if((*source)->_nodeType == NODE_Script)
5184 stack_push(
struct X3D_Node*,instancedScripts,*dest);
5190 shaderfield = shaderFields(*source);
5205 offsets = (
fieldinfo)NODE_OFFSETS[(*source)->_nodeType];
5207 field = &offsets[ifield];
5209 while( field->nameIndex > -1)
5217 isrecord = in_IStable(*source,ifield,(
Stack *)ctx->__IS, is_source);
5218 if (isrecord != NULL)
5223 union anyVrml *source_field, *dest_field;
5226 sp = ctx->__protoDef;
5227 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5230 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5231 dest_field = (
union anyVrml*)&((
char*)*dest )[field->offset];
5233 shallow_copy_field(field->typeIndex, source_field, dest_field);
5234 registerParentIfManagedField(field->typeIndex,PKW_from_KW(field->ioType),1, dest_field, *dest);
5245 else if((*source)->_nodeType == NODE_Proto && !strcmp(FIELDNAMES[field->nameIndex],
"__protoDef") )
5261 dp = newProtoDefinition();
5270 for(k=0;k<sp->iface->n;k++)
5272 sdecl = protoDefinition_getFieldByNum(sp, k);
5273 ddecl = protoDefinition_getFieldByNum(dp, k);
5280 isrecord = in_IStable(*source,k,(
Stack *)ctx->__IS, is_source);
5281 if (isrecord != NULL)
5286 union anyVrml *source_field, *dest_field;
5289 sp = ctx->__protoDef;
5290 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5293 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5294 dest_field = (
union anyVrml*)&(ddecl->defaultVal);
5300 shallow_copy_field(sdecl->type, source_field, dest_field);
5301 registerParentIfManagedField(sdecl->type,sdecl->mode,1, dest_field, *dest);
5302 ddecl->alreadySet = sdecl->alreadySet;
5308 if(sdecl->mode == PKW_initializeOnly || sdecl->mode == PKW_inputOutput){
5310 union anyVrml *source_field, *dest_field;
5311 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5312 dest_field = (
union anyVrml*)&(ddecl->defaultVal);
5313 copy_field(sdecl->type,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5314 ddecl->alreadySet = sdecl->alreadySet;
5322 else if((*source)->_nodeType == NODE_Script && !strcmp(FIELDNAMES[field->nameIndex],
"__scriptObj") )
5333 sp = s->__scriptObj;
5334 dp = d->__scriptObj = new_Shader_ScriptB(*dest);
5335 dp->loaded = sp->loaded;
5337 sfields = sp->fields;
5338 for(k=0;k<sfields->n;k++)
5344 bzero(dfield->fieldDecl,
sizeof(
struct FieldDecl));
5348 isrecord = in_IStable(*source,k,(
Stack *)ctx->__IS, is_source);
5349 isInitialize = isrecord && (isrecord->mode == PKW_initializeOnly || isrecord->mode == PKW_inputOutput);
5355 union anyVrml *source_field, *dest_field;
5359 sp = ctx->__protoDef;
5360 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5361 if(sdecl->fieldString)
5362 dfield->ASCIIvalue = STRDUP(sdecl->fieldString);
5363 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5371 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5372 dest_field = (
union anyVrml*)&(dfield->value);
5374 shallow_copy_field(sdecl->type, source_field, dest_field);
5375 registerParentIfManagedField(sdecl->type, sdecl->mode, 1, dest_field, *dest);
5378 if(sfield->ASCIIvalue)
5379 dfield->ASCIIvalue = STRDUP(sfield->ASCIIvalue);
5381 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5384 dfield->value = sfield->value;
5388 if(sfield->fieldDecl->PKWmode == PKW_initializeOnly || sfield->fieldDecl->PKWmode == PKW_inputOutput){
5389 union anyVrml *source_field, *dest_field;
5390 source_field = (
union anyVrml*)&(sfield->value);
5391 dest_field = (
union anyVrml*)&(dfield->value);
5392 copy_field(dfield->fieldDecl->fieldType,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5394 dfield->valueSet = sfield->valueSet;
5399 else if(shaderfield && !strcmp(FIELDNAMES[field->nameIndex],
"_shaderUserDefinedFields") )
5416 void **dshaderfield;
5421 dshaderfield = shaderFields(*dest);
5423 dp = new_Shader_ScriptB(*dest);
5424 (*dshaderfield) = (
void*) dp;
5425 dp->loaded = sp->loaded;
5427 sfields = sp->fields;
5428 for(k=0;k<sfields->n;k++)
5434 bzero(dfield->fieldDecl,
sizeof(
struct FieldDecl));
5438 isrecord = in_IStable(*source,k,(
Stack *)ctx->__IS, is_source);
5439 isInitialize = isrecord && (isrecord->mode == PKW_initializeOnly || isrecord->mode == PKW_inputOutput);
5445 union anyVrml *source_field, *dest_field;
5449 sp = ctx->__protoDef;
5450 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5451 if(sdecl->fieldString)
5452 dfield->ASCIIvalue = STRDUP(sdecl->fieldString);
5453 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5461 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5462 dest_field = (
union anyVrml*)&(dfield->value);
5464 shallow_copy_field(sdecl->type, source_field, dest_field);
5465 registerParentIfManagedField(sdecl->type, sdecl->mode, 1, dest_field, *dest);
5468 if(sfield->ASCIIvalue)
5469 dfield->ASCIIvalue = STRDUP(sfield->ASCIIvalue);
5471 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5474 dfield->value = sfield->value;
5478 if(sfield->fieldDecl->PKWmode == PKW_initializeOnly || sfield->fieldDecl->PKWmode == PKW_inputOutput){
5479 union anyVrml *source_field, *dest_field;
5480 source_field = (
union anyVrml*)&(sfield->value);
5481 dest_field = (
union anyVrml*)&(dfield->value);
5482 copy_field(dfield->fieldDecl->fieldType,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5484 dfield->valueSet = sfield->valueSet;
5491 if( FIELDNAMES[field->nameIndex][0] !=
'_'){
5492 union anyVrml *source_field, *dest_field;
5493 source_field = (
union anyVrml*)&((
char*)*source)[field->offset];
5494 dest_field = (
union anyVrml*)&((
char*)*dest )[field->offset];
5502 copy_field(field->typeIndex,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5506 field = &offsets[ifield];
5509 if((*source)->_nodeType == NODE_Proto)
5515 unsigned char pdepthflag;
5516 pdest = X3D_PROTO(*dest);
5519 pdepthflag = ciflag_get(ctx->__protoFlags,0);
5520 pdest->__protoFlags = ciflag_set(pdest->__protoFlags,pdepthflag,0);
5525int nextScriptHandle (
void);
5532 ss->num = nextScriptHandle();
5536 for(j=0;j<ss->fields->n;j++)
5551 script_initCodeFromMFUri(ss, url);
5554void initialize_scripts(
Stack *instancedScripts)
5583 if(instancedScripts)
5592 n = instancedScripts->n;
5595 p = vector_get(
struct X3D_Node*,instancedScripts,i);
5598 ss = sn->__scriptObj;
5600 initialize_one_script(ss,&sn->url);
5605 ss->num = nextScriptHandle();
5609 for(j=0;j<ss->fields->n;j++)
5615 scriptFieldDecl_jsFieldInit(field, ss->num);
5623 script_initCodeFromMFUri(ss, &sn->url);
5658 struct X3D_Proto *scenePlaceholderProto;
5663 children = childrenField(sceneInstance);
5666 parent = (
struct X3D_Node*)sceneInstance;
5667 scenePlaceholderProto = createNewX3DNode0(NODE_Proto);
5675 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(sceneProto->__children),(
union anyVrml*)children,
5676 p2p,instancedScripts,scenePlaceholderProto,parent);
5679 copy_routes(sceneProto->__ROUTES, NULL, p2p);
5681 copy_IS(sceneProto->__IS, NULL, p2p);
5683 copy_defnames(sceneProto->__DEFnames, NULL, p2p);
5685 initialize_scripts(instancedScripts);
5733BOOL nodeTypeSupportsUserFields(
struct X3D_Node *node)
5736 user = node->_nodeType == NODE_Proto || node->_nodeType == NODE_Script ||
5737 node->_nodeType == NODE_ComposedShader || node->_nodeType == NODE_ShaderProgram ||
5738 node->_nodeType == NODE_PackagedShader || node->_nodeType == NODE_Effect ? TRUE : FALSE;
5743const char *rootFieldName(
const char* fieldname,
int* len,
int *has_changed,
int *has_set)
5750 static char* str_changed =
"_changed";
5752 static int len_changed = 8;
5753 static int len_set = 4;
5758 ln = (int) strlen(fieldname);
5760 *has_changed = ln > len_changed ? !strncmp(&fieldname[ln-len_changed],str_changed,len_changed) : FALSE;
5761 *has_set = ln > len_set ? !strncmp(fieldname,
"set_",len_set) : FALSE;
5762 s = *has_set ? &fieldname[len_set] : fieldname;
5763 *len = *has_changed? (int)(&fieldname[ln - len_changed] - s) : (int)(&fieldname[ln] - s);
5766BOOL fieldSynonymCompare(
const char *routeFieldName,
const char* nodeFieldName)
5771 int lr,hsr,hcr,ln,hsn,hcn;
5772 const char *rf, *nf;
5774 if(!strcmp(routeFieldName,nodeFieldName) )
return FALSE;
5777 rf = rootFieldName(routeFieldName,&lr,&hsr,&hcr);
5778 nf = rootFieldName(nodeFieldName, &ln,&hsn,&hcn);
5780 if(lr != ln)
return TRUE;
5781 if(strncmp(rf,nf,lr))
return TRUE;
5804 case PKW_initializeOnly:
5805 iret = PKW_initializeOnly;
break;
5806 case PKW_exposedField:
5807 case PKW_inputOutput:
5808 iret = PKW_inputOutput;
break;
5811 iret = PKW_inputOnly;
break;
5813 case PKW_outputOnly:
5814 iret = PKW_outputOnly;
break;
5816 printf(
"ouch from X3DMODE\n");
5822BOOL walk_fields(
struct X3D_Node* node,
int (*callbackFunc)(),
void* callbackData);
5824BOOL walk_fields(
struct X3D_Node* node, BOOL (*callbackFunc)(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
5825 const char *fieldName, indexT mode, indexT type,
int isource,BOOL publicfield),
void* callbackData);
5837BOOL cbExactName(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
5841 found = !strcmp(fieldName,cbd->fname);
5843 cbd->fieldValue = fieldPtr;
5844 cbd->fname = fieldName;
5845 cbd->jfield = jfield;
5848 cbd->publicfield = publicfield;
5849 cbd->source = source;
5854 int *imode,
int *itype,
char* nodeFieldName,
int *isource,
void** fdecl,
int *ifield)
5858 cbd.fname = nodeFieldName;
5859 found = walk_fields(node,cbExactName,&cbd);
5861 *anyptr = cbd.fieldValue;
5864 *isource = cbd.source;
5865 *ifield = cbd.jfield;
5882BOOL cbRootNameAndRouteDir(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
5887 found = !fieldSynonymCompare(fieldName,cbd->fname) ? TRUE : FALSE;
5888 found = found && (mode == cbd->PKW_eventType || mode == PKW_inputOutput);
5890 cbd->fname = fieldName;
5891 cbd->jfield = jfield;
5894 cbd->publicfield = publicfield;
5895 cbd->source = source;
5899BOOL cbExactNameAndRouteDir(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
5904 found = !strcmp(fieldName,cbd->fname) ? TRUE : FALSE;
5905 found = found && (mode == cbd->PKW_eventType || mode == PKW_inputOutput);
5907 cbd->fname = fieldName;
5908 cbd->jfield = jfield;
5911 cbd->publicfield = publicfield;
5912 cbd->source = source;
5916BOOL find_anyfield_by_nameAndRouteDir(
struct X3D_Node* node,
union anyVrml **anyptr,
5917 int *imode,
int *itype,
char* nodeFieldName,
int *isource,
void** fdecl,
int *ifield,
int PKW_eventType)
5921 cbd.fname = nodeFieldName;
5922 cbd.PKW_eventType = PKW_eventType;
5923 found = walk_fields(node,cbExactNameAndRouteDir,&cbd);
5925 found = walk_fields(node,cbRootNameAndRouteDir,&cbd);
5927 *anyptr = cbd.fieldValue;
5930 *isource = cbd.source;
5931 *ifield = cbd.jfield;
5937BOOL cbCountFields(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
5940 int *count = (
int*)callbackData;
5944int count_fields(
struct X3D_Node* node)
5949 walk_fields(node,cbCountFields,&count);
5953void **shaderFields(
struct X3D_Node* node);
5955int getFieldFromNodeAndName0(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
5956 int *iifield,
int *builtIn,
union anyVrml **value,
int *iunca,
const char **cname){
5965 shaderfield = shaderFields(node);
5968 if(node->_nodeType == NODE_Script)
5980 sfields = sp->fields;
5981 for(k=0;k<sfields->n;k++)
5986 fdecl = sfield->fieldDecl;
5987 fieldName = fieldDecl_getShaderScriptName(fdecl);
5988 if(!strcmp(fieldName,fieldname)){
5989 *type = fdecl->fieldType;
5990 *kind = fdecl->PKWmode;
5991 *value = &(sfield->value);
5999 else if(shaderfield)
6009 sfields = sp->fields;
6010 for(k=0;k<sfields->n;k++)
6015 fdecl = sfield->fieldDecl;
6016 fieldName = fieldDecl_getShaderScriptName(fdecl);
6017 if(!strcmp(fieldName,fieldname)){
6018 *type = fdecl->fieldType;
6019 *kind = fdecl->PKWmode;
6020 *value = &(sfield->value);
6027 }
else if(node->_nodeType == NODE_Proto) {
6034 for(k=0; k!=vectorSize(pstruct->iface); ++k)
6036 const char *fieldName;
6039 fieldName = pfield->cname;
6040 if(!strcmp(fieldName,fieldname)){
6041 *type = pfield->type;
6042 *kind = pfield->mode;
6043 if(pfield->mode == PKW_initializeOnly || pfield->mode == PKW_inputOutput)
6044 *value = &(pfield->defaultVal);
6069 offsets = (
fieldinfo)NODE_OFFSETS[node->_nodeType];
6071 field = &offsets[ifield];
6072 while( field->nameIndex > -1)
6074 if(!strcmp(FIELDNAMES[field->nameIndex],fieldname)){
6076 *type = field->typeIndex;
6078 switch(field->ioType){
6079 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6080 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6081 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6082 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6087 *value = (
union anyVrml*)&((
char*)node)[field->offset];
6088 *iunca = field->unca;
6089 *cname = FIELDNAMES[field->nameIndex];
6093 field = &offsets[ifield];
6098int getFieldFromNodeAndNameU(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
int* builtIn,
union anyVrml **value,
int *iunca,
const char **cname){
6100 ifound = getFieldFromNodeAndName0(node,fieldname,type,kind,iifield,builtIn,value,iunca,cname);
6104 nf = rootFieldName(fieldname, &ln,&hcn,&hsn);
6108 ifound = getFieldFromNodeAndName0(node,nf,type,kind,iifield,builtIn,value,iunca,cname);
6113 char rootname[MAXJSVARIABLELENGTH];
6114 memcpy(rootname,fieldname,ln);
6115 rootname[ln] =
'\0';
6116 ifound = getFieldFromNodeAndName0(node,rootname,type,kind,iifield,builtIn,value,iunca,cname);
6121int getFieldFromNodeAndName(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
union anyVrml **value){
6125 const char *cname = NULL;
6126 ifound = getFieldFromNodeAndNameU(node,fieldname,type,kind,iifield,&builtIn,value,&iunca,&cname);
6129int getFieldFromNodeAndNameC(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
int *builtIn,
union anyVrml **value,
const char **cname){
6132 ifound = getFieldFromNodeAndNameU(node,fieldname,type,kind,iifield,builtIn,value,&iunca,cname);
6136int getFieldFromNodeAndIndex(
struct X3D_Node* node,
int ifield,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value){
6142 if(node->_nodeType == NODE_Script )
6156 sfields = sp->fields;
6159 if(k > -1 && k < sfields->n)
6163 fdecl = sfield->fieldDecl;
6164 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6165 *type = fdecl->fieldType;
6166 *kind = fdecl->PKWmode;
6167 *value = &(sfield->value);
6171 }
else if(node->_nodeType == NODE_Proto ) {
6179 if(k > -1 && k < vectorSize(pstruct->iface))
6183 *fieldname = pfield->cname;
6184 *type = pfield->type;
6185 *kind = pfield->mode;
6186 if(pfield->mode == PKW_initializeOnly || pfield->mode == PKW_inputOutput)
6187 *value = &(pfield->defaultVal);
6210 offsets = (
fieldinfo)NODE_OFFSETS[node->_nodeType];
6213 if(kfield >= offsets[0].offset){
6215 while(offsets[k].nameIndex > -1){
6216 if(ifield == offsets[k].offset){
6223 for(k=0;k<=kfield;k++)
6224 if(offsets[k].nameIndex == -1)
return 0;
6225 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6226 *type = offsets[kfield].typeIndex;
6228 switch(offsets[kfield].ioType){
6229 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6230 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6231 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6232 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6235 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6240int getFieldFromNodeAndIterator(
struct X3D_Node* node,
int ifield,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value,
int *builtIn){
6247 if(node->_nodeType == NODE_Script )
6261 sfields = sp->fields;
6265 if(k > -1 && k < nuser)
6269 fdecl = sfield->fieldDecl;
6270 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6271 *type = fdecl->fieldType;
6272 *kind = fdecl->PKWmode;
6273 *value = &(sfield->value);
6278 }
else if(node->_nodeType == NODE_Proto ) {
6286 nuser = vectorSize(pstruct->iface);
6287 if(k > -1 && k < nuser)
6291 *fieldname = pfield->cname;
6292 *type = pfield->type;
6293 *kind = pfield->mode;
6295 if(pfield->mode == PKW_initializeOnly || pfield->mode == PKW_inputOutput)
6296 *value = &(pfield->defaultVal);
6316 int kfield, nbuiltin;
6319 offsets = (
fieldinfo)NODE_OFFSETS[node->_nodeType];
6322 kfield = ifield - nuser;
6323 for(k=0;k<=kfield;k++)
6324 if(offsets[k].nameIndex == -1)
return -1;
6325 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6326 *type = offsets[kfield].typeIndex;
6329 switch(offsets[kfield].ioType){
6330 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6331 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6332 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6333 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6336 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6342int getFieldFromNodeAndIndexSource(
struct X3D_Node* node,
int ifield,
int builtIn,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value){
6349 if(node->_nodeType == NODE_Script && !builtIn)
6363 sfields = sp->fields;
6367 if(k > -1 && k < nuser)
6371 fdecl = sfield->fieldDecl;
6372 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6373 *type = fdecl->fieldType;
6374 *kind = fdecl->PKWmode;
6375 *value = &(sfield->value);
6379 }
else if(node->_nodeType == NODE_Proto && !builtIn ) {
6387 nuser = vectorSize(pstruct->iface);
6388 if(k > -1 && k < nuser)
6392 *fieldname = pfield->cname;
6393 *type = pfield->type;
6394 *kind = pfield->mode;
6395 if(pfield->mode == PKW_initializeOnly || pfield->mode == PKW_inputOutput)
6396 *value = &(pfield->defaultVal);
6419 offsets = (
fieldinfo)NODE_OFFSETS[node->_nodeType];
6423 if(kfield >= offsets[0].offset){
6425 while(offsets[k].nameIndex > -1){
6426 if(ifield == offsets[k].offset){
6433 for(k=0;k<=kfield;k++)
6434 if(offsets[k].nameIndex == -1)
return -1;
6435 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6436 *type = offsets[kfield].typeIndex;
6438 switch(offsets[kfield].ioType){
6439 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6440 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6441 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6442 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6445 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6452void broto_store_IS(
struct X3D_Proto *proto,
char *protofieldname,
int pmode,
int iprotofield,
int pBuiltIn,
int type,
6453 struct X3D_Node *node,
char* nodefieldname,
int mode,
int ifield,
int nBuiltIn,
int source)
6460 is->protofieldname = strdup(protofieldname);
6462 is->iprotofield = iprotofield;
6463 is->pBuiltIn = pBuiltIn;
6466 is->nodefieldname = strdup(nodefieldname);
6468 is->ifield = ifield;
6469 is->builtIn = nBuiltIn;
6470 is->source = source;
6474 ISs = newStack(
struct brotoIS *);
6477 stack_push(
struct brotoIS *, ISs, is);
6491 int source, builtIn, pbuiltIn;
6492 int ifield, iprotofield;
6495 char *protoFieldName;
6496 char *nodeFieldName;
6499 BOOL foundProtoField;
6504 const char* pname = NULL;
6511 if(!lexer_setCurID(me->lexer))
return FALSE;
6512 ASSERT(me->lexer->curID);
6513 nodeFieldName = STRDUP(me->lexer->curID);
6515 FREE_IF_NZ(me->lexer->curID);
6530 foundField = find_anyfield_by_name(me->lexer, node, &fieldPtr, &mode, &type, nodeFieldName, &source, &fdecl, &ifield);
6535 FREE_IF_NZ(nodeFieldName);
6541 if(!lexer_keyword(me->lexer, KW_IS)) {
6543 FREE_IF_NZ(nodeFieldName);
6550 if(!lexer_setCurID(me->lexer))
return FALSE;
6551 ASSERT(me->lexer->curID);
6552 protoFieldName = STRDUP(me->lexer->curID);
6553 FREE_IF_NZ(me->lexer->curID);
6569 foundProtoField = FALSE;
6574 const char* pname = NULL;
6577 if(!strcasecmp(protoFieldName,
"metadata")){
6579 foundProtoField = getFieldFromNodeAndNameC(X3D_NODE(proto),protoFieldName,&ptype, &pmode, &iprotofield, &pbuiltIn, &defaultPtr, &pname);
6581 for(i=0; i!=vectorSize(pdef->iface); ++i)
6586 foundProtoField = !strcmp(pname,protoFieldName) ? TRUE : FALSE;
6587 if(foundProtoField ) {
6594 defaultPtr = &f->defaultVal;
6599 if( !foundProtoField ){
6600 ConsoleMessage(
"Parser error: no matching protoField for %s IS %s\n",
6601 nodeFieldName,protoFieldName);
6602 FREE_IF_NZ(me->lexer->curID);
6604 FREE_IF_NZ(nodeFieldName);
6605 FREE_IF_NZ(protoFieldName);
6610 if(!pname) pname =
"";
6611 ConsoleMessage(
"Parser error: IS - we have a name match: %s IS %s found protofield %s\n",
6612 nodeFieldName,protoFieldName,pname);
6613 ConsoleMessage(
"...But the types don't match: nodefield %s protofield %s\n",
6614 FIELDTYPES[type],FIELDTYPES[ptype]);
6615 FREE_IF_NZ(me->lexer->curID);
6617 FREE_IF_NZ(nodeFieldName);
6618 FREE_IF_NZ(protoFieldName);
6633 if(X3DMODE(mode) != PKW_inputOutput && X3DMODE(mode) != X3DMODE(pmode)){
6634 if(X3DMODE(pmode) != PKW_inputOutput){
6635 ConsoleMessage(
"Parser Error: IS - we have a name match: %s IS %s found protofield %s\n",
6636 nodeFieldName,protoFieldName,f->fieldString);
6637 ConsoleMessage(
"...But the modes don't jive: nodefield %s protofield %s\n",
6638 PROTOKEYWORDS[mode],PROTOKEYWORDS[pmode]);
6639 FREE_IF_NZ(me->lexer->curID);
6641 FREE_IF_NZ(nodeFieldName);
6642 FREE_IF_NZ(protoFieldName);
6645 ConsoleMessage(
"Parser Warning: IS - we have a name match: %s IS %s found protofield %s\n",
6646 nodeFieldName,protoFieldName,pname);
6647 ConsoleMessage(
"...But the modes don't jive: nodefield %s protofield %s\n",
6648 PROTOKEYWORDS[mode],PROTOKEYWORDS[pmode]);
6649 ConsoleMessage(
"...will thunk\n");
6656 if(X3DMODE(pmode) == PKW_initializeOnly || X3DMODE(pmode) == PKW_inputOutput)
6667 shallow_copy_field(type, defaultPtr , fieldPtr);
6680 builtIn = source ? FALSE : TRUE;
6681 broto_store_IS(proto,protoFieldName,X3DMODE(f->mode),iprotofield,pbuiltIn,type,
6682 node,nodeFieldName,X3DMODE(mode),ifield,builtIn,source);
6691 FREE_IF_NZ(nodeFieldName);
6692 FREE_IF_NZ(protoFieldName);
6710 ulr = librarySearch(res->URLrequest);
6711 if(ulr)
return ulr->three;
6717#define LOAD_INITIAL_STATE 0
6718#define LOAD_REQUEST_RESOURCE 1
6719#define LOAD_FETCHING_RESOURCE 2
6721#define LOAD_STABLE 10
6750void load_externProtoDeclare (
struct X3D_Proto *node) {
6755 char flagInstance, flagExtern;
6756 flagInstance = ciflag_get(node->__protoFlags,2);
6757 flagExtern = ciflag_get(node->__protoFlags,3);
6758 if(flagInstance == 0 && flagExtern == 1) {
6761 switch (node->__loadstatus) {
6762 case LOAD_INITIAL_STATE:
6764 if (node->url.n == 0) {
6765 node->__loadstatus = LOAD_STABLE;
6768 res = resource_create_multi(&(node->url));
6769 res->media_type = resm_unknown;
6770 node->__loadstatus = LOAD_REQUEST_RESOURCE;
6771 node->__loadResource = res;
6775 case LOAD_REQUEST_RESOURCE:
6776 res = node->__loadResource;
6777 resource_identify(node->_parentResource, res);
6778 node->__afterPound = (
void*)res->afterPoundCharacters;
6781 if(node->__afterPound)
6782 res2 = resLibraryAlreadyRequested(res);
6784 node->__loadResource = res2;
6789 res->actions = resa_download | resa_load;
6790 pushInputResource(res);
6791 libraryScene = createNewX3DNode0(NODE_Proto);
6793 res->ectx = (
void*)libraryScene;
6794 res->whereToPlaceData = X3D_NODE(libraryScene);
6795 res->offsetFromWhereToPlaceData = offsetof (
struct X3D_Proto, __children);
6796 addLibrary(res->URLrequest,libraryScene,res);
6797 resitem_enqueue(ml_new(res));
6799 node->__loadstatus = LOAD_FETCHING_RESOURCE;
6802 case LOAD_FETCHING_RESOURCE:
6803 res = node->__loadResource;
6807 if (res->status == ress_loaded) {
6808 res->actions = resa_process;
6809 res->complete = FALSE;
6810 resitem_enqueue(ml_new(res));
6811 }
else if ((res->status == ress_failed) || (res->status == ress_invalid)) {
6813 printf (
"resource failed to load\n");
6814 node->__loadstatus = LOAD_STABLE;
6815 }
else if (res->status == ress_parsed) {
6818 struct X3D_Proto *libraryScene = res->whereToPlaceData;
6819 if(node->__externProtoDeclares == NULL)
6820 node->__externProtoDeclares = newVector(
struct X3D_Proto*,1);
6821 vector_pushBack(
struct X3D_Proto*,node->__externProtoDeclares,libraryScene);
6823 if(node->__externProtoDeclares){
6824 int n = vectorSize(node->__externProtoDeclares);
6826 struct X3D_Proto *libraryScene = vector_get(
struct X3D_Proto*,node->__externProtoDeclares,0);
6827 if(libraryScene->__protoDeclares){
6828 int m = vectorSize(libraryScene->__protoDeclares);
6835 if(node->__afterPound){
6837 char *
typename, *matchstring;
6839 matchstring = node->__afterPound;
6840 pDefinition = vector_get(
struct X3D_Proto*,libraryScene->__protoDeclares,k);
6841 typename = (
char *)pDefinition->__typename;
6843 if(!strcmp(matchstring,
typename)){
6846 node->__protoDeclares = newVector(
struct X3D_Proto*,1);
6847 vector_pushBack(
struct X3D_Proto*,node->__protoDeclares,pDefinition);
6853 pDefinition = vector_get(
struct X3D_Proto*,libraryScene->__protoDeclares,0);
6854 node->__protoDeclares = newVector(
struct X3D_Proto*,1);
6855 vector_pushBack(
struct X3D_Proto*,node->__protoDeclares,pDefinition);
6861 node->__loadstatus = LOAD_STABLE;
6873void load_externProtoInstance (
struct X3D_Proto *node) {
6878 char flagInstance, flagExtern;
6879 flagInstance = ciflag_get(node->__protoFlags,2);
6880 flagExtern = ciflag_get(node->__protoFlags,3);
6881 if(flagInstance == 1 && flagExtern == 1) {
6883 if(node->__children.n)
return;
6884 pnode = (
struct X3D_Proto*)node->__prototype;
6886 if(pnode->__loadstatus != LOAD_STABLE){
6888 load_externProtoDeclare(pnode);
6890 if(pnode->__loadstatus == LOAD_STABLE){
6892 if(pnode->__protoDeclares){
6893 int n = vectorSize(pnode->__protoDeclares);
6897 pdeclare = vector_get(
struct X3D_Proto*,pnode->__protoDeclares,0);
6898 pinstance = brotoInstance(pdeclare,1);
6899 if (pinstance != NULL) {
6904 pushInputResource(pinstance->_parentResource);
6905 ed = node->__protoDef;
6907 pd = pinstance->__protoDef;
6909 add_node_to_broto_context(node,X3D_NODE(pinstance));
6914 char *ename, *pname;
6919 for(i=0;i<ei->n;i++){
6920 ef = protoDefinition_getFieldByNum(ed, i);
6922 for(j=0;j<pi->n;j++){
6923 pf = protoDefinition_getFieldByNum(pd, j);
6925 if(!strcmp(ename,pname) || !fieldSynonymCompare(ename,pname)){
6928 if(ef->type == pf->type){
6932 broto_store_IS(node,ef->cname,ef->mode, i, FALSE, ef->type, X3D_NODE(pinstance), pf->cname, pf->mode, j, FALSE, 3);
6941 p2pentry.pp = X3D_NODE(pinstance);
6942 p2pentry.pn = X3D_NODE(pinstance);
6944 copy_IS(node->__IS, node, p2p);
6953 for(i=0;i<istable->n;i++)
6957 is = vector_get(
struct brotoIS*, istable, i);
6958 if(is->pmode == PKW_inputOutput || is->pmode == PKW_initializeOnly){
6959 if(is->mode == PKW_inputOutput || is->mode == PKW_initializeOnly){
6960 ef = protoDefinition_getFieldByNum(ed, is->iprotofield);
6961 pf = protoDefinition_getFieldByNum(pd, is->ifield);
6962 if(ef->alreadySet ){
6964 shallow_copy_field(is->type, &ef->defaultVal, &pf->defaultVal);
6965 pf->alreadySet = TRUE;
6972 deep_copy_broto_body2(&pdeclare,&pinstance);
6973 nnode = X3D_NODE(pinstance);
6974 AddRemoveChildren(X3D_NODE(node), &node->__children, &nnode, 1, 1,__FILE__,__LINE__);
6975 add_parent(X3D_NODE(pinstance),X3D_NODE(node),__FILE__,__LINE__);
6995 if(context && hasContext(X3D_NODE(context))){
6997 if(!context->__nodes)
6998 context->__nodes = newVector(
struct X3D_Node*,4);
6999 __nodes = context->__nodes;
7000 node->_executionContext = (
struct X3D_Node*)context;
7001 stack_push(
struct X3D_Node*,__nodes,node);
7002 if(hasContext(node)){
7004 if(!context->__subcontexts)
7005 context->__subcontexts = newVector(
struct X3D_Node*,4);
7006 __subctxs = context->__subcontexts;
7007 stack_push(
struct X3D_Node*,__subctxs,node);
7011void remove_node_from_broto_context(
struct X3D_Proto *context,
struct X3D_Node *node){
7021 if(context && hasContext(X3D_NODE(context))){
7022 if(context->__nodes){
7024 for(i=0;i<vectorSize(context->__nodes);i++){
7027 vector_remove_elem(
struct X3D_Node*,context->__nodes,i);
7032 if(context->__subcontexts && hasContext(node) ){
7034 for(i=0;i<vectorSize(context->__subcontexts);i++){
7035 struct X3D_Node *ns = vector_get(
struct X3D_Node*,context->__subcontexts,i);
7037 vector_remove_elem(
struct X3D_Node*,context->__subcontexts,i);
7044void lock_and_do_routes_register();
7045int unregister_broutes(
struct X3D_Proto * node){
7048 if(node && hasContext(X3D_NODE(node))){
7049 unsigned char depthflag = ciflag_get(node->__protoFlags,0);
7055 for(i=0;i<vectorSize(node->__ROUTES);i++){
7056 route = vector_get(
struct brotoRoute*,node->__ROUTES,i);
7057 if(route && route->lastCommand){
7058 CRoutes_RemoveSimpleB(route->from.node,route->from.ifield,route->from.builtIn,route->to.node,route->to.ifield,route->to.builtIn,route->ft);
7059 route->lastCommand = 0;
7066 lock_and_do_routes_register();
7075void unRegisterTexture(
struct X3D_Node *tmp);
7076void unRegisterBindable (
struct X3D_Node *node);
7077void remove_OSCsensor(
struct X3D_Node * node);
7078void remove_picksensor(
struct X3D_Node * node);
7079void delete_first(
struct X3D_Node *node);
7080void removeNodeFromKeySensorList(
struct X3D_Node* node);
7081int unInitializeScript(
struct X3D_Node *node);
7082void delete_polyrep(
struct X3D_Node *node);
7083void unRegisterPolyRep(
struct X3D_Node *node);
7084void delete_glbuffers(
struct X3D_Node *node);
7085void unRegisterGeoElevationGrid(
struct X3D_Node *node);
7087int unRegisterX3DAnyNode(
struct X3D_Node *node){
7115 unRegisterTexture(node);
7117 unRegisterX3DNode(node);
7119 unRegisterBindable(node);
7121 unRegisterGeoElevationGrid(node);
7123 remove_OSCsensor(node);
7125 remove_picksensor(node);
7129 removeNodeFromKeySensorList(X3D_NODE(node));
7132 unInitializeScript(node);
7135 delete_polyrep(node);
7136 delete_glbuffers(node);
7139int print_broto_stats(
int level,
struct X3D_Proto *node){
7142 for(i=0;i<level;i++)
7144 spaces[level] =
'\0';
7145 nr = node->__ROUTES ? vectorSize(node->__ROUTES) : 0;
7146 nn = node->__nodes ? vectorSize(node->__nodes) : 0;
7147 nc = node->__subcontexts ? vectorSize(node->__subcontexts) : 0;
7149 printf(
"%sctx=%p routes=%d nodes=%d subcontexts=%d\n",spaces,node,nr,nn,nc);
7151 int nextlevel = level + 1;
7154 print_broto_stats(nextlevel,sc);
7160int unregister_broto_instance(
struct X3D_Proto* node){
7177 if(node && hasContext(X3D_NODE(node))){
7178 unsigned char depthflag = ciflag_get(node->__protoFlags,0);
7182 if(node->__subcontexts){
7184 for(i=0;i<vectorSize(node->__subcontexts);i++){
7186 unregister_broto_instance(subcontext);
7190 unregister_IStableRoutes((
Stack*)node->__IS, node);
7192 unregister_broutes(node);
7199 for(i=0;i<vectorSize(node->__nodes);i++){
7201 unRegisterX3DAnyNode(ns);
7202 broto_clear_DEF_by_node(node,ns);
7210int gc_broto_instance(
struct X3D_Proto* node){
7221 if(node && hasContext(X3D_NODE(node))){
7222 node->__children.n = 0;
7223 node->_sortedChildren.n = 0;
7224 if(node->__subcontexts){
7226 for(i=0;i<vectorSize(node->__subcontexts);i++){
7227 subctx = vector_get(
struct X3D_Proto*,node->__subcontexts,i);
7228 gc_broto_instance(subctx);
7230 deleteVector(
struct X3D_Proto*,node->__subcontexts);
7234 for(i=0;i<vectorSize(node->__ROUTES);i++){
7239 deleteVector(
struct brotoRoute *, node->__ROUTES);
7243 deleteVector(
struct X3D_Node *,node->__scripts);
7246 for(i=0;i<vectorSize(node->__IS);i++) {
7250 deleteVector(
struct brotoIS *,node->__IS);
7253 if(node->__DEFnames) {
7254 for(i=0;i<vectorSize(node->__DEFnames);i++) {
7256 FREE_IF_NZ(def.name);
7262 deleteVector(
struct EXIMPORT *,node->__IMPORTS);
7265 deleteVector(
struct EXIMPORT *,node->__EXPORTS);
7275 int crash_challenge = 1;
7276 if(crash_challenge) {
7277 for(i=0;i<vectorSize(node->__nodes);i++){
7278 nx = vector_get(
struct X3D_Node*,node->__nodes,i);
7279 freeMallocedNodeFields(nx);
7283 deleteVector(
struct X3D_Node *,node->__nodes);
7285 if(node->__protoDeclares){
7288 char flagInstance, flagExtern;
7289 flagInstance = ciflag_get(node->__protoFlags,2);
7290 flagExtern = ciflag_get(node->__protoFlags,3);
7291 if(!(flagExtern && !flagInstance))
7292 for(i=0;i<vectorSize(node->__protoDeclares);i++){
7293 subctx = vector_get(
struct X3D_Proto*,node->__protoDeclares,i);
7295 gc_broto_instance(subctx);
7296 freeMallocedNodeFields(X3D_NODE(subctx));
7299 deleteVector(
void*,node->__protoDeclares);
7301 if(node->__externProtoDeclares){
7304 char flagInstance, flagExtern;
7305 flagInstance = ciflag_get(node->__protoFlags,2);
7306 flagExtern = ciflag_get(node->__protoFlags,3);
7307 if(!(flagExtern && !flagInstance))
7308 for(i=0;i<vectorSize(node->__externProtoDeclares);i++){
7312 subctx = vector_get(
struct X3D_Proto*,node->__externProtoDeclares,i);
7313 gc_broto_instance(subctx);
7314 freeMallocedNodeFields(X3D_NODE(subctx));
7317 deleteVector(
void*,node->__externProtoDeclares);
7323int unload_broto(
struct X3D_Proto* node){
7346 if(node && hasContext(X3D_NODE(node))){
7348 unregister_broto_instance(node);
7349 gc_broto_instance(node);
7357 if(context && hasContext(X3D_NODE(context))){
7358 if(context->__ROUTES){
7360 nr = vectorSize(context->__ROUTES);
7364 route = vector_get(
struct brotoRoute*,context->__ROUTES,ii);
7365 if(route->from.node == node || route->to.node == node){
7366 if( route->lastCommand){
7367 CRoutes_RemoveSimpleB(route->from.node,route->from.ifield,route->from.builtIn, route->to.node,route->to.ifield,route->to.builtIn,route->ft);
7368 route->lastCommand = 0;
7370 vector_remove_elem(
struct X3D_Node*,context->__ROUTES,ii);
7382 if(context && hasContext(X3D_NODE(context))){
7383 if(node && hasContext(node))
7384 unload_broto(X3D_PROTO(node));
7385 unRegisterX3DAnyNode(node);
7386 unRegisterNodeRoutes(context,node);
7387 remove_node_from_broto_context(context,node);