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!
")
3871 /* Read the next line and parse it as an interface declaration. */
3872 /* Add the user-defined field name to the appropriate list of user-defined names (user_initializeOnly, user_inputOnly, Out, or user_inputOutput).
3873 Create a new protoFieldDecl for this field and add it to the iface vector for the ProtoDefinition obj.
3874 For fields and inputOutputs, get the default value of the field and store it in the protoFieldDecl. */
3875 while(parser_interfaceDeclaration(me, obj, NULL));
3877 /* Make sure that the next token is a ']'. Skip over it. */
3878 if(!lexer_closeSquare(me->lexer))
3879 PARSE_ERROR("Expected ] after interface declaration!
")
3882 //proto = new Proto() //off scenegraph storage please
3883 //proto.__protoDef = obj
3884 //contextParent.declared_protos.add(proto);
3885 //parser_proto_body(proto)
3886 //return NULL; //no scenegraph node created, or more precisely: nothing to link in to parent's children
3888 //create a ProtoDeclare
3889 proto = createNewX3DNode0(NODE_Proto);
3890 //add it to the current context's list of declared protos
3891 parent = (struct X3D_Proto*)me->ectx;
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); //me->ptr; //link back to parent proto, for isAvailableProto search
3898 proto->__protoFlags = parent->__protoFlags;
3899 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,0); //((char*)(&proto->__protoFlags))[0] = 0; //shallow instancing of protoInstances inside a protoDeclare
3901 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,2); //((char*)(&proto->__protoFlags))[2] = 0; //this is a protoDeclare we are parsing
3902 proto->__protoFlags = ciflag_set(proto->__protoFlags,1,3); //((char*)(&proto->__protoFlags))[3] = 1; //an externProtoDeclare
3903 //set ProtoDefinition *obj
3904 proto->__protoDef = obj;
3905 proto->__prototype = X3D_NODE(proto); //point to self, so shallow and deep instances will inherit this value
3906 proto->__typename = (void *)STRDUP(obj->protoName);
3907 proto->__unitlengthfactor = getunitlengthfactor();
3908 proto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
3910 /* EXTERNPROTO url */
3912 //struct Multi_String url;
3913 //unsigned char *buffer;
3915 //resource_item_t *res;
3917 /* get the URL string */
3918 if (!parser_mfstringValue(me,&proto->url)) {
3919 PARSE_ERROR ("EXTERNPROTO - problem reading URL string
");
3921 proto->__loadstatus = LOAD_INITIAL_STATE;
3922 /*the rest is done in load_externProto during rendering*/
3929/*Q. could/should brotoRoutes resolve to pointers early during parsing (as they are now)
3930 or late (by storing char* DEFNode, char* fieldname)?
3931 - late might help with Inline IMPORT/EXPORT, where routes are declared
3932 before the nodes appear.
3937// struct X3D_Node* fromNode;
3939// struct X3D_Node* toNode;
3943struct brotoRoute *createNewBrotoRoute();
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,
3950 struct brotoRoute* route;
3951 //struct X3D_Proto* protoDeclare = (struct X3D_Proto*)me->ptr;
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){
3970 routes = newStack(struct brotoRoute *);
3971 proto->__ROUTES = routes;
3973 stack_push(struct brotoRoute *, routes, route);
3983//void broto_store_ImportRoute_old(struct X3D_Proto* proto, char *fromNode, char *fromField, char *toNode, char* toField)
3985// struct ImportRoute* improute;
3986// if( proto->__IMPROUTES == NULL)
3987// proto->__IMPROUTES= newStack(struct ImportRoute *);
3988// improute = MALLOC(struct ImportRoute*,sizeof(struct ImportRoute));
3989// improute->fromNode = strdup(fromNode);
3990// improute->fromField = strdup(fromField);
3991// improute->toNode = strdup(toNode);
3992// improute->toField = strdup(toField);
3993// stack_push(struct ImportRoute *, proto->__IMPROUTES, improute);
3995void broto_store_ImportRoute_obsolete(struct X3D_Proto* proto, char *fromNode, char *fromField, char *toNode, char* toField)
3997 //there could be combinations of known/strong/node* and weak char* route ends - in that case split up this function
3998 struct brotoRoute* route;
3999 if( proto->__ROUTES == NULL)
4000 proto->__ROUTES= newStack(struct brotoRoute *);
4001 route = createNewBrotoRoute();
4003 route->lastCommand = 0; //not added to CRoutes until inline loaded
4004 route->from.weak = 2; //weak references to publish/from,subscribe/to ends not loaded yet
4005 route->from.cnode = STRDUP(fromNode);
4006 route->from.cfield = STRDUP(fromField);
4007 route->from.ftype = -1; //unknown
4009 route->to.cnode = STRDUP(toNode);
4010 route->to.cfield = STRDUP(toField);
4011 route->to.ftype = -1; //unknown
4012 stack_push(struct brotoRoute *, proto->__ROUTES, route);
4014struct brotoRoute *createNewBrotoRoute(){
4015 struct brotoRoute* route;
4016 route = MALLOC(struct brotoRoute*,sizeof(struct brotoRoute));
4017 memset(route,0,sizeof(struct brotoRoute));
4020void broto_store_broute(struct X3D_Proto* context,struct brotoRoute *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);
4029void free_broute(struct brotoRoute *route){
4030 free_brouteEnd(&route->from);
4031 free_brouteEnd(&route->to);
4033//BOOL route_parse_nodefield(pre, eventType)
4034//used by parser_routeStatement:
4036BOOL route_parse_nodefield(struct VRMLParser* me, int *NodeIndex, struct X3D_Node** Node, int KW_eventType,
4037 int *Ofs, int *fieldType, struct ScriptFieldDecl** ScriptField)
4039 int PKW_eventType = PKW_outputOnly;
4045 int ifield; //, iprotofield;
4046 char *nodeFieldName;
4049 union anyVrml *fieldPtr;
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);