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();
81 ppCParseParser p = (ppCParseParser)t->prv;
82 p->foundInputErrors = 0;
83 p->latest_protoDefNumber = 1;
89void resetParseSuccessfullyFlag(
void) {
90 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
91 p->foundInputErrors = 0;
93int parsedSuccessfully(
void) {
94 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
95 return p->foundInputErrors == 0;
150static BOOL parser_routeStatement(
struct VRMLParser*);
151static BOOL parser_componentStatement(
struct VRMLParser*);
152static BOOL parser_exportStatement(
struct VRMLParser*);
153static BOOL parser_importStatement(
struct VRMLParser*);
154static BOOL parser_metaStatement(
struct VRMLParser*);
155static BOOL parser_unitStatement(
struct VRMLParser*);
156static BOOL parser_profileStatement(
struct VRMLParser*);
159static BOOL parser_nodeStatement(
struct VRMLParser*, vrmlNodeT*);
160static BOOL parser_node(
struct VRMLParser*, vrmlNodeT*,
int);
165static BOOL parser_sffloatValue_ (
struct VRMLParser *,
void *);
166static BOOL parser_sfboolValue(
struct VRMLParser*,
void*);
167static BOOL parser_sfint32Value_ (
struct VRMLParser *,
void *);
168static BOOL parser_sftimeValue (
struct VRMLParser *,
void *);
169static BOOL parser_sfdoubleValue(
struct VRMLParser*,
void*);
170static BOOL parser_sfnodeValue (
struct VRMLParser *,
void *);
171static BOOL parser_sfcolorValue(
struct VRMLParser*,
void*);
172static BOOL parser_sfcolorrgbaValue(
struct VRMLParser*,
void*);
173static BOOL parser_sfrotationValue (
struct VRMLParser *,
void *);
174static BOOL parser_sfvec2fValue(
struct VRMLParser*,
void*);
175static BOOL parser_sfvec3fValue(
struct VRMLParser*,
void*);
176static BOOL parser_sfvec4fValue(
struct VRMLParser*,
void*);
177static BOOL parser_sfvec2dValue(
struct VRMLParser*,
void*);
178static BOOL parser_sfvec3dValue(
struct VRMLParser*,
void*);
179static BOOL parser_sfvec4dValue(
struct VRMLParser*,
void*);
180static BOOL parser_sfstringValue_(
struct VRMLParser*,
void*);
181static BOOL parser_sfimageValue(
struct VRMLParser*,
void*);
182static BOOL parser_sfmatrix3fValue (
struct VRMLParser *,
void *);
183static BOOL parser_sfmatrix4fValue (
struct VRMLParser *,
void *);
184static BOOL parser_sfmatrix3dValue (
struct VRMLParser *,
void *);
185static BOOL parser_sfmatrix4dValue (
struct VRMLParser *,
void *);
187static BOOL parser_mffloatValue(
struct VRMLParser*,
void*);
188static BOOL parser_mfboolValue(
struct VRMLParser*,
void*);
189static BOOL parser_mfint32Value(
struct VRMLParser*,
void*);
190static BOOL parser_mftimeValue(
struct VRMLParser*,
void*);
191static BOOL parser_mfdoubleValue(
struct VRMLParser*,
void*);
192static BOOL parser_mfnodeValue(
struct VRMLParser*,
void*);
193static BOOL parser_mfcolorValue(
struct VRMLParser*,
void*);
194static BOOL parser_mfcolorrgbaValue(
struct VRMLParser*,
void*);
195static BOOL parser_mfrotationValue(
struct VRMLParser*,
void*);
196static BOOL parser_mfvec2fValue(
struct VRMLParser*,
void*);
197static BOOL parser_mfvec3fValue(
struct VRMLParser*,
void*);
198static BOOL parser_mfvec4fValue(
struct VRMLParser*,
void*);
199static BOOL parser_mfvec2dValue(
struct VRMLParser*,
void*);
200static BOOL parser_mfvec3dValue(
struct VRMLParser*,
void*);
201static BOOL parser_mfvec4dValue(
struct VRMLParser*,
void*);
202static BOOL parser_mfstringValue(
struct VRMLParser*,
void*);
203static BOOL parser_mfimageValue(
struct VRMLParser*,
void*);
204static BOOL parser_mfmatrix3fValue(
struct VRMLParser*,
void*);
205static BOOL parser_mfmatrix4fValue(
struct VRMLParser*,
void*);
206static BOOL parser_mfmatrix3dValue(
struct VRMLParser*,
void*);
207static BOOL parser_mfmatrix4dValue(
struct VRMLParser*,
void*);
216static BOOL parser_fieldTypeNotParsedYet(
struct VRMLParser* me,
void* ret);
219BOOL (*PARSE_TYPE[])(
struct VRMLParser*,
void*)={
220 &parser_sffloatValue_, &parser_mffloatValue,
221 &parser_sfboolValue,&parser_mfboolValue,
222 &parser_sfint32Value_,&parser_mfint32Value,
223 &parser_sftimeValue,&parser_mftimeValue,
224 &parser_sfdoubleValue,&parser_mfdoubleValue,
225 &parser_sfnodeValue,&parser_mfnodeValue,
226 &parser_sfcolorValue,&parser_mfcolorValue,
227 &parser_sfcolorrgbaValue,&parser_mfcolorrgbaValue,
228 &parser_sfrotationValue, &parser_mfrotationValue,
229 &parser_sfvec2fValue,& parser_mfvec2fValue,
230 &parser_sfvec3fValue, &parser_mfvec3fValue,
231 &parser_sfvec4fValue,& parser_mfvec4fValue,
232 &parser_sfvec2dValue,& parser_mfvec2dValue,
233 &parser_sfvec3dValue,& parser_mfvec3dValue,
234 &parser_sfvec4dValue,& parser_mfvec4dValue,
235 &parser_sfstringValue_, &parser_mfstringValue,
236 &parser_sfimageValue, &parser_mfimageValue,
237 &parser_sfmatrix3fValue, &parser_mfmatrix3fValue,
238 &parser_sfmatrix4fValue, &parser_mfmatrix4fValue,
239 &parser_sfmatrix3dValue, &parser_mfmatrix3dValue,
240 &parser_sfmatrix4dValue, &parser_mfmatrix4dValue,
241 &parser_fieldTypeNotParsedYet,& parser_fieldTypeNotParsedYet,
249 ASSERT(PARSE_TYPE[type]);
252 if (type == ID_UNDEFINED)
return false;
254 return PARSE_TYPE[type](me, (
void*)defaultVal);
265struct ProtoFieldDecl* newProtoFieldDecl(indexT mode, indexT type, indexT name)
273 ret->alreadySet=FALSE;
274 ret->fieldString = NULL;
276 ret->scriptDests = NULL;
277 ret->defaultVal.mfnode.p = NULL;
278 ret->defaultVal.mfnode.n = 0;
283 ddecl = newProtoFieldDecl(sdecl->mode,sdecl->type,sdecl->name);
285 ddecl->cname = STRDUP(sdecl->cname);
288 shallow_copy_field(sdecl->type,&(sdecl->defaultVal),&(ddecl->defaultVal));
296void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr)
302 if(type == FIELDTYPE_FreeWRLPTR){
303 if(0) FREE_IF_NZ(fieldPtr->sfstring);
304 }
else if(type == FIELDTYPE_SFString){
307 us = fieldPtr->sfstring;
308 clearASCIIString(us);
309 FREE_IF_NZ(fieldPtr->sfstring);
311 }
else if(type == FIELDTYPE_MFString){
312 clearMFString(&fieldPtr->mfstring);
313 fieldPtr->mfstring.n = 0;
316 FREE_IF_NZ(fieldPtr->mfnode.p);
317 fieldPtr->mfnode.n = 0;
326 FREE_IF_NZ(me->cname);
327 FREE_IF_NZ(me->fieldString);
328 fieldPtr = &(me->defaultVal);
330 deleteMallocedFieldValue(type,fieldPtr);
346 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
361 ret->deconstructedProtoBody = NULL;
365 ret->protoDefNumber = p->latest_protoDefNumber++;
366 ret->estimatedBodyLen = 0;
367 ret->protoName = NULL;
369 ret->isExtern = FALSE;
377 for(i=0;i<vectorSize(ret->iface);i++) {
380 deleteProtoFieldDecl(iface);
385 FREE_IF_NZ(ret->protoName);
394 indexT ind, indexT mode)
399 if (!me)
return NULL;
400 for(i=0; i!=vectorSize(me->iface); ++i)
403 if(f->name==ind && f->mode==mode) {
421 if(node->_nodeType == NODE_Proto){
428void add_empty_proto_vectors(
struct X3D_Node* node) {
436 if (node->_nodeType != NODE_Proto && node->_nodeType != NODE_Inline)
return;
438 proto->__protoDeclares = newStack(
struct X3D_Proto*);
439 proto->__externProtoDeclares = newStack(
struct X3D_Proto*);
440 proto->__nodes = newStack(
struct X3D_Node*);
441 proto->__subcontexts = newStack(
struct X3D_Proto*);
447 proto->__ROUTES = newStack(
struct CRStruct*);
448 proto->__EXPORTS = newStack(
struct IMEXPORT*);
449 proto->__IMPORTS = newStack(
struct IMEXPORT*);
451 proto->__IS = newStack(
struct brotoIS*);
452 proto->__scripts = newStack(
struct X3D_Node*);
459struct VRMLParser* newParser(
void *ectx,
void* ptr,
unsigned ofs,
int parsingX3DfromXML) {
461 ret->lexer=newLexer();
467 ret->DEFedNodes = NULL;
469 ret->parsingX3DfromXML = parsingX3DfromXML;
470 ret->brotoDEFedNodes = NULL;
474struct VRMLParser* reuseParser(
void *ectx,
void* ptr,
unsigned ofs) {
501 deleteLexer(me->lexer);
506static void parser_scopeOut_DEFUSE();
507static void parser_scopeOut_PROTO();
516 while(!stack_empty(me->DEFedNodes))
517 parser_scopeOut_DEFUSE(me);
518 deleteStack(
struct Vector*, me->DEFedNodes);
521 ASSERT(!me->DEFedNodes);
527 while(!stack_empty(me->PROTOs))
528 parser_scopeOut_PROTO(me);
529 deleteStack(
struct Vector*, me->PROTOs);
534 lexer_destroyData(me->lexer);
538 zeroScriptHandles ();
543static void parser_scopeIn_DEFUSE(
struct VRMLParser* me)
546 me->DEFedNodes=newStack(
struct Vector*);
548 ASSERT(me->DEFedNodes);
549 stack_push(
struct Vector*, me->DEFedNodes,
550 newVector(
struct X3D_Node*, DEFMEM_INIT_SIZE));
551 ASSERT(!stack_empty(me->DEFedNodes));
562static void parser_scopeIn_PROTO(
struct VRMLParser* me)
569static void parser_scopeOut_DEFUSE(
struct VRMLParser* me)
571 ASSERT(!stack_empty(me->DEFedNodes));
573 deleteVector(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes));
574 stack_pop(
struct Vector*, me->DEFedNodes);
581static void parser_scopeOut_PROTO(
struct VRMLParser* me)
586 vector_popBackN(
struct ProtoDefinition*, me->PROTOs, lexer_getProtoPopCnt(me->lexer));
587 lexer_scopeOut_PROTO(me->lexer);
592 lexer_scopeIn(me->lexer);
593 parser_scopeIn_DEFUSE(me);
594 parser_scopeIn_PROTO(me);
598 parser_scopeOut_DEFUSE(me);
599 parser_scopeOut_PROTO(me);
600 lexer_scopeOut(me->lexer);
604#define STRDUP_IF_NZ(_ptr) ((_ptr) ? STRDUP(_ptr) : NULL)
605#define DECLAREUP char *saveNextIn, *saveCurID = NULL;
606#define SAVEUP { FREE_IF_NZ(saveCurID); \
607 saveCurID = STRDUP_IF_NZ(me->lexer->curID); \
608 saveNextIn = me->lexer->nextIn;}
609#define BACKUP {FREE_IF_NZ(me->lexer->curID); \
610 me->lexer->curID = saveCurID; \
611 me->lexer->nextIn = saveNextIn; }
612#define FREEUP {FREE_IF_NZ(saveCurID);}
614static BOOL parser_brotoStatement(
struct VRMLParser* me);
633 printf(
"parser_vrmlScene: Try node\n");
635 if(parser_nodeStatement(me, &node))
639 AddRemoveChildren(me->ptr, offsetPointer_deref(
void *,me->ptr,me->ofs), &node, 1, 1,__FILE__,__LINE__);
641 printf(
"parser_vrmlScene: node parsed\n");
653 printf(
"parser_vrmlScene: Try route\n");
658 BLOCK_STATEMENT(parser_vrmlScene)
669 printf(
"parser_vrmlScene: Try proto\n");
678 if(parser_brotoStatement(me)) {
680 printf(
"parser_vrmlScene: BROTO parsed\n");
689void broto_store_DEF(
struct X3D_Proto* proto,
struct X3D_Node* node,
const char *name);
690static BOOL parser_node_B(
struct VRMLParser* me, vrmlNodeT* ret,
int ind);
692static BOOL parser_node(
struct VRMLParser* me, vrmlNodeT* node,
int ival)
694 return parser_node_B(me,node,ival);
705 parse_proto_body(me);
710 return lexer_eof(me->lexer);
733 return parser_vrmlScene_B(me);
758 char *startOfField = NULL;
759 int startOfFieldLexerLevel = INT_ID_UNDEFINED;
763 printf (
"start of parser_interfaceDeclaration\n");
766 bzero (&defaultVal,
sizeof (
union anyVrml));
769 ASSERT((proto || script) && !(proto && script));
776 if(!lexer_protoFieldMode(me->lexer, &mode)) {
778 printf (
"parser_interfaceDeclaration, not lexer_protoFieldMode, returning\n");
786 if (script != NULL) {
787 if(script->ShaderScriptNode->_nodeType==NODE_Script && mode==PKW_inputOutput)
789 PARSE_ERROR(
"Scripts must not have inputOutputs!")
796 if(!lexer_fieldType(me->lexer, &type))
797 PARSE_ERROR(
"Expected fieldType after proto-field keyword!")
800 printf (
"parser_interfaceDeclaration, switching on mode %s\n",PROTOKEYWORDS[mode]);
806#define LEX_DEFINE_FIELDID(suff) \
808 if(!lexer_define_##suff(me->lexer, &name)) \
809 PARSE_ERROR("Expected fieldNameId after field type!") \
812 LEX_DEFINE_FIELDID(initializeOnly)
813 LEX_DEFINE_FIELDID(inputOnly)
814 LEX_DEFINE_FIELDID(outputOnly)
815 LEX_DEFINE_FIELDID(inputOutput)
830 printf (
"parser_interfaceDeclaration, calling newProtoFieldDecl\n");
833 pdecl=newProtoFieldDecl(mode, type, name);
834 pdecl->cname = STRDUP(protoFieldDecl_getStringName(me->lexer, pdecl));
836 externproto = proto->isExtern;
838 printf (
"parser_interfaceDeclaration, finished calling newProtoFieldDecl\n");
842 printf (
"parser_interfaceDeclaration, calling newScriptFieldDecl\n");
845 sdecl=newScriptFieldDecl(me->lexer, mode, type, name);
853 if((mode==PKW_initializeOnly || mode==PKW_inputOutput) ) {
855 printf (
"parser_interfaceDeclaration, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
861 if (script && lexer_keyword(me->lexer, KW_IS)) {
867 if(!lexer_field(me->lexer, NULL, NULL, &fieldO, &fieldE))
868 PARSE_ERROR(
"Expected fieldId after IS!")
870 if(fieldO!=ID_UNDEFINED)
873 pField=protoDefinition_getField(me->curPROTO, fieldO, PKW_initializeOnly);
875 PARSE_ERROR(
"IS source is no field of current PROTO!")
876 ASSERT(pField->mode==PKW_initializeOnly);
879 ASSERT(fieldE!=ID_UNDEFINED);
881 pField=protoDefinition_getField(me->curPROTO, fieldE, PKW_inputOutput);
883 PARSE_ERROR(
"IS source is no field of current PROTO!")
884 ASSERT(pField->mode==PKW_inputOutput);
889 sfield = newScriptFieldInstanceInfo(sdecl, script);
891 defaultVal = pField->defaultVal;
896 startOfField = (
char *)me->lexer->nextIn;
897 startOfFieldLexerLevel = me->lexer->lexerInputLevel;
901 bzero (&defaultVal,
sizeof (
union anyVrml));
903 if (!parseType(me, type, &defaultVal)) {
905 CPARSE_ERROR_CURID(
"Expected default value for field!");
906 if(pdecl) deleteProtoFieldDecl(pdecl);
907 if(sdecl) deleteScriptFieldDecl(sdecl);
915 pdecl->defaultVal=defaultVal;
920 scriptFieldDecl_setFieldValue(sdecl, defaultVal);
924 printf (
"parser_interfaceDeclaration, NOT mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
928 if (script && lexer_keyword(me->lexer, KW_IS)) {
931 BOOL isIn = FALSE, isOut = FALSE;
934 printf (
"parser_interfaceDeclaration, got IS\n");
938 if (mode == PKW_inputOnly) {
939 if (lexer_inputOnly(me->lexer, NULL, NULL, NULL, &evO, &evE)) {
941 isOut = (evE != ID_UNDEFINED);
944 if (lexer_outputOnly(me->lexer, NULL, NULL, NULL, &evO, &evE)) {
950 if (!isIn && !isOut) {
952 printf (
"parser_interfaceDeclaration, NOT isIn Nor isOut\n");
960 pField = protoDefinition_getField(me->curPROTO, evO, isIn ? PKW_inputOnly: PKW_outputOnly);
965 sfield = newScriptFieldInstanceInfo(sdecl, script);
978 if (startOfField != NULL) {
979 if (startOfFieldLexerLevel == me->lexer->lexerInputLevel) {
981 size_t sz = (size_t) ((me->lexer->nextIn)-startOfField);
984 FREE_IF_NZ(pdecl->fieldString);
985 pdecl->fieldString = MALLOC (
char *, sz + 2);
986 if (NULL != pdecl->fieldString)
988 memcpy(pdecl->fieldString,startOfField,sz);
989 pdecl->fieldString[sz]=
'\0';
1017 for (i=startOfFieldLexerLevel+1; i<me->lexer->lexerInputLevel; i++) {
1018 printf (
"CAUTION: unverified code in recursive PROTO invocations in classic VRML parser\n");
1019 printf (
"level %d\n",i);
1020 printf (
"size of this level, %d\n",(
int) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]));
1021 sz += (size_t) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]);
1025 sz += (size_t)(me->lexer->nextIn - me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
1032 FREE_IF_NZ(pdecl->fieldString);
1033 pdecl->fieldString = MALLOC(
char *, sz);
1034 curStrPtr = pdecl->fieldString;
1048 for (i=startOfFieldLexerLevel+1; i<me->lexer->lexerInputLevel; i++) {
1049 sz = (size_t) (me->lexer->oldNextIn[i+1] - me->lexer->startOfStringPtr[i]);
1050 memcpy(curStrPtr,me->lexer->startOfStringPtr[i],sz);
1055 sz = (size_t)(me->lexer->nextIn - me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
1056 memcpy(curStrPtr,me->lexer->startOfStringPtr[me->lexer->lexerInputLevel],sz);
1064 #ifdef CPARSERVERBOSE
1065 printf (
"pdecl->fieldString is :%s:\n",pdecl->fieldString);
1068 protoDefinition_addIfaceField(proto, pdecl);
1072 script_addField(script, sdecl);
1075 #ifdef CPARSERVERBOSE
1076 printf (
"end of parser_interfaceDeclaration\n");
1095static BOOL parser_componentStatement(
struct VRMLParser* me) {
1096 char *cname, *clevel;
1097 char cfullname[200];
1098 int myComponent = INT_ID_UNDEFINED;
1099 int myLevel = INT_ID_UNDEFINED;
1101#if DJ_KEEP_COMPILER_WARNING
1102#define COMPSTRINGSIZE 20
1106 lexer_skip(me->lexer);
1109 if(!lexer_keyword(me->lexer, KW_COMPONENT))
return FALSE;
1111#ifdef CPARSERVERBOSE
1112 printf (
"parser_componentStatement...\n");
1115 if(!lexer_setCurID(me->lexer))
return TRUE;
1116 ASSERT(me->lexer->curID);
1122 strcpy(cfullname,me->lexer->curID);
1124 FREE_IF_NZ(me->lexer->curID);
1128 len = strlen(cfullname);
1130 if(cfullname[i] ==
':'){
1131 cfullname[i] =
'\0';
1132 clevel = &cfullname[i+1];
1135 char *cname1 = cname;
1136 if(!strcmp(cname,
"H-Anim")) cname1 =
"HAnim";
1137 myComponent = findFieldInCOMPONENTS(cname1);
1139 if(clevel) myLevel = atoi(clevel);
1141 handleComponent(myComponent,myLevel);
1154 switch(node->_nodeType){
1164struct X3D_Node *broto_search_DEFname(
struct X3D_Proto *context,
const char *name);
1166void handleExport_B (
void *ctxnodeptr,
char *nodename,
char *as) {
1168 struct X3D_Proto *context = hasContext(ctxnodeptr);
1172 if(!context->__EXPORTS) context->__EXPORTS = newVector(
struct IMEXPORT *,4);
1173 mxport->mxname = STRDUP(nodename);
1174 mxport->as = mxport->mxname;
1176 mxport->as = STRDUP(as);
1177 node = broto_search_DEFname(context,mxport->mxname);
1178 mxport->nodeptr = node;
1179 vector_pushBack(
struct IMEXPORT*,context->__EXPORTS,mxport);
1181 #ifdef CAPABILITIESVERBOSE
1182 printf (
"handleExport: node :%s: ",node);
1183 if (as != NULL) printf (
" AS :%s: ",node);
1189void handleImport_B (
struct X3D_Node *nodeptr,
char *nodeName,
char *nodeImport,
char *as) {
1195 struct X3D_Proto *context = hasContext(nodeptr);
1198 if(!context->__IMPORTS) context->__IMPORTS = newVector(
struct IMEXPORT *,4);
1199 mxport->mxname = STRDUP(nodeImport);
1200 mxport->inlinename = STRDUP(nodeName);
1201 mxport->as = mxport->mxname;
1203 mxport->as = STRDUP(as);
1204 mxport->nodeptr = NULL;
1205 vector_pushBack(
struct IMEXPORT*,context->__IMPORTS,mxport);
1208 #ifdef CAPABILITIESVERBOSE
1209 printf (
"handleImport: inlineNodeName :%s: nodeToImport :%s:",nodeName, nodeImport);
1210 if (as != NULL) printf (
" AS :%s: ",as);
1215static BOOL parser_exportStatement(
struct VRMLParser* me) {
1216 char *nodeToExport = NULL;
1220 lexer_skip(me->lexer);
1223 if(!lexer_keyword(me->lexer, KW_EXPORT))
return FALSE;
1225#ifdef CPARSERVERBOSE
1226 printf (
"parser_exportStatement...\n");
1229 if(!lexer_setCurID(me->lexer))
return TRUE;
1230 ASSERT(me->lexer->curID);
1233 nodeToExport = me->lexer->curID;
1234 me->lexer->curID = NULL;
1236 if(!lexer_setCurID(me->lexer))
return TRUE;
1237 ASSERT(me->lexer->curID);
1240 if (strcmp(
"AS",me->lexer->curID) == 0) {
1241 FREE_IF_NZ(me->lexer->curID);
1242 if(!lexer_setCurID(me->lexer))
return TRUE;
1243 ASSERT(me->lexer->curID);
1244 alias = me->lexer->curID;
1248 handleExport_B(me->ectx,nodeToExport, alias);
1251 FREE_IF_NZ(nodeToExport);
1252 if (alias != NULL) {FREE_IF_NZ(me->lexer->curID);}
1256static BOOL parser_importStatement(
struct VRMLParser* me) {
1257 char *inlineNodeName = NULL;
1259 char *nodeToImport = NULL;
1262 lexer_skip(me->lexer);
1265 if(!lexer_keyword(me->lexer, KW_IMPORT))
return FALSE;
1267#ifdef CPARSERVERBOSE
1268 printf (
"parser_importStatement...\n");
1271 if(!lexer_setCurID(me->lexer))
return TRUE;
1272 ASSERT(me->lexer->curID);
1275 inlineNodeName = STRDUP(me->lexer->curID);
1276 FREE_IF_NZ(me->lexer->curID);
1279 if (!lexer_point(me->lexer)) {
1280 CPARSE_ERROR_CURID(
"expected period in IMPORT statement")
1284 if(!lexer_setCurID(me->lexer)) return TRUE;
1285 ASSERT(me->lexer->curID);
1288 nodeToImport = STRDUP(me->lexer->curID);
1289 FREE_IF_NZ(me->lexer->curID);
1292 if(!lexer_setCurID(me->lexer)) return TRUE;
1293 ASSERT(me->lexer->curID);
1296 if (strcmp(
"AS",me->lexer->curID) == 0) {
1297 FREE_IF_NZ(me->lexer->curID);
1298 if(!lexer_setCurID(me->lexer))
return TRUE;
1299 ASSERT(me->lexer->curID);
1300 alias = STRDUP(me->lexer->curID);
1301 FREE_IF_NZ(me->lexer->curID);
1305 handleImport_B(me->ectx,inlineNodeName, nodeToImport, alias);
1307 FREE_IF_NZ (inlineNodeName);
1308 FREE_IF_NZ (nodeToImport);
1312static BOOL parser_metaStatement(
struct VRMLParser* me) {
1313 vrmlStringT val1, val2;
1316 lexer_skip(me->lexer);
1319 if(!lexer_keyword(me->lexer, KW_META))
return FALSE;
1321#ifdef CPARSERVERBOSE
1322 printf (
"parser_metaStatement...\n");
1328 val1=NULL; val2 = NULL;
1330 if(!parser_sfstringValue (me, &val1)) {
1331 CPARSE_ERROR_CURID(
"Expected a string after a META keyword")
1334 if(!parser_sfstringValue (me, &val2)) {
1335 CPARSE_ERROR_CURID(
"Expected a string after a META keyword")
1338 if ((val1 != NULL) && (val2 != NULL)) { handleMetaDataStringString(me->ectx, val1->strptr,val2->strptr); }
1341 if (val1 != NULL) {FREE_IF_NZ(val1->strptr); FREE_IF_NZ(val1);}
1342 if (val2 != NULL) {FREE_IF_NZ(val2->strptr); FREE_IF_NZ(val2);}
1345static BOOL parser_unitStatement(
struct VRMLParser* me) {
1347 double conversionfactor;
1348 char *categoryname = NULL;
1349 char *unitname = NULL;
1353 lexer_skip(me->lexer);
1356 if(!lexer_keyword(me->lexer, KW_UNIT))
return FALSE;
1358#ifdef CPARSERVERBOSE
1359 printf (
"parser_unitStatement...\n");
1365 categoryname=NULL; unitname = NULL; conversionfactor = 0.0;
1367 if(!lexer_setCurID(me->lexer))
return TRUE;
1368 ASSERT(me->lexer->curID);
1370 categoryname = STRDUP(me->lexer->curID);
1371 FREE_IF_NZ(me->lexer->curID);
1373 if(!lexer_setCurID(me->lexer))
return TRUE;
1374 ASSERT(me->lexer->curID);
1376 unitname = STRDUP(me->lexer->curID);
1377 FREE_IF_NZ(me->lexer->curID);
1379 if(!parser_sftimeValue(me,&conversionfactor)) {
1380 CPARSE_ERROR_CURID(
"Expected a numeric string after a UNIT keyword")
1383 if ((categoryname != NULL) && (unitname != NULL) && (conversionfactor != 0.0)) {
1384 handleUnitDataStringString(me->ectx,categoryname,unitname,conversionfactor);
1388 if (categoryname != NULL) FREE_IF_NZ(categoryname);
1389 if (unitname != NULL) FREE_IF_NZ(unitname);
1394static BOOL parser_profileStatement(
struct VRMLParser* me) {
1395 int myProfile = INT_ID_UNDEFINED;
1398 lexer_skip(me->lexer);
1401 if(!lexer_keyword(me->lexer, KW_PROFILE))
return FALSE;
1403#ifdef CPARSERVERBOSE
1404 printf (
"parser_profileStatement...\n");
1407 if(!lexer_setCurID(me->lexer))
return TRUE;
1408 ASSERT(me->lexer->curID);
1410 myProfile = findFieldInPROFILES(me->lexer->curID);
1412 if (myProfile != ID_UNDEFINED) {
1413 handleProfile(myProfile);
1415 CPARSE_ERROR_CURID(
"Expected a profile after a PROFILE keyword")
1420#ifdef CPARSERVERBOSE
1421 printf (
"my profile is %d\n",myProfile);
1424 FREE_IF_NZ(me->lexer->curID);
1433static BOOL parser_routeStatement_B(
struct VRMLParser* me);
1435static BOOL parser_routeStatement(
struct VRMLParser* me)
1437 return parser_routeStatement_B(me);
1443void parser_registerRoute(
struct VRMLParser* me,
1444 struct X3D_Node* fromNode,
int fromOfs,
1445 struct X3D_Node* toNode,
int toOfs,
1449 if ((fromOfs == ID_UNDEFINED) || (toOfs == ID_UNDEFINED)) {
1450 ConsoleMessage (
"problem registering route - either fromField or toField invalid");
1452 CRoutes_RegisterSimple(fromNode, fromOfs, toNode, toOfs, ft);
1458static vrmlNodeT parse_KW_DEF(
struct VRMLParser *me) {
1459 int ind = ID_UNDEFINED;
1464 if(!lexer_defineNodeName(me->lexer, &ind))
1465 PARSE_ERROR(
"Expected nodeNameId after DEF!\n")
1466 ASSERT(ind!=ID_UNDEFINED);
1470 if(!me->DEFedNodes || stack_empty(me->DEFedNodes)) {
1472 parser_scopeIn_DEFUSE(me);
1474 ASSERT(me->DEFedNodes);
1475 ASSERT(!stack_empty(me->DEFedNodes));
1479 ASSERT(ind<=vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1480 if(ind==vectorSize(stack_top(
struct Vector*, me->DEFedNodes))) {
1481 vector_pushBack(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), NULL);
1483 ASSERT(ind<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1489#ifdef CPARSERVERBOSE
1490 printf(
"parser_KW_DEF: parsing DEFed node \n");
1492 if(!parser_node(me, &node,ind)) {
1495 CPARSE_ERROR_CURID(
"ERROR:Expected an X3D node in a DEF statement, got \"");
1499#ifdef CPARSERVERBOSE
1500 printf(
"parser_KW_DEF: DEFed node successfully parsed\n");
1504 return (vrmlNodeT) vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind);
1510static vrmlNodeT parse_KW_USE(
struct VRMLParser *me) {
1516 if(!lexer_nodeName(me->lexer, &ind)) {
1517 CPARSE_ERROR_CURID(
"ERROR:Expected valid DEF name after USE; found: ");
1518 FREE_IF_NZ(me->lexer->curID);
1521#ifdef CPARSERVERBOSE
1522 printf(
"parser_KW_USE: parsing USE\n");
1526 ASSERT(ind!=ID_UNDEFINED);
1529 ASSERT(me->DEFedNodes && !stack_empty(me->DEFedNodes) &&
1530 ind<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
1532 #ifdef CPARSERVERBOSE
1533 printf (
"parser_KW_USE, returning vector %u\n", vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind));
1537 return (vrmlNodeT) vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind);
1557void push_binding_stack_set(
struct X3D_Node* layersetnode);
1558void push_next_layerId_from_binding_stack_set(
struct X3D_Node *layer);
1559void pop_binding_stack_set();
1561static BOOL parser_nodeStatement(
struct VRMLParser* me, vrmlNodeT* ret)
1566 if(lexer_keyword(me->lexer, KW_DEF)) {
1569 *ret = parse_KW_DEF(me);
1574 if(lexer_keyword(me->lexer, KW_USE)) {
1575 *ret= parse_KW_USE(me);
1580 return parser_node(me, ret, ID_UNDEFINED);
1590 for(i=0; i!=node->n; ++i) {
1591 ADD_PARENT(node->p[i], parent);
1601void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr);
1605#undef PARSER_FINALLY
1606#define PARSER_FINALLY
1608#ifdef CPARSERVERBOSE
1609 printf (
"start of parser_fieldValue\n");
1610 printf (
"me->curPROTO = %u\n",me->curPROTO);
1614#ifdef CPARSERVERBOSE
1615 printf (
"parser_fieldValue, not an IS\n");
1618#define myOffsetPointer_deref(t, me) \
1619 ((t)(((char*)(node))+offs))
1621 void* directRet=myOffsetPointer_deref(
void*, ret);
1622 deleteMallocedFieldValue(type,directRet);
1637 #ifdef CPARSERVERBOSE
1638 printf (
"parser_fieldValue, me %u, directRet %u\n",me,directRet);
1642 return PARSE_TYPE[type](me, directRet);
1645#undef PARSER_FINALLY
1646#define PARSER_FINALLY
1653#define NODE_SPECIFIC_INIT(type, code) \
1656 struct X3D_##type* node=(struct X3D_##type*)n; \
1661 switch(n->_nodeType)
1664 NODE_SPECIFIC_INIT(Script, node->__scriptObj=new_Shader_ScriptB(X3D_NODE(node));)
1665 NODE_SPECIFIC_INIT(ShaderProgram, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1666 NODE_SPECIFIC_INIT(PackagedShader, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1667 NODE_SPECIFIC_INIT(ComposedShader, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1668 NODE_SPECIFIC_INIT(Effect, node->_shaderUserDefinedFields=X3D_NODE(new_Shader_ScriptB(X3D_NODE(node)));)
1754#define UNCA_BASE 0X01
1755#define UNCA_DRVD 0x10
1756#define UNCA_BOTH 0x11
1768 {
"length", UNCA_LENGTH, 1,UNCA_BASE,0,1.0,
"meters", },
1769 {
"angle", UNCA_ANGLE, 0,UNCA_BASE,0,1.0,
"radians", },
1770 {
"mass", UNCA_MASS, 0,UNCA_BASE,0,1.0,
"kilograms", },
1772 {
"force", UNCA_FORCE, 1,UNCA_BOTH,0,1.0,
"newtons", },
1774 {
"acceleration",UNCA_ACCEL, 1,UNCA_DRVD,0,1.0,
"meters/second**2", },
1775 {
"angular_rate",UNCA_ANGLERATE,0,UNCA_DRVD,0,1.0,
"radians/second", },
1776 {
"area", UNCA_AREA, 2,UNCA_DRVD,0,1.0,
"meters**2", },
1777 {
"speed", UNCA_SPEED, 1,UNCA_DRVD,0,1.0,
"meters/seccond", },
1778 {
"volume", UNCA_VOLUME, 3,UNCA_DRVD,0,1.0,
"meters**3", },
1779 {
"torque", UNCA_TORQUE, 2,UNCA_DRVD,0,1.0,
"kg*meters**2/second**2",},
1780 {
"moment", UNCA_MOMENT, 2,UNCA_DRVD,0,1.0,
"kg*meters**2", },
1786#define strcasecmp _stricmp
1788#define UNITMETHOD_ONESTEP 1
1789#define UNITMETHOD_TWOSTEP 2
1790static int unitmethod = UNITMETHOD_ONESTEP;
1791static int UNITSTRICT33 = TRUE;
1793static int isunits = 0;
1794static double unitlengthfactor = 1.0;
1795double getunitlengthfactor(){
1796 return unitlengthfactor;
1801void setUnits(
int isOn){
1804static Stack * units2vec = NULL;
1807 if(units2vec) units2vec->n = 0;
1808 unitlengthfactor = 1.0;
1810static int do_lengthunits = 0;
1822 LENGTHMETHOD_NONE = 0,
1824 LENGTHMETHOD_MINUSONE,
1826void addUnits(
void *ecx,
char *category,
char *unit,
double factor){
1828 struct unitsB *uptr, *u2length, *u2mass, *u2force, *u2angle;
1830 int i, iuc, lengthmethod;
1832 if(!units2vec || (units2vec->n == 0)){
1836 units2vec = newVector(
struct unitsB,20);
1840 memcpy(&u2,uc,
sizeof(
struct unca));
1841 memset(&u2.uname,0,20);
1842 memcpy(&u2.uname[0],uc->uname,min(39,strlen(uc->uname)+1));
1843 vector_pushBack(
struct unitsB,units2vec,u2);
1845 }
while(uncas[iuc].catname);
1848 for(i=0;i<vectorSize(units2vec);i++){
1849 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1850 if(!strcasecmp(uptr->catname,category)){
1852 if(uptr->derived & UNCA_BASE){
1853 memcpy(&uptr->uname[0],unit,min(39,strlen(unit)+1));
1854 uptr->factor = factor;
1855 uptr->ichanged = TRUE;
1856 if(uptr->iunca == UNCA_LENGTH) {
1859 unitlengthfactor = factor;
1860 ec->__unitlengthfactor = unitlengthfactor;
1861 do_lengthunits = TRUE;
1869 u2mass = u2angle = u2length = u2force = NULL;
1870 for(i=0;i<vectorSize(units2vec);i++){
1871 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1872 if(uptr->derived & UNCA_BASE){
1873 switch(uptr->iunca){
1875 u2mass = uptr;
break;
1877 u2angle = uptr;
break;
1879 u2length = uptr;
break;
1881 u2force = uptr;
break;
1891 lengthmethod = LENGTHMETHOD_FULL;
1892 if(unitmethod == UNITMETHOD_TWOSTEP)
1893 lengthmethod = LENGTHMETHOD_MINUSONE;
1894 for(i=0;i<vectorSize(units2vec);i++){
1895 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1896 if(uptr->derived & UNCA_DRVD){
1897 double factor = uptr->factor;
1898 switch(uptr->iunca){
1900 if(!uptr->ichanged){
1904 if(lengthmethod == LENGTHMETHOD_FULL)
1905 factor = u2mass->factor * u2length->factor;
1906 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1907 factor = u2mass->factor;
1911 if(lengthmethod == LENGTHMETHOD_FULL)
1912 factor = u2length->factor;
1914 case UNCA_ANGLERATE:
1915 factor = u2angle->factor;
1918 if(lengthmethod == LENGTHMETHOD_FULL)
1919 factor = u2length->factor * u2length->factor;
1920 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1921 factor = u2length->factor;
1924 if(lengthmethod == LENGTHMETHOD_FULL)
1925 factor = u2length->factor;
1930 if(lengthmethod == LENGTHMETHOD_FULL)
1931 factor = u2length->factor * u2length->factor * u2mass->factor;
1932 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1933 factor = u2length->factor * u2mass->factor;
1934 if(lengthmethod == LENGTHMETHOD_NONE)
1935 factor = u2mass->factor;
1940 if(lengthmethod == LENGTHMETHOD_FULL)
1942 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1944 factor = pow(u2length->factor,dpow);
1949 if(lengthmethod == LENGTHMETHOD_FULL)
1950 factor = u2force->factor * u2length->factor;
1951 if(lengthmethod == LENGTHMETHOD_MINUSONE)
1952 factor = u2force->factor;
1957 uptr->factor = factor;
1966 return ( do_lengthunits && unitmethod == UNITMETHOD_TWOSTEP ) ? TRUE : FALSE;
1968int isUnitSpecVersionOK(
int specversion){
1973 return (!UNITSTRICT33 || specversion > 320) ? TRUE : FALSE;
1979void sfunitf(
int nodetype,
char *fieldname,
float *var,
int n,
int iunca) {
1980 int i,k,specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
1981 if(isUnits() && isUnitSpecVersionOK(specversion)){
1983 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
1986 for(i=0;i<vectorSize(units2vec);i++){
1987 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
1988 if(uptr->iunca == iunca){
1990 var[k] *= (float)uptr->factor;
1998void mfunitrotation(
int nodetype,
char *fieldname,
struct SFRotation *var,
int n,
int iunca){
1999 int i,k, specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
2000 if(isUnits() && isUnitSpecVersionOK(specversion)){
2003 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
2006 for(i=0;i<vectorSize(units2vec);i++){
2007 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2008 if(uptr->iunca == iunca){
2010 var[k].c[3] *= (float)uptr->factor;
2019void mfunit3f(
int nodetype,
char *fieldname,
struct SFVec3f *var,
int n,
int iunca){
2020 int i,k, specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
2021 if(isUnits() && isUnitSpecVersionOK(specversion)){
2023 ok = iunca && (iunca == UNCA_ANGLE || iunca == UNCA_ANGLERATE);
2026 for(i=0;i<vectorSize(units2vec);i++){
2027 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2028 if(uptr->iunca == iunca){
2030 vecscale3f(var[k].c,var[k].c,(
float)uptr->factor);
2040void sfunitd(
int nodeType,
char *fieldname,
double *var,
int n,
int iunca) {
2044int isNodeGeospatial(
struct X3D_Node* node);
2045void applyUnitsToNode(
struct X3D_Node *node){
2053 int specversion = X3D_PROTO(node->_executionContext)->__specversion;
2054 if(isUnits() && isUnitSpecVersionOK(specversion)){
2058 if(isNodeGeospatial(node)){
2061 double factorA, factorL, factorC;
2064 factorA = factorL = factorC = 1.0;
2065 for(i=0;i<vectorSize(units2vec);i++){
2066 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2067 if(uptr->iunca == UNCA_ANGLE) factorA = uptr->factor;
2068 if(uptr->iunca == UNCA_LENGTH) factorL = uptr->factor;
2073 offsets = (fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2075 field = &offsets[ifield];
2077 isgeosystemGD = TRUE;
2078 while( field->nameIndex > -1)
2080 const char *name = FIELDNAMES[field->nameIndex];
2081 if(!strcmp(name,
"geoSystem")){
2082 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2083 struct Uni_String *ustring = value->mfstring.p[0];
2084 if(strcmp(ustring->strptr,
"GD"))
2085 isgeosystemGD = FALSE;
2089 field = &offsets[ifield];
2100 offsets = (fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2102 field = &offsets[ifield];
2104 while( field->nameIndex > -1)
2106 int iunca = field->unca;
2107 const char *name = FIELDNAMES[field->nameIndex];
2108 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2109 if(iunca == UNCA_GEO){
2113 switch(field->typeIndex){
2114 case FIELDTYPE_SFDouble:
2116 value->sfdouble *= factorC;
2118 case FIELDTYPE_MFDouble:
2120 printf(
"mfdouble nixpa7 ");
2122 case FIELDTYPE_SFVec3d:
2123 dvar = value->sfvec2d.c;
2128 case FIELDTYPE_MFVec3d:
2129 for(k=0;k<value->mfvec3d.n;k++){
2130 sfvar = &value->mfvec3d.p[k];
2142 field = &offsets[ifield];
2147 offsets = (fieldinfo)NODE_OFFSETS[(node)->_nodeType];
2149 field = &offsets[ifield];
2151 while( field->nameIndex > -1)
2153 int iunca = field->unca;
2154 if(iunca == UNCA_PLANE) iunca = UNCA_LENGTH;
2155 const char *name = FIELDNAMES[field->nameIndex];
2156 union anyVrml *value = (
union anyVrml*)&((
char*)node)[field->offset];
2157 if(iunca != UNCA_NONE && iunca != UNCA_ANGLE && iunca != UNCA_ANGLERATE && iunca != UNCA_GEO){
2160 if(!(iunca == UNCA_LENGTH && unitmethod == UNITMETHOD_TWOSTEP)){
2165 for(i=0;i<vectorSize(units2vec);i++){
2166 uptr = vector_get_ptr(
struct unitsB,units2vec,i);
2167 if(uptr->iunca == iunca){
2168 factor = (float)uptr->factor;
2172 iunca = field->unca;
2173 switch(field->typeIndex){
2174 case FIELDTYPE_SFRotation:
2175 value->sfrotation.c[3] *= factor;
2177 case FIELDTYPE_SFFloat:
2178 value->sffloat *= factor;
2180 case FIELDTYPE_MFFloat:
2181 for(i=0;i<value->mffloat.n;i++)
2182 value->mffloat.p[i] *= factor;
2184 case FIELDTYPE_SFVec3f:
2185 vecscale3f(value->sfvec3f.c,value->sfvec3f.c,(
float)factor);
2187 case FIELDTYPE_SFVec4f:
2188 if(iunca == UNCA_PLANE)
2189 value->sfvec4f.c[3] *= factor;
2191 vecscale4f(value->sfvec4f.c,value->sfvec4f.c,(
float)factor);
2193 case FIELDTYPE_SFVec2f:
2194 vecscale2f(value->sfvec2f.c,value->sfvec2f.c,(
float)factor);
2196 case FIELDTYPE_MFVec3f:
2197 for(i=0;i<value->mfvec3f.n;i++)
2198 vecscale3f(value->mfvec3f.p[i].c,value->mfvec3f.p[i].c,(
float)factor);
2200 case FIELDTYPE_SFMatrix3f:
2202 value->sfmatrix3f.c[i] *= factor;
2204 case FIELDTYPE_MFRotation:
2205 for(i=0;i<value->mfrotation.n;i++)
2206 value->mfrotation.p[i].c[3] *= factor;
2208 case FIELDTYPE_SFDouble:
2209 value->sfdouble *= factor;
2218 field = &offsets[ifield];
2225#define INIT_CODE_sfnode(var,fieldname) \
2226 ADD_PARENT(node2->var, X3D_NODE(node2));
2227#define INIT_CODE_mfnode(var,fieldname) \
2228 mfnode_add_parent(&node2->var, X3D_NODE(node2));
2229#define INIT_CODE_sfbool(var,fieldname)
2230#define INIT_CODE_sfcolor(var,fieldname)
2231#define INIT_CODE_sfcolorrgba(var,fieldname)
2232#define INIT_CODE_sffloat(var,fieldname) sfunitf(node2->_nodeType,fieldname, (float*)&node2->var, 1,iunca);
2233#define INIT_CODE_sfimage(var,fieldname)
2234#define INIT_CODE_sfint32(var,fieldname)
2235#define INIT_CODE_sfrotation(var,fieldname) sfunitf(node2->_nodeType,fieldname, &node2->var.c[3], 1,iunca);
2236#define INIT_CODE_sfstring(var,fieldname)
2237#define INIT_CODE_sftime(var,fieldname)
2238#define INIT_CODE_sfvec2f(var,fieldname) sfunitf(node2->_nodeType,fieldname, node2->var.c, 2, iunca);
2239#define INIT_CODE_sfvec3f(var,fieldname) sfunitf(node2->_nodeType,fieldname, node2->var.c, 3, iunca);
2240#define INIT_CODE_sfvec3d(var,fieldname)
2241#define INIT_CODE_mfbool(var,fieldname)
2242#define INIT_CODE_mfcolor(var,fieldname)
2243#define INIT_CODE_mfcolorrgba(var,fieldname)
2244#define INIT_CODE_mffloat(var,fieldname) sfunitf(node2->_nodeType,fieldname,node2->var.p, node2->var.n,iunca);
2245#define INIT_CODE_mfint32(var,fieldname)
2246#define INIT_CODE_mfrotation(var,fieldname) mfunitrotation(node2->_nodeType,fieldname, node2->var.p, node2->var.n,iunca);
2247#define INIT_CODE_mfstring(var,fieldname)
2248#define INIT_CODE_mftime(var,fieldname)
2249#define INIT_CODE_mfvec2f(var,fieldname)
2250#define INIT_CODE_mfvec3f(var,fieldname) mfunit3f(node2->_nodeType,fieldname, node2->var.p, node2->var.n, iunca);
2251#define INIT_CODE_mfvec3d(var,fieldname)
2252#define INIT_CODE_sfdouble(var,fieldname)
2253#define INIT_CODE_mfdouble(var,fieldname)
2254#define INIT_CODE_sfvec4d(var,fieldname)
2255#define INIT_CODE_mfmatrix3f(var,fieldname)
2256#define INIT_CODE_mfmatrix4f(var,fieldname)
2258#define INIT_CODE_mfmatrix3d(var,fieldname)
2259#define INIT_CODE_mfmatrix4d(var,fieldname)
2260#define INIT_CODE_mfvec2d(var,fieldname)
2261#define INIT_CODE_mfvec4d(var,fieldname)
2262#define INIT_CODE_mfvec4f(var,fieldname)
2263#define INIT_CODE_sfmatrix3d(var,fieldname)
2264#define INIT_CODE_sfmatrix3f(var,fieldname) sfunitf(node2->_nodeType,fieldname,node2->var.c, 9,iunca);
2265#define INIT_CODE_sfmatrix4d(var,fieldname)
2266#define INIT_CODE_sfmatrix4f(var,fieldname)
2267#define INIT_CODE_sfvec2d(var,fieldname)
2268#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); }
2288 if(!lexer_field(me->lexer, &fieldO, &fieldE, NULL, NULL))
2306#define EVENT_IN(n, f, t, v, realType)
2307#define EVENT_OUT(n, f, t, v, realType)
2310#define END_NODE(type) \
2316#define FTIND_sfnode FIELDTYPE_SFNode
2317#define FTIND_sfbool FIELDTYPE_SFBool
2318#define FTIND_sfcolor FIELDTYPE_SFColor
2319#define FTIND_sfcolorrgba FIELDTYPE_SFColorRGBA
2320#define FTIND_sffloat FIELDTYPE_SFFloat
2321#define FTIND_sfimage FIELDTYPE_SFImage
2322#define FTIND_sfint32 FIELDTYPE_SFInt32
2323#define FTIND_sfrotation FIELDTYPE_SFRotation
2324#define FTIND_sfstring FIELDTYPE_SFString
2325#define FTIND_sftime FIELDTYPE_SFTime
2326#define FTIND_sfdouble FIELDTYPE_SFDouble
2327#define FTIND_sfvec2f FIELDTYPE_SFVec2f
2328#define FTIND_sfvec2d FIELDTYPE_SFVec2d
2329#define FTIND_sfvec3f FIELDTYPE_SFVec3f
2330#define FTIND_sfvec3d FIELDTYPE_SFVec3d
2331#define FTIND_sfvec4f FIELDTYPE_SFVec4f
2332#define FTIND_sfvec4d FIELDTYPE_SFVec4d
2333#define FTIND_sfmatrix3f FIELDTYPE_SFMatrix3f
2334#define FTIND_sfmatrix4f FIELDTYPE_SFMatrix4f
2335#define FTIND_sfmatrix3d FIELDTYPE_SFMatrix3d
2336#define FTIND_sfmatrix4d FIELDTYPE_SFMatrix4d
2338#define FTIND_mfnode FIELDTYPE_MFNode
2339#define FTIND_mfbool FIELDTYPE_MFBool
2340#define FTIND_mfcolor FIELDTYPE_MFColor
2341#define FTIND_mfcolorrgba FIELDTYPE_MFColorRGBA
2342#define FTIND_mffloat FIELDTYPE_MFFloat
2343#define FTIND_mfint32 FIELDTYPE_MFInt32
2344#define FTIND_mfrotation FIELDTYPE_MFRotation
2345#define FTIND_mfstring FIELDTYPE_MFString
2346#define FTIND_mfimage FIELDTYPE_MFImage
2347#define FTIND_mftime FIELDTYPE_MFTime
2348#define FTIND_mfvec2f FIELDTYPE_MFVec2f
2349#define FTIND_mfvec2d FIELDTYPE_MFVec2d
2350#define FTIND_mfvec3f FIELDTYPE_MFVec3f
2351#define FTIND_mfvec3d FIELDTYPE_MFVec3d
2352#define FTIND_mfvec4d FIELDTYPE_MFVec4d
2353#define FTIND_mfvec4f FIELDTYPE_MFVec4f
2354#define FTIND_mfdouble FIELDTYPE_MFDouble
2355#define FTIND_mfmatrix3f FIELDTYPE_MFMatrix3f
2356#define FTIND_mfmatrix4f FIELDTYPE_MFMatrix4f
2357#define FTIND_mfmatrix3d FIELDTYPE_MFMatrix3d
2358#define FTIND_mfmatrix4d FIELDTYPE_MFMatrix4d
2364#define PROCESS_FIELD_B(exposed, node, field, fieldType, var, fe, junca) \
2365 case exposed##FIELD_##field: \
2366 if(!parser_fieldValue(me, \
2367 X3D_NODE(node2), (int) offsetof(struct X3D_##node, var), \
2368 FTIND_##fieldType, fe, FALSE, NULL, NULL)) {\
2369 PARSE_ERROR("Expected " #fieldType " Value for a fieldtype!") }\
2371 INIT_CODE_##fieldType(var,#field) \
2378#define NODE_DEFAULT_B \
2380 PARSE_ERROR("Parser PROCESS_FIELD_B, Unsupported node!")
2387if(fieldE!=ID_UNDEFINED)
2388 switch(node->_nodeType)
2392#define BEGIN_NODE(type) \
2395 struct X3D_##type* node2=(struct X3D_##type*)node; \
2402#define EXPOSED_FIELD(node, field, fieldType, var, realType,iunca) \
2403 PROCESS_FIELD_B(EXPOSED_, node, field, fieldType, var, fieldE,iunca)
2406#define FIELD(n, f, t, v, realType,iunca)
2409#include "NodeFields.h"
2421if(fieldO!=ID_UNDEFINED)
2422 switch(node->_nodeType)
2426#define BEGIN_NODE(type) \
2429 struct X3D_##type* node2=(struct X3D_##type*)node; \
2435#define FIELD(node, field, fieldType, var, realType,iunca) \
2436 PROCESS_FIELD_B(, node, field, fieldType, var, ID_UNDEFINED,iunca)
2439#define EXPOSED_FIELD(n, f, t, v, realType,iunca)
2442#include "NodeFields.h"
2459PARSE_ERROR(
"Unsupported field for node!")
2466 return parser_field_B(me,node);
2468static union anyVrml ignore_field;
2475 char *nodeFieldName;
2483 if(!lexer_setCurID(me->lexer))
return FALSE;
2484 ASSERT(me->lexer->curID);
2485 nodeFieldName = STRDUP(me->lexer->curID);
2487 FREE_IF_NZ(me->lexer->curID);
2490 targetVal = &ignore_field;
2491 if(strcmp(nodeFieldName,
"_xy")){
2493 FREE_IF_NZ(nodeFieldName);
2496 type = FIELDTYPE_SFVec2f;
2497 if (!parseType(me, type, targetVal)) {
2499 CPARSE_ERROR_CURID(
"Expected default value for field!");
2502 FREE_IF_NZ(nodeFieldName);
2506 FREE_IF_NZ(nodeFieldName);
2515static void stuffDEFUSE(
struct Multi_Node *outMF, vrmlNodeT in,
int type) {
2522 case FIELDTYPE_MFNode:
2525 outMF->p=MALLOC(
void *,
sizeof(
struct X3D_Node*));
2529 case FIELDTYPE_MFFloat:
2530 case FIELDTYPE_MFBool:
2531 case FIELDTYPE_MFInt32:
2532 case FIELDTYPE_MFTime:
2533 case FIELDTYPE_MFDouble:
2534 case FIELDTYPE_MFColor:
2535 case FIELDTYPE_MFColorRGBA:
2536 case FIELDTYPE_MFRotation:
2537 case FIELDTYPE_MFVec2f:
2538 case FIELDTYPE_MFVec3f:
2539 case FIELDTYPE_MFVec4f:
2540 case FIELDTYPE_MFVec2d:
2541 case FIELDTYPE_MFVec3d:
2542 case FIELDTYPE_MFVec4d:
2543 case FIELDTYPE_MFString:
2544 case FIELDTYPE_MFImage:
2545 case FIELDTYPE_MFMatrix3f:
2546 case FIELDTYPE_MFMatrix4f:
2547 case FIELDTYPE_MFMatrix3d:
2548 case FIELDTYPE_MFMatrix4d:
2550 localSize = returnRoutingElementLength(convertToSFType(type));
2554 outMF->p=MALLOC(
void *, localSize);
2555 memcpy (&outMF->p[0], &in, localSize);
2559 ConsoleMessage(
"VRML Parser; stuffDEFUSE, unhandled type");
2567static void stuffSFintoMF(
struct Multi_Node *outMF, vrmlNodeT *inSF,
int type) {
2574 rsz = returnElementRowSize(type);
2575 elelen = returnElementLength(type);
2590 for (i=0; i<outMF->n; i++) {
2591 if (type == FIELDTYPE_MFString) {
2594 FREE_IF_NZ(m->strptr);
2599 if (outMF->n != 1) {
2601 FREE_IF_NZ(outMF->p);
2603 outMF->p=MALLOC(
void *, rsz * elelen);
2608 memcpy (outMF->p, inSF, rsz * elelen);
2612#define PARSER_MFFIELD(name, type) \
2613 static BOOL parser_mf##name##Value(struct VRMLParser* me, void *ret) { \
2614 struct Vector* vec; \
2616 struct Multi_##type *rv; \
2624 if (!(me->parsingX3DfromXML)) { \
2626 if(lexer_keyword(me->lexer, KW_USE)) { \
2629 RCX=parse_KW_USE(me); \
2630 if (RCX == NULL) return FALSE; \
2632 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2636 else if (lexer_keyword(me->lexer, KW_DEF)) { \
2639 RCX=parse_KW_DEF(me); \
2640 if (RCX == NULL) return FALSE; \
2643 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2650if (me->lexer->curID != NULL) { \
2652 if (!parser_node(me, &RCX, ID_UNDEFINED)) { \
2655 if (RCX == NULL) return FALSE; \
2657 stuffDEFUSE(ret, RCX, FIELDTYPE_MF##type); \
2662if((!lexer_openSquare(me->lexer)) && (!(me->parsingX3DfromXML))) { \
2663 vrml##type##T RCXRet; \
2665 if(!parser_sf##name##Value(me, &RCXRet)) { \
2672 stuffSFintoMF(ret, (vrmlNodeT *)&RCXRet, FIELDTYPE_MF##type); \
2678 vec=newVector(vrml##type##T, 128); \
2679 if (!me->parsingX3DfromXML) { \
2680 while(!lexer_closeSquare(me->lexer)) { \
2681 vrml##type##T val; \
2682 if(!parser_sf##name##Value(me, &val)) { \
2683 CPARSE_ERROR_CURID("ERROR:Expected \"]\" before end of MF-Value") \
2686 vector_pushBack(vrml##type##T, vec, val); \
2689 lexer_skip(me->lexer); \
2690 while(*me->lexer->nextIn != '\0') { \
2691 vrml##type##T val; \
2692 if(!parser_sf##name##Value(me, &val)) { \
2693 CPARSE_ERROR_CURID("ERROR:Expected \"]\" before end of MF-Value") \
2696 vector_pushBack(vrml##type##T, vec, val); \
2697 lexer_skip(me->lexer); \
2700 rv = (struct Multi_##type*) ret; \
2701 rv->n=vectorSize(vec); \
2702 rv->p=vector_releaseData(vrml##type##T, vec); \
2704 deleteVector(vrml##type##T, vec); \
2709 PARSER_MFFIELD(
bool, Bool)
2710 PARSER_MFFIELD(color, Color)
2711 PARSER_MFFIELD(colorrgba, ColorRGBA)
2712 PARSER_MFFIELD(
float, Float)
2713 PARSER_MFFIELD(int32, Int32)
2714 PARSER_MFFIELD(node, Node)
2715 PARSER_MFFIELD(rotation, Rotation)
2716 PARSER_MFFIELD(
string, String)
2717 PARSER_MFFIELD(time, Time)
2718 PARSER_MFFIELD(
double, Double)
2719 PARSER_MFFIELD(vec2f, Vec2f)
2720 PARSER_MFFIELD(vec3f, Vec3f)
2721 PARSER_MFFIELD(vec3d, Vec3d)
2722 PARSER_MFFIELD(vec2d, Vec2d)
2723 PARSER_MFFIELD(vec4f, Vec4f)
2724 PARSER_MFFIELD(vec4d, Vec4d)
2725 PARSER_MFFIELD(image, Image)
2726 PARSER_MFFIELD(matrix3f, Matrix3f)
2727 PARSER_MFFIELD(matrix4f, Matrix4f)
2728 PARSER_MFFIELD(matrix3d, Matrix3d)
2729 PARSER_MFFIELD(matrix4d, Matrix4d)
2735#define PARSER_FIXED_VEC(name, type, cnt) \
2736 BOOL parser_sf##name##Value(struct VRMLParser* me, void* ret) \
2739 vrml##type##T *rv; \
2740 ASSERT(me->lexer); \
2741 rv = (vrml##type##T *) ret; \
2742 for(i=0; i!=cnt; ++i) {\
2743 if(!parser_sffloatValue(me, rv->c+i)) \
2750#define PARSER_FIXED_DOUBLE_VEC(name, type, cnt) \
2751 BOOL parser_sf##name##Value(struct VRMLParser* me, void* ret) \
2754 vrml##type##T *rv; \
2755 ASSERT(me->lexer); \
2756 rv = (vrml##type##T *) ret; \
2757 for(i=0; i!=cnt; ++i) {\
2758 if(!parser_sfdoubleValue_(me, rv->c+i)) \
2764 BOOL parser_sfdoubleValue_(
struct VRMLParser* me, vrmlDoubleT* ret)
2766 return lexer_double(me->lexer, ret);
2768static BOOL parser_sffloatValue_(
struct VRMLParser* me,
void* ret)
2771 rf = (vrmlFloatT*)ret;
2772 return lexer_float(me->lexer, rf);
2774static BOOL parser_sfint32Value_(
struct VRMLParser* me,
void* ret)
2777 rf = (vrmlInt32T*)ret;
2778 return lexer_int32(me->lexer, rf);
2783static BOOL set_X3Dstring(
struct VRMLLexer* me, vrmlStringT* ret) {
2785 *ret=newASCIIString((
char *)me->startOfStringPtr[me->lexerInputLevel]);
2789static BOOL parser_sfstringValue_(
struct VRMLParser* me,
void* ret) {
2792 rv = (vrmlStringT*)ret;
2796 if (!me->parsingX3DfromXML)
return lexer_string(me->lexer, rv);
2798 else return set_X3Dstring(me->lexer, rv);
2803static BOOL parser_sfboolValue(
struct VRMLParser* me,
void* ret) {
2806 rv = (vrmlBoolT*)ret;
2809 if (!me->parsingX3DfromXML) {
2811 if(lexer_keyword(me->lexer, KW_TRUE)) {
2815 if(lexer_keyword(me->lexer, KW_FALSE)) {
2820 if(lexer_keyword(me->lexer, KW_true)) {
2824 if(lexer_keyword(me->lexer, KW_false)) {
2831 if(lexer_keyword(me->lexer, KW_true)) {
2835 if(lexer_keyword(me->lexer, KW_false)) {
2840 if(lexer_keyword(me->lexer, KW_TRUE)) {
2844 if(lexer_keyword(me->lexer, KW_FALSE)) {
2882 PARSER_FIXED_VEC(color, Color, 3)
2883 PARSER_FIXED_VEC(colorrgba, ColorRGBA, 4)
2884 PARSER_FIXED_VEC(rotation, Rotation, 4)
2885 PARSER_FIXED_VEC(vec2f, Vec2f, 2)
2886 PARSER_FIXED_VEC(vec3f, Vec3f, 3)
2887 PARSER_FIXED_VEC(vec4f, Vec4f, 4)
2888 PARSER_FIXED_DOUBLE_VEC(vec2d, Vec2d, 2)
2889 PARSER_FIXED_DOUBLE_VEC(vec3d, Vec3d, 3)
2890 PARSER_FIXED_DOUBLE_VEC(vec4d, Vec4d, 4)
2891 PARSER_FIXED_VEC(matrix3f, Matrix3f, 9)
2892 PARSER_FIXED_VEC(matrix4f, Matrix4f, 16)
2893 PARSER_FIXED_DOUBLE_VEC(matrix3d, Matrix3d, 9)
2894 PARSER_FIXED_DOUBLE_VEC(matrix4d, Matrix4d, 16)
2899 static BOOL parser_sfimageValue(struct
VRMLParser* me,
void* ret)
2902 vrmlInt32T width, height, depth;
2905 rv = (vrmlImageT*) ret;
2907 if(!lexer_int32(me->lexer, &width))
2909 if(!lexer_int32(me->lexer, &height))
2911 if(!lexer_int32(me->lexer, &depth))
2915 rv->arr.n=width*height;
2916 rv->arr.p=MALLOC(
int *,
sizeof(
int) * rv->arr.n);
2921 for(ptr=rv->arr.p; ptr!=rv->arr.p+rv->arr.n; ++ptr)
2922 if(!lexer_int32(me->lexer, ptr))
2924 FREE_IF_NZ(rv->arr.p);
2933static BOOL parser_sfnodeValue(
struct VRMLParser* me,
void* ret) {
2938 rv = (vrmlNodeT*)ret;
2940 if(lexer_keyword(me->lexer, KW_NULL)) {
2946 if (!me->parsingX3DfromXML) {
2947 return parser_nodeStatement(me, rv);
2951 if (sscanf(me->lexer->startOfStringPtr[me->lexer->lexerInputLevel],
"%zu", & tmp) != 1) {
2952 CPARSE_ERROR_FIELDSTRING (
"error finding SFNode id on line :%s:",
2953 me->lexer->startOfStringPtr[me->lexer->lexerInputLevel]);
2957 *rv = (vrmlNodeT)tmp;
2963static BOOL parser_sftimeValue(
struct VRMLParser* me,
void* ret)
2966 rv = (vrmlTimeT*)ret;
2967 return lexer_double(me->lexer, rv);
2970static BOOL parser_sfdoubleValue(
struct VRMLParser* me,
void* ret)
2973 rv = (vrmlDoubleT*)ret;
2974 return lexer_double(me->lexer, rv);
2978static BOOL parser_fieldTypeNotParsedYet(
struct VRMLParser* me,
void* ret) {
2979 CPARSE_ERROR_CURID (
"received a request to parse a type not supported yet");
2985 #define OUTLINELEN 800
2987void cParseErrorCurID(
struct VRMLParser *me,
char *str) {
2988 char fw_outline[OUTLINELEN];
2989 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
2991 if (strlen(str) > FROMSRC) {
2992 memcpy(fw_outline,str,FROMSRC);
2993 fw_outline[FROMSRC-1] =
'\0';
2995 strcpy(fw_outline,str);
2997 if (me->lexer->curID != ((
void *)0)) {
2998 strcat (fw_outline,
"; current token :");
2999 strcat (fw_outline, me->lexer->curID);
3000 strcat (fw_outline,
": ");
3002 if (me->lexer->nextIn != NULL) {
3003 strcat (fw_outline,
" at: \"");
3004 strncat(fw_outline,me->lexer->nextIn,FROMSRC);
3005 if (strlen(me->lexer->nextIn) > FROMSRC)
3006 strcat (fw_outline,
"...");
3007 strcat (fw_outline,
"\"");
3010 p->foundInputErrors++;
3011 ConsoleMessage(fw_outline);
3014void cParseErrorFieldString(
struct VRMLParser *me,
char *str,
const char *str2) {
3016 char fw_outline[OUTLINELEN];
3017 int str2len = (int) strlen(str2);
3018 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
3020 if (strlen(str) > FROMSRC) str[FROMSRC] =
'\0';
3021 strcpy(fw_outline,str);
3022 strcat (fw_outline,
" (");
3023 strncat (fw_outline,str2,str2len);
3024 strcat (fw_outline,
") ");
3025 if (me->lexer->curID != ((
void *)0)) strcat (fw_outline, me->lexer->curID);
3026 if (me->lexer->nextIn != NULL) {
3027 strcat (fw_outline,
" at: \"");
3028 strncat(fw_outline,me->lexer->nextIn,FROMSRC);
3029 if (strlen(me->lexer->nextIn) > FROMSRC)
3030 strcat (fw_outline,
"...");
3031 strcat (fw_outline,
"\"");
3034 p->foundInputErrors++;
3035 ConsoleMessage(fw_outline);
3117void add_node_to_broto_context(
struct X3D_Proto *currentContext,
struct X3D_Node *node);
3119static BOOL parser_externbrotoStatement(
struct VRMLParser* me);
3120static BOOL parser_node_B(
struct VRMLParser* me, vrmlNodeT* ret,
int ind) {
3121 int nodeTypeB, nodeTypeU, isBroto;
3129 currentContext = (
struct X3D_Proto*)me->ectx;
3130 pflagdepth = ciflag_get(currentContext->__protoFlags,0);
3141#ifdef CPARSERVERBOSE
3142 printf (
"parser_node START, curID :%s: nextIn :%s:\n",me->lexer->curID, me->lexer->nextIn);
3147 if(parser_routeStatement(me)) {
3151 if (parser_componentStatement(me)) {
3155 if (parser_exportStatement(me)) {
3159 if (parser_importStatement(me)) {
3163 if (parser_metaStatement(me)) {
3167 if (parser_profileStatement(me)) {
3170 if(parser_brotoStatement(me)) {
3173 if(parser_externbrotoStatement(me)) {
3180 if(!lexer_node(me->lexer, &nodeTypeB, &nodeTypeU)) {
3181#ifdef CPARSERVERBOSE
3182 printf (
"parser_node, not lexed - is this one of those special nodes?\n");
3191 if(!lexer_openCurly(me->lexer))
3192 PARSE_ERROR(
"Expected { after node-type id!")
3194#ifdef CPARSERVERBOSE
3195 printf (
"parser_node: have nodeTypeB %d nodeTypeU %d\n",nodeTypeB, nodeTypeU);
3198 if (nodeTypeU != ID_UNDEFINED) {
3204 char *protoname = vector_get(
char*, me->lexer->userNodeTypesVec, nodeTypeU);
3208 if( isAvailableBroto(protoname, currentContext , &proto))
3212 idepth = pflagdepth == 1;
3213 node=X3D_NODE(brotoInstance(proto,idepth));
3214 node->_executionContext = X3D_NODE(currentContext);
3215 add_node_to_broto_context(currentContext,node);
3219 if (ind != ID_UNDEFINED) {
3222 vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind)=node;
3223#ifdef CPARSERVERBOSE
3224 printf(
"parser_node: adding DEFed node (pointer %p) to DEFedNodes vector\n", node);
3226 name = vector_get(
char*, stack_top(
struct Vector*, me->lexer->userNodeNames), ind);
3227 broto_store_DEF((
struct X3D_Proto*)(me->ectx),node, name);
3234 if(nodeTypeB!=ID_UNDEFINED) {
3235#ifdef CPARSERVERBOSE
3236 printf(
"parser_node: parsing builtin node\n");
3241 node=X3D_NODE(createNewX3DNode((
int)nodeTypeB));
3242 if(node->_nodeType == NODE_Inline){
3243 if(X3D_NODE(me->ectx)->_nodeType != NODE_Inline && X3D_NODE(me->ectx)->_nodeType != NODE_Proto)
3244 printf(
"ouch trying to caste a %d nodetype to inline or proto\n",X3D_NODE(me->ectx)->_nodeType);
3245 X3D_INLINE(node)->__parentProto = me->ectx;
3248 node=X3D_NODE(createNewX3DNode0((
int)nodeTypeB));
3250 node->_executionContext = X3D_NODE(currentContext);
3251 add_node_to_broto_context(currentContext,node);
3256 if (ind != ID_UNDEFINED) {
3259 vector_get(
struct X3D_Node*, stack_top(
struct Vector*, me->DEFedNodes), ind)=node;
3260 name = vector_get(
char*, stack_top(
struct Vector*, me->lexer->userNodeNames), ind);
3261 broto_store_DEF((
struct X3D_Proto*)(me->ectx),node, name);
3263#ifdef CPARSERVERBOSE
3264 printf(
"parser_node: adding DEFed node (pointer %p) to DEFedNodes vector\n", node);
3271 parser_specificInitNode_B(node, me);
3274 switch (node->_nodeType) {
3275 case NODE_Script: script=X3D_SCRIPT(node)->__scriptObj;
break;
3276 case NODE_ShaderProgram: shader=(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
3277 case NODE_PackagedShader: shader=(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
3278 case NODE_ComposedShader: shader=(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
3279 case NODE_Effect: shader=(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
3281 push_binding_stack_set(node);
break;
3282 case NODE_LayoutLayer:
3284 push_next_layerId_from_binding_stack_set(node);
break;
3296 if( (nodeTypeB!=ID_UNDEFINED) || isBroto)
3298 #define SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING 1
3307#ifdef CPARSERVERBOSE
3308 printf(
"parser_node: try parsing field ... \n");
3314 if( found_IS_field(me,node) ){
3318 if(SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3319 if(parser_field_user(me,node)) {
3324 if(parser_field(me, node)) {
3325#ifdef CPARSERVERBOSE
3326 printf(
"parser_node: field parsed\n");
3335#ifdef CPARSERVERBOSE
3336 printf(
"parser_node: try parsing ROUTE ... \n");
3341 BLOCK_STATEMENT(parser_node);
3351#ifdef CPARSERVERBOSE
3352 printf(
"parser_node: try parsing PROTO ... \n");
3363 if(parser_brotoStatement(me)) {
3364#ifdef CPARSERVERBOSE
3365 printf(
"parser_vrmlScene: BROTO parsed\n");
3370#ifdef CPARSERVERBOSE
3371 printf(
"parser_node: try parsing Script or Shader field\n");
3381 if(SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3382 if(script && parser_interfaceDeclarationB(me, NULL, script)){
3385 if(!SPLIT_SCRIPTUSERFIELD_CREATION_FROM_VALUEPARSING)
3386 if(script && parser_interfaceDeclaration(me, NULL, script)) {
3387#ifdef CPARSERVERBOSE
3388 printf(
"parser_node: SCRIPT field parsed\n");
3393 if(shader && parser_interfaceDeclaration(me, NULL, shader)) {
3394#ifdef CPARSERVERBOSE
3395 printf(
"parser_node: Shader field parsed\n");
3403 applyUnitsToNode(node);
3406#ifdef CPARSERVERBOSE
3407 printf(
"parser_node: try parsing SCRIPT url\n");
3411 initialize_one_script(script,&X3D_SCRIPT(node)->url);
3412#ifdef CPARSERVERBOSE
3413 printf(
"parser_node: SCRIPT url parsed\n");
3417 if(isBroto && pflagdepth){
3425 ptype = X3D_PROTO(X3D_PROTO(node)->__prototype);
3426 pdest = X3D_PROTO(node);
3427 deep_copy_broto_body2(&ptype,&pdest);
3437#ifdef CPARSERVERBOSE
3438 printf (
"calling lexer_closeCurly at B\n");
3441 if(!lexer_closeCurly(me->lexer)) {
3442 CPARSE_ERROR_CURID(
"ERROR: Expected a closing brace after fields of a node;")
3446 if(node->_nodeType == NODE_LayerSet)
3447 pop_binding_stack_set();
3451 #ifdef CPARSERVERBOSE
3452 printf (
"returning at end of parser_node, ret %u\n",node);
3453 if (node != NULL) printf (
"and, node type is %s\n",stringNodeType(node->_nodeType));
3483#ifdef CPARSERVERBOSE
3484 printf (
"start of parser_interfaceDeclaration\n");
3489 ASSERT((proto || script) && !(proto && script));
3496 if(!lexer_protoFieldMode(me->lexer, &mode)) {
3497#ifdef CPARSERVERBOSE
3498 printf (
"parser_interfaceDeclaration, not lexer_protoFieldMode, returning\n");
3506 if (script != NULL) {
3507 if(script->ShaderScriptNode->_nodeType==NODE_Script && mode==PKW_inputOutput)
3509 PARSE_ERROR(
"Scripts must not have inputOutputs!")
3516 if(!lexer_fieldType(me->lexer, &type))
3517 PARSE_ERROR(
"Expected fieldType after proto-field keyword!")
3519#ifdef CPARSERVERBOSE
3520 printf (
"parser_interfaceDeclaration, switching on mode %s\n",PROTOKEYWORDS[mode]);
3529#define LEX_DEFINE_FIELDID(suff) \
3531 if(!lexer_define_##suff(me->lexer, &name)) \
3532 PARSE_ERROR("Expected fieldNameId after field type!") \
3535 LEX_DEFINE_FIELDID(initializeOnly)
3536 LEX_DEFINE_FIELDID(inputOnly)
3537 LEX_DEFINE_FIELDID(outputOnly)
3538 LEX_DEFINE_FIELDID(inputOutput)
3551#ifdef CPARSERVERBOSE
3552 printf (
"parser_interfaceDeclaration, calling newProtoFieldDecl\n");
3555 pdecl=newProtoFieldDecl(mode, type, name);
3558#ifdef CPARSERVERBOSE
3559 printf (
"parser_interfaceDeclaration, finished calling newProtoFieldDecl\n");
3562#ifdef CPARSERVERBOSE
3563 printf (
"parser_interfaceDeclaration, calling newScriptFieldDecl\n");
3566 sdecl=newScriptFieldDecl(me->lexer, mode, type, name);
3574 if(mode==PKW_initializeOnly || mode==PKW_inputOutput) {
3575#ifdef CPARSERVERBOSE
3576 printf (
"parser_interfaceDeclaration, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
3578 bzero (&defaultVal,
sizeof (
union anyVrml));
3582 pdecl->defaultVal=defaultVal;
3588 scriptFieldDecl_setFieldValue(sdecl, defaultVal);
3598 protoDefinition_addIfaceField(proto, pdecl);
3606 #ifdef CPARSERVERBOSE
3607 printf (
"end of parser_interfaceDeclaration\n");
3619BOOL 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);
3636 char *nodeFieldName;
3648#ifdef CPARSERVERBOSE
3649 printf (
"start of parser_field_user\n");
3659 if(!lexer_setCurID(me->lexer))
return FALSE;
3660 ASSERT(me->lexer->curID);
3665 nodeFieldName = STRDUP(me->lexer->curID);
3672 FREE_IF_NZ(me->lexer->curID);
3676 if(!find_anyfield_by_name(me->lexer,node,&targetVal,&mode,&type,nodeFieldName,&source,&fdecl,&ifield)){
3679 FREE_IF_NZ(nodeFieldName);
3684 FREE_IF_NZ(nodeFieldName);
3689 if(mode==PKW_initializeOnly || mode==PKW_inputOutput) {
3690#ifdef CPARSERVERBOSE
3691 printf (
"parser_field_user, mode==PKW_initializeOnly || mode==PKW_inputOutput\n");
3697 deleteMallocedFieldValue(type,targetVal);
3698 if (!parseType(me, type, targetVal)) {
3700 CPARSE_ERROR_CURID(
"Expected default value for field!");
3703 FREE_IF_NZ(nodeFieldName);
3712 struct X3D_Proto *pnode = X3D_PROTO(node);
3715 struct ProtoFieldDecl * pf = protoDefinition_getFieldByNum(pd, ifield);
3739 #ifdef CPARSERVERBOSE
3740 printf (
"end of parser_user_field\n");
3743 FREE_IF_NZ(nodeFieldName);
3753static BOOL parser_brotoStatement(
struct VRMLParser* me)
3770 if(!lexer_keyword(me->lexer, KW_PROTO))
3779 if(!lexer_defineNodeType(me->lexer, &name))
3780 PARSE_ERROR(
"Expected nodeTypeId after PROTO!\n")
3781 ASSERT(name!=ID_UNDEFINED);
3784 obj=newProtoDefinition();
3787 if (vectorSize(me->lexer->userNodeTypesVec) != ID_UNDEFINED) {
3788 obj->protoName = STRDUP(vector_get(
const char*, me->lexer->userNodeTypesVec, vectorSize(me->lexer->userNodeTypesVec)-1));
3790 printf (
"warning - have proto but no name, so just copying a default string in\n");
3791 obj->protoName = STRDUP(
"noProtoNameDefined");
3794 #ifdef CPARSERVERBOSE
3795 printf (
"parser_protoStatement, working on proto :%s:\n",obj->protoName);
3800 parser_scopeIn_PROTO(me);
3814 if(!lexer_openSquare(me->lexer))
3815 PARSE_ERROR(
"Expected [ to start interface declaration!")
3821 while(parser_interfaceDeclaration(me, obj, NULL));
3824 if(!lexer_closeSquare(me->lexer))
3825 PARSE_ERROR(
"Expected ] after interface declaration!")
3835 proto = createNewX3DNode(NODE_Proto);
3837 if(X3D_NODE(me->ectx)->_nodeType != NODE_Proto && X3D_NODE(me->ectx)->_nodeType != NODE_Inline )
3838 printf(
"ouch trying to caste node type %d to proto\n",X3D_NODE(me->ectx)->_nodeType);
3840 if(parent->__protoDeclares == NULL)
3841 parent->__protoDeclares = newVector(struct
X3D_Proto*,4);
3842 vector_pushBack(struct
X3D_Proto*,parent->__protoDeclares,proto);
3844 proto->__parentProto = X3D_NODE(parent);
3845 proto->__protoFlags = parent->__protoFlags;
3846 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,0);
3848 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,2);
3849 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,3);
3851 proto->__protoDef = obj;
3852 proto->__prototype = X3D_NODE(proto);
3853 proto->__typename = STRDUP(obj->protoName);
3854 proto->__unitlengthfactor = getunitlengthfactor();
3855 proto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
3859 if(!lexer_openCurly(me->lexer))
3860 PARSE_ERROR(
"Expected { to start PROTO body!")
3874#ifdef CPARSERVERBOSE
3875 printf (
"about to parse PROTO body; new proto def %p\n",obj);
3884 me->ofs = offsetof(
struct X3D_Proto, __children);
3885 parse_proto_body(me);
3893 if(!lexer_closeCurly(me->lexer))
3894 PARSE_ERROR(
"Expected } to end PROTO body!")
3897 parser_scopeOut(me);
3900#ifdef CPARSERVERBOSE
3901 printf (
"calling lexer_closeCurly at A\n");
3902printf (
"parser_protoStatement, FINISHED proto :%s:\n",obj->protoName);
3912#define LOAD_INITIAL_STATE 0
3913static BOOL parser_externbrotoStatement(
struct VRMLParser* me)
3929 if(!lexer_keyword(me->lexer, KW_EXTERNPROTO))
3938 if(!lexer_defineNodeType(me->lexer, &name))
3939 PARSE_ERROR(
"Expected nodeTypeId after EXTERNPROTO!\n")
3940 ASSERT(name!=ID_UNDEFINED);
3943 obj=newProtoDefinition();
3944 obj->isExtern = TRUE;
3946 if (vectorSize(me->lexer->userNodeTypesVec) != ID_UNDEFINED) {
3947 obj->protoName = STRDUP(vector_get(
const char*, me->lexer->userNodeTypesVec, vectorSize(me->lexer->userNodeTypesVec)-1));
3949 printf (
"warning - have proto but no name, so just copying a default string in\n");
3950 obj->protoName = STRDUP(
"noProtoNameDefined");
3953 #ifdef CPARSERVERBOSE
3954 printf (
"parser_protoStatement, working on proto :%s:\n",obj->protoName);
3959 parser_scopeIn_PROTO(me);
3973 if(!lexer_openSquare(me->lexer))
3974 PARSE_ERROR(
"Expected [ to start interface declaration!")
3980 while(parser_interfaceDeclaration(me, obj, NULL));
3983 if(!lexer_closeSquare(me->lexer))
3984 PARSE_ERROR(
"Expected ] after interface declaration!")
3994 proto = createNewX3DNode0(NODE_Proto);
3997 if(parent->__externProtoDeclares == NULL)
3998 parent->__externProtoDeclares = newVector(struct
X3D_Proto*,4);
3999 vector_pushBack(struct
X3D_Proto*,parent->__externProtoDeclares,proto);
4002 proto->__parentProto = X3D_NODE(parent);
4003 proto->__protoFlags = parent->__protoFlags;
4004 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,0);
4006 proto->__protoFlags = ciflag_set(proto->__protoFlags,0,2);
4007 proto->__protoFlags = ciflag_set(proto->__protoFlags,1,3);
4009 proto->__protoDef = obj;
4010 proto->__prototype = X3D_NODE(proto);
4011 proto->__typename = (
void *)STRDUP(obj->protoName);
4012 proto->__unitlengthfactor = getunitlengthfactor();
4013 proto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
4023 if (!parser_mfstringValue(me,&proto->url)) {
4024 PARSE_ERROR (
"EXTERNPROTO - problem reading URL string");
4026 proto->__loadstatus = LOAD_INITIAL_STATE;
4049void broto_store_route(
struct X3D_Proto* proto,
4050 struct X3D_Node* fromNode,
int fromIndex,
int fromBuiltIn,
4051 struct X3D_Node* toNode,
int toIndex,
int toBuiltIn,
4058 if ((fromIndex == ID_UNDEFINED) || (toIndex == ID_UNDEFINED)) {
4059 ConsoleMessage (
"problem registering route - either fromField or toField invalid");
4063 route = createNewBrotoRoute();
4064 route->from.node = fromNode;
4065 route->from.ifield = fromIndex;
4066 route->from.builtIn = fromBuiltIn;
4067 route->to.node = toNode;
4068 route->to.ifield = toIndex;
4069 route->to.builtIn = toBuiltIn;
4070 route->lastCommand = 1;
4073 routes = proto->__ROUTES;
4074 if( routes == NULL){
4076 proto->__ROUTES = routes;
4078 stack_push(
struct brotoRoute *, routes, route);
4100void broto_store_ImportRoute_obsolete(
struct X3D_Proto* proto,
char *fromNode,
char *fromField,
char *toNode,
char* toField)
4104 if( proto->__ROUTES == NULL)
4105 proto->__ROUTES= newStack(
struct brotoRoute *);
4106 route = createNewBrotoRoute();
4108 route->lastCommand = 0;
4109 route->from.weak = 2;
4110 route->from.cnode = STRDUP(fromNode);
4111 route->from.cfield = STRDUP(fromField);
4112 route->from.ftype = -1;
4114 route->to.cnode = STRDUP(toNode);
4115 route->to.cfield = STRDUP(toField);
4116 route->to.ftype = -1;
4117 stack_push(
struct brotoRoute *, proto->__ROUTES, route);
4126 if( context->__ROUTES == NULL)
4127 context->__ROUTES= newStack(
struct brotoRoute *);
4128 stack_push(
struct brotoRoute *, context->__ROUTES, route);
4130void free_brouteEnd(
struct brouteEnd *bend){
4131 FREE_IF_NZ(bend->cnode);
4132 FREE_IF_NZ(bend->cfield);
4135 free_brouteEnd(&route->from);
4136 free_brouteEnd(&route->to);
4141BOOL route_parse_nodefield(
struct VRMLParser* me,
int *NodeIndex,
struct X3D_Node** Node,
int KW_eventType,
4144 int PKW_eventType = PKW_outputOnly;
4151 char *nodeFieldName;
4162 if(KW_eventType == KW_outputOnly){
4163 PKW_eventType = PKW_outputOnly;
4164 cerror1 =
"Expected an event of type : outputOnly :";
4165 }
else if(KW_eventType == KW_inputOnly) {
4166 PKW_eventType = PKW_inputOnly;
4167 cerror1 =
"Expected an event of type : inputOnly :";
4173 if(!lexer_nodeName(me->lexer, NodeIndex)) {
4175 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected a valid DEF name; found \"");
4182 ASSERT(me->DEFedNodes && !stack_empty(me->DEFedNodes) && *NodeIndex<vectorSize(stack_top(
struct Vector*, me->DEFedNodes)));
4185 stack_top(
struct Vector*, me->DEFedNodes),
4188 if (*Node == NULL) {
4190 CPARSE_ERROR_CURID(
"ERROR:ROUTE: no DEF name found - check scoping and \"}\"s");
4197 if(!lexer_point(me->lexer)) {
4198 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected \".\" after the NODE name")
4204 if(!lexer_setCurID(me->lexer)) return FALSE;
4205 ASSERT(me->lexer->curID);
4206 nodeFieldName = STRDUP(me->lexer->curID);
4208 FREE_IF_NZ(me->lexer->curID);
4211 foundField = find_anyfield_by_nameAndRouteDir( *Node, &fieldPtr, &mode, &type,
4212 nodeFieldName, &source, &fdecl, &ifield, PKW_eventType);
4216 *Ofs = NODE_OFFSETS[(*Node)->_nodeType][ifield*FIELDOFFSET_LENGTH + 1];
4219 *ScriptField = fdecl;
4223 if((*Node)->_nodeType==NODE_Script && !fdecl) {
4224 PARSE_ERROR(
"Event-field invalid for this PROTO/Script!")
4226 PARSE_ERROR(cerror1)
4228 FREE_IF_NZ(nodeFieldName);
4232struct IMEXPORT *broto_search_IMPORTname(
struct X3D_Proto *context,
const char *name);
4233BOOL route_parse_nodefield_B(
struct VRMLParser* me,
char **ssnode,
char **ssfield)
4241 char *snode,*sfield;
4246 if(!lexer_setCurID(me->lexer))
4248 ASSERT(me->lexer->curID);
4249 snode = STRDUP(me->lexer->curID);
4250 FREE_IF_NZ(me->lexer->curID);
4254 if(!lexer_point(me->lexer)) {
4255 CPARSE_ERROR_CURID(
"ERROR:ROUTE: Expected \".\" after the NODE name")
4261 if(!lexer_setCurID(me->lexer))
4263 ASSERT(me->lexer->curID);
4264 sfield = STRDUP(me->lexer->curID);
4265 FREE_IF_NZ(me->lexer->curID);
4275void QAandRegister_parsedRoute_B(struct
X3D_Proto *context,
char* fnode,
char* ffield,
char* tnode,
char* tfield);
4279static BOOL parser_routeStatement_B(struct
VRMLParser* me)
4281 char *sfnode, *sffield;
4282 char *stnode, *stfield;
4283 int foundfrom, foundto, gotTO;
4285 ppCParseParser p = (ppCParseParser)gglobal()->CParseParser.prv;
4288 lexer_skip(me->lexer);
4291 if(!lexer_keyword(me->lexer, KW_ROUTE))
4299 foundfrom = route_parse_nodefield_B(me,&sfnode, &sffield);
4303 if(!lexer_keyword(me->lexer, KW_TO)) {
4305 char *buf = p->fw_outline;
4306 strcpy (buf,
"ERROR:ROUTE: Expected \"TO\" found \"");
4307 if (me->lexer->curID != NULL) strcat (buf, me->lexer->curID);
else strcat (buf,
"(EOF)");
4308 CPARSE_ERROR_CURID(buf);
4316 foundto = route_parse_nodefield_B(me,&stnode, &stfield);
4318 if(!(foundfrom && gotTO && foundto)){
4320 FREE_IF_NZ(sffield);
4322 FREE_IF_NZ(stfield);
4327 QAandRegister_parsedRoute_B(X3D_PROTO(me->ectx), sfnode, sffield, stnode, stfield);
4329 FREE_IF_NZ(sffield);
4331 FREE_IF_NZ(stfield);
4391void broto_store_DEF(
struct X3D_Proto* proto,
struct X3D_Node* node,
const char *name)
4396 def.name = STRDUP(name);
4397 defs = proto->__DEFnames;
4401 proto->__DEFnames = defs;
4405int broto_search_DEF_index_by_node(
struct X3D_Proto* proto,
struct X3D_Node *node){
4407 Stack *defs = proto->__DEFnames;
4411 for(i=0;i<vectorSize(defs);i++){
4413 if(def.node == node){
4427 index = broto_search_DEF_index_by_node(proto,node);
4429 defs = proto->__DEFnames;
4431 FREE_IF_NZ(def.name);
4432 vector_removeElement(
sizeof(
struct brotoDefpair),defs,index);
4435struct X3D_Node *broto_search_DEFname(
struct X3D_Proto *context,
const char *name){
4436 int i, istart, iend;
4441 if(context->__DEFnames){
4442 istart = vectorSize(context->__DEFnames) -1;
4444 for(i=istart;i>=iend; i--) {
4445 def = vector_get(
struct brotoDefpair, context->__DEFnames,i);
4446 if(!strcmp(def.name, name))
return def.node;
4451struct IMEXPORT *broto_search_IMPORTname(
struct X3D_Proto *context,
const char *name){
4454 if(context->__IMPORTS)
4455 for(i=0;i<vectorSize(context->__IMPORTS);i++){
4456 def = vector_get(
struct IMEXPORT *, context->__IMPORTS,i);
4457 if(!strcmp(def->as,name))
return def;
4461struct IMEXPORT *broto_search_EXPORTname(
struct X3D_Proto *context,
const char *name){
4464 if(context->__EXPORTS)
4465 for(i=0;i<vectorSize(context->__EXPORTS);i++){
4466 def = vector_get(
struct IMEXPORT *, context->__EXPORTS,i);
4467 if(!strcmp(def->as,name))
return def;
4473BOOL isAvailableBroto(
const char *pname,
struct X3D_Proto* currentContext,
struct X3D_Proto **proto)
4486 context = currentContext;
4492 BOOL bottomUp = TRUE;
4494 plist = (
struct Vector*) context->__protoDeclares;
4496 int n = vectorSize(plist);
4500 if(bottomUp) j = n - 1 - i;
4502 p = vector_get(
struct X3D_Proto*,plist,j);
4503 obj = p->__protoDef;
4504 if(!strcmp(obj->protoName,pname))
4511 plist = (
struct Vector*) context->__externProtoDeclares;
4513 int n = vectorSize(plist);
4517 if(bottomUp) j = n - 1 - i;
4519 p = vector_get(
struct X3D_Proto*,plist,j);
4520 obj = p->__protoDef;
4521 if(!strcmp(obj->protoName,pname))
4528 context = (
struct X3D_Proto*)context->__parentProto;
4530 printf(
"ouch no broto definition found\n");
4543 for(i=0;i<p2p->n;i++)
4546 if(pair.pp == source){
4554void copy_routes2(Stack *routes,
struct X3D_Proto* target,
struct Vector *p2p)
4559 struct X3D_Node *fromNode, *toNode;
4560 if(routes == NULL)
return;
4561 for(i=0;i<routes->n;i++)
4563 route = vector_get(
struct brotoRoute*, routes, i);
4566 fromNode = p2p_lookup(route->from.node,p2p);
4567 toNode = p2p_lookup(route->to.node,p2p);
4568 CRoutes_RegisterSimpleB(fromNode, route->from.ifield, route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4572 broto_store_route(target,fromNode,route->from.ifield,route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4579void copy_defnames2(Stack *defnames,
struct X3D_Proto* target,
struct Vector *p2p)
4590 if(target->__DEFnames == NULL)
4596 n = vectorSize(defnames);
4599 def2.name = STRDUP(def.name);
4600 def2.node = p2p_lookup(def.node, p2p);
4602 stack_push(
struct brotoDefpair, target->__DEFnames, def2);
4607void copy_IS(Stack *istable,
struct X3D_Proto* target,
struct Vector *p2p);
4608void copy_IStable(Stack **sourceIS, Stack** destIS);
4611void initialize_scripts(Stack *instancedScripts);
4644 Stack *instancedScripts;
4649 p->__children.n = 0;
4650 p->__children.p = NULL;
4651 parent = (
struct X3D_Node*) (*dest);
4652 prototype = (
struct X3D_Proto*)(*proto)->__prototype;
4654 p->__prototype = X3D_NODE(prototype);
4656 p->__protoFlags = ciflag_set(p->__protoFlags,1,2);
4663 copy_IStable((Stack **) &(prototype->__IS), (Stack **) &(p->__IS));
4665 instancedScripts = (*dest)->__scripts;
4666 if( instancedScripts == NULL)
4668 instancedScripts = newStack(
struct X3D_Node *);
4669 (*dest)->__scripts = instancedScripts;
4673 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(prototype->__children),(
union anyVrml*)&(p->__children),
4674 p2p,instancedScripts,p,parent);
4676 copy_routes2(prototype->__ROUTES, p, p2p);
4678 copy_defnames2(prototype->__DEFnames, p, p2p);
4682 for (
int i = 0; i < vectorSize(prototype->__protoDeclares); i++) {
4683 pp = vector_get(
struct X3D_Proto*, prototype->__protoDeclares, i);
4684 vector_pushBack(
struct X3D_Proto*, p->__protoDeclares, pp);
4687 for (
int i = 0; i < vectorSize(prototype->__externProtoDeclares); i++) {
4688 pp = vector_get(
struct X3D_Proto*, prototype->__externProtoDeclares, i);
4689 vector_pushBack(
struct X3D_Proto*, p->__externProtoDeclares, pp);
4693 copy_IS(p->__IS, p, p2p);
4695 initialize_scripts(instancedScripts);
4715 pushInputResource(proto->_parentResource);
4716 p = createNewX3DNode(NODE_Proto);
4719 p->__children.n = 0;
4720 p->__children.p = NULL;
4723 pflags = ciflag_set(pflags,1,0);
4725 pflags = ciflag_set(pflags,1,2);
4726 pflags = ciflag_set(pflags,0,3);
4727 if(ciflag_get(proto->__protoFlags,3)==1)
4728 pflags = ciflag_set(pflags,1,3);
4730 p->__protoFlags = pflags;
4733 p = createNewX3DNode0(NODE_Proto);
4735 p->__children.n = 0;
4736 p->__children.p = NULL;
4743 p->__protoFlags = 0;
4748 p->__prototype = proto->__prototype;
4749 p->_nodeType = proto->_nodeType;
4750 p->__unitlengthfactor = proto->__unitlengthfactor;
4751 p->__specversion = proto->__specversion;
4752 p->_defaultContainer = proto->_defaultContainer;
4753 p->_renderFlags = proto->_renderFlags;
4754 pobj = proto->__protoDef;
4758 nobj->iface = newVector(
struct ProtoFieldDecl *, pobj->iface->n);
4760 nobj->protoName = STRDUP(pobj->protoName);
4761 for(i=0;i<pobj->iface->n;i++)
4763 pdecl = protoDefinition_getFieldByNum(pobj, i);
4765 ndecl=newProtoFieldDecl(pdecl->mode, pdecl->type, pdecl->name);
4769 ndecl = copy_ProtoFieldDecl(pdecl);
4771 protoDefinition_addIfaceField(nobj, ndecl);
4773 p->__protoDef = nobj;
4783 for(i=0;i<p2p->n;i++)
4786 if(pnode == pair.pp)
return pair.pn;
4791void copy_routes(Stack *routes,
struct X3D_Proto* target,
struct Vector *p2p)
4795 struct X3D_Node *fromNode, *toNode;
4796 if(routes == NULL)
return;
4797 for(i=0;i<routes->n;i++)
4799 route = vector_get(
struct brotoRoute*, routes, i);
4802 fromNode = p2p_lookup(route->from.node,p2p);
4803 toNode = p2p_lookup(route->to.node,p2p);
4804 CRoutes_RegisterSimpleB(fromNode, route->from.ifield, route->from.builtIn, toNode, route->to.ifield, route->to.builtIn, route->ft);
4820 char *protofieldname;
4826 char* nodefieldname;
4834void copy_IS(Stack *istable,
struct X3D_Proto* target,
struct Vector *p2p)
4839 if(istable == NULL)
return;
4840 for(i=0;i<istable->n;i++)
4842 int ifield, builtIn, iprotofield;
4843 is = vector_get(
struct brotoIS*, istable, i);
4846 node = p2p_lookup(is->node,p2p);
4848 pnode = X3D_NODE(target);
4849 ifield = is->ifield;
4850 builtIn = is->builtIn;
4853 iprotofield = is->iprotofield;
4856 if(is->pmode == PKW_outputOnly){
4859 CRoutes_RegisterSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4861 }
else if(is->pmode == PKW_inputOnly){
4862 CRoutes_RegisterSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4863 }
else if(is->pmode == PKW_inputOutput){
4864 CRoutes_RegisterSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4865 CRoutes_RegisterSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4871void unregister_IStableRoutes(Stack* istable,
struct X3D_Proto* target){
4879 if(istable == NULL)
return;
4880 for(i=0;i<istable->n;i++)
4882 int ifield, builtIn, iprotofield;
4883 is = vector_get(
struct brotoIS*, istable, i);
4888 pnode = X3D_NODE(target);
4889 ifield = is->ifield;
4890 builtIn = is->builtIn;
4893 iprotofield = is->iprotofield;
4896 if(is->pmode == PKW_outputOnly){
4899 CRoutes_RemoveSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4901 }
else if(is->pmode == PKW_inputOnly){
4902 CRoutes_RemoveSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4903 }
else if(is->pmode == PKW_inputOutput){
4904 CRoutes_RemoveSimpleB(node, ifield, builtIn, pnode, iprotofield, FALSE, 0);
4905 CRoutes_RemoveSimpleB(pnode, iprotofield, FALSE, node, ifield, builtIn, 0);
4912void copy_IStable(Stack **sourceIS, Stack** destIS)
4917 *destIS = newStack(
struct brotoIS*);
4919 for(i=0;i<(*sourceIS)->n;i++)
4922 iss = vector_get(
struct brotoIS*,*sourceIS,i);
4923 memcpy(isd,iss,
sizeof(
struct brotoIS));
4925 stack_push(
struct brotoIS*, *destIS, isd);
4929struct brotoIS * in_IStable(
struct X3D_Node *target,
int ifield, Stack *IS,
int source)
4934 for(i=0;i<IStable->n;i++)
4937 if(target == record->node){
4938 if(ifield == record->ifield && source == record->source){
4950void copy_defnames(Stack *defnames,
struct X3D_Proto* target,
struct Vector *p2p)
4955 defs = globalParser->brotoDEFedNodes;
4959 globalParser->brotoDEFedNodes = defs;
4965 n = vectorSize(defnames);
4969 def2->name = def->name;
4970 def2->node = p2p_lookup(def->node, p2p);
4975char *broto_getNameFromNode(
struct X3D_Node* node)
4982 defs = globalParser->brotoDEFedNodes;
4986 n = vectorSize(defs);
4989 if(def->node == node){
4999 Stack *instancedScripts,
struct X3D_Proto *ctx);
5009 isMF = typeIndex % 2;
5010 sftype = typeIndex - isMF;
5013 isize = sizeofSForMF(sftype);
5020 deleteMallocedFieldValue(typeIndex,dest);
5023 if( sftype == FIELDTYPE_SFNode ) nele = (int) upper_power_of_two(nele);
5027 mfd->p = MALLOC (
struct X3D_Node **, isize*nele);
5028 bzero(mfd->p,isize*nele);
5030 ps = (
char *)mfs->p;
5031 pd = (
char *)mfd->p;
5032 for(i=0;i<mfs->n;i++)
5034 copy_field(sftype,(
union anyVrml*)ps,(
union anyVrml*)pd,p2p,instancedScripts,ctx,parent);
5044 case FIELDTYPE_SFNode:
5047 deep_copy_node(&source->sfnode,&dest->sfnode,p2p,instancedScripts,ctx);
5048 add_parent(dest->sfnode,parent,__FILE__,__LINE__);
5050 dest->sfnode = NULL;
5054 case FIELDTYPE_SFString:
5057 deleteMallocedFieldValue(typeIndex,dest);
5061 sd->strptr = STRDUP((*ss)->strptr);
5062 dest->sfstring = sd;
5067 memcpy(dest,source,isize);
5074void deep_copy_broto_body(
struct X3D_Proto** proto,
struct X3D_Proto** dest, Stack *instancedScripts)
5109 p->__children.n = 0;
5110 p->__children.p = NULL;
5111 parent = (
struct X3D_Node*) (*dest);
5112 prototype = (
struct X3D_Proto*)(*proto)->__prototype;
5118 copy_IStable((Stack **) &(prototype->__IS), (Stack **) &(p->__IS));
5121 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(prototype->__children),(
union anyVrml*)&(p->__children),
5122 p2p,instancedScripts,p,parent);
5124 copy_routes(prototype->__ROUTES, p, p2p);
5126 copy_defnames(prototype->__DEFnames, p, p2p);
5129 copy_IS(p->__IS, p, p2p);
5140void shallow_copy_field(
int typeIndex,
union anyVrml* source,
union anyVrml* dest)
5146 isMF = typeIndex % 2;
5147 sftype = typeIndex - isMF;
5150 isize = sizeofSForMF(sftype);
5158 if(mfs->p != mfd->p){
5160 deleteMallocedFieldValue(typeIndex,dest);
5162 if( sftype == FIELDTYPE_SFNode ) nele = (int) upper_power_of_two(nele);
5167 mfd->p = MALLOC (
struct X3D_Node **, isize*nele);
5168 bzero(mfd->p,isize*nele);
5170 ps = (
char *)mfs->p;
5171 pd = (
char *)mfd->p;
5172 for(i=0;i<mfs->n;i++)
5174 shallow_copy_field(sftype,(
union anyVrml*)ps,(
union anyVrml*)pd);
5184 case FIELDTYPE_SFString:
5189 deleteMallocedFieldValue(typeIndex,dest);
5194 sd->strptr = STRDUP((*ss)->strptr);
5195 dest->sfstring = sd;
5200 case FIELDTYPE_SFImage:
5203 si = &source->sfimage;
5204 di = &dest->sfimage;
5205 if (di == si)
return;
5208 FREE_IF_NZ(di->arr.p);
5209 int nele = si->arr.n;
5210 nele = (int)upper_power_of_two(nele);
5214 di->whc[0] = di->whc[1] = di->whc[2] = 0;
5217 int jsize =
sizeof(int);
5218 di->arr.p = MALLOC(
int *, jsize * nele);
5219 bzero(di->arr.p, jsize * nele);
5220 di->arr.n = si->arr.n;
5221 memcpy(di->arr.p, si->arr.p, jsize * si->arr.n);
5222 memcpy(di->whc, si->whc, 3 *
sizeof(
int));
5231 memcpy(dest,source,isize);
5239int PKW_from_KW(
int KW_index)
5246 case KW_initializeOnly:
5247 pkw = PKW_initializeOnly;
break;
5249 pkw = PKW_inputOnly;
break;
5251 pkw = PKW_outputOnly;
break;
5252 case KW_inputOutput:
5253 pkw = PKW_inputOutput;
break;
5255 pkw = PKW_field;
break;
5257 pkw = PKW_eventIn;
break;
5259 pkw = PKW_eventOut;
break;
5260 case KW_exposedField:
5261 pkw = PKW_exposedField;
break;
5267BOOL isManagedField(
int mode,
int type, BOOL isPublic);
5268void registerParentIfManagedField(
int type,
int mode, BOOL isPublic,
union anyVrml* any,
struct X3D_Node* parent)
5277 if(isManagedField(mode,type,isPublic))
5279 int n,k,haveSomething;
5281 haveSomething = (type==FIELDTYPE_SFNode && any->sfnode) || (type==FIELDTYPE_MFNode && any->mfnode.n);
5282 haveSomething = haveSomething && parent;
5284 if(type==FIELDTYPE_SFNode){
5285 plist = &any->sfnode;
5288 plist = any->mfnode.p;
5295 if( !sfn->_parentVector)
5296 sfn->_parentVector = newVector(
struct X3D_Node*,2);
5297 vector_pushBack(
struct X3D_Node*, sfn->_parentVector, parent);
5303void freeMallocedNodeFields(
struct X3D_Node* node);
5305void freePublicBuiltinNodeFields(
struct X3D_Node* node);
5306void **shaderFields(
struct X3D_Node* node);
5307void deep_copy_node(
struct X3D_Node** source,
struct X3D_Node** dest,
struct Vector *p2p, Stack *instancedScripts,
5312 void **shaderfield = NULL;
5313 if(*source == NULL){
5317 *dest = inPointerTable(*source,p2p);
5324 if((*source)->_nodeType == NODE_Proto){
5325 *dest = X3D_NODE(brotoInstance(X3D_PROTO(X3D_PROTO(*source)->__prototype),ciflag_get(ctx->__protoFlags,0)));
5327 *dest=X3D_NODE(createNewX3DNode( (*source)->_nodeType));
5329 add_node_to_broto_context(ctx,(*dest));
5332 if((*source)->_nodeType == NODE_Script)
5333 stack_push(
struct X3D_Node*,instancedScripts,*dest);
5339 shaderfield = shaderFields(*source);
5354 offsets = (fieldinfo)NODE_OFFSETS[(*source)->_nodeType];
5356 field = &offsets[ifield];
5358 while( field->nameIndex > -1)
5366 isrecord = in_IStable(*source,ifield,(Stack *)ctx->__IS, is_source);
5367 if (isrecord != NULL)
5372 union anyVrml *source_field, *dest_field;
5375 sp = ctx->__protoDef;
5376 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5379 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5380 dest_field = (
union anyVrml*)&((
char*)*dest )[field->offset];
5382 shallow_copy_field(field->typeIndex, source_field, dest_field);
5383 registerParentIfManagedField(field->typeIndex,PKW_from_KW(field->ioType),1, dest_field, *dest);
5394 else if((*source)->_nodeType == NODE_Proto && !strcmp(FIELDNAMES[field->nameIndex],
"__protoDef") )
5410 dp = newProtoDefinition();
5419 for(k=0;k<sp->iface->n;k++)
5421 sdecl = protoDefinition_getFieldByNum(sp, k);
5422 ddecl = protoDefinition_getFieldByNum(dp, k);
5429 isrecord = in_IStable(*source,k,(Stack *)ctx->__IS, is_source);
5430 if (isrecord != NULL)
5435 union anyVrml *source_field, *dest_field;
5438 sp = ctx->__protoDef;
5439 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5442 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5443 dest_field = (
union anyVrml*)&(ddecl->defaultVal);
5449 shallow_copy_field(sdecl->type, source_field, dest_field);
5450 registerParentIfManagedField(sdecl->type,sdecl->mode,1, dest_field, *dest);
5451 ddecl->alreadySet = sdecl->alreadySet;
5457 if(sdecl->mode == PKW_initializeOnly || sdecl->mode == PKW_inputOutput){
5459 union anyVrml *source_field, *dest_field;
5460 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5461 dest_field = (
union anyVrml*)&(ddecl->defaultVal);
5462 copy_field(sdecl->type,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5463 ddecl->alreadySet = sdecl->alreadySet;
5471 else if((*source)->_nodeType == NODE_Script && !strcmp(FIELDNAMES[field->nameIndex],
"__scriptObj") )
5482 sp = s->__scriptObj;
5483 dp = d->__scriptObj = new_Shader_ScriptB(*dest);
5484 dp->loaded = sp->loaded;
5486 sfields = sp->fields;
5487 for(k=0;k<sfields->n;k++)
5493 bzero(dfield->fieldDecl,
sizeof(
struct FieldDecl));
5497 isrecord = in_IStable(*source,k,(Stack *)ctx->__IS, is_source);
5498 isInitialize = isrecord && (isrecord->mode == PKW_initializeOnly || isrecord->mode == PKW_inputOutput);
5504 union anyVrml *source_field, *dest_field;
5508 sp = ctx->__protoDef;
5509 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5510 if(sdecl->fieldString)
5511 dfield->ASCIIvalue = STRDUP(sdecl->fieldString);
5512 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5520 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5521 dest_field = (
union anyVrml*)&(dfield->value);
5523 shallow_copy_field(sdecl->type, source_field, dest_field);
5524 registerParentIfManagedField(sdecl->type, sdecl->mode, 1, dest_field, *dest);
5527 if(sfield->ASCIIvalue)
5528 dfield->ASCIIvalue = STRDUP(sfield->ASCIIvalue);
5530 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5533 dfield->value = sfield->value;
5537 if(sfield->fieldDecl->PKWmode == PKW_initializeOnly || sfield->fieldDecl->PKWmode == PKW_inputOutput){
5538 union anyVrml *source_field, *dest_field;
5539 source_field = (
union anyVrml*)&(sfield->value);
5540 dest_field = (
union anyVrml*)&(dfield->value);
5541 copy_field(dfield->fieldDecl->fieldType,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5543 dfield->valueSet = sfield->valueSet;
5548 else if(shaderfield && !strcmp(FIELDNAMES[field->nameIndex],
"_shaderUserDefinedFields") )
5565 void **dshaderfield;
5570 dshaderfield = shaderFields(*dest);
5572 dp = new_Shader_ScriptB(*dest);
5573 (*dshaderfield) = (
void*) dp;
5574 dp->loaded = sp->loaded;
5576 sfields = sp->fields;
5577 for(k=0;k<sfields->n;k++)
5583 bzero(dfield->fieldDecl,
sizeof(
struct FieldDecl));
5587 isrecord = in_IStable(*source,k,(Stack *)ctx->__IS, is_source);
5588 isInitialize = isrecord && (isrecord->mode == PKW_initializeOnly || isrecord->mode == PKW_inputOutput);
5594 union anyVrml *source_field, *dest_field;
5598 sp = ctx->__protoDef;
5599 sdecl = protoDefinition_getFieldByNum(sp, isrecord->iprotofield);
5600 if(sdecl->fieldString)
5601 dfield->ASCIIvalue = STRDUP(sdecl->fieldString);
5602 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5610 source_field = (
union anyVrml*)&(sdecl->defaultVal);
5611 dest_field = (
union anyVrml*)&(dfield->value);
5613 shallow_copy_field(sdecl->type, source_field, dest_field);
5614 registerParentIfManagedField(sdecl->type, sdecl->mode, 1, dest_field, *dest);
5617 if(sfield->ASCIIvalue)
5618 dfield->ASCIIvalue = STRDUP(sfield->ASCIIvalue);
5620 memcpy(dfield->fieldDecl,sfield->fieldDecl,
sizeof(
struct FieldDecl));
5623 dfield->value = sfield->value;
5627 if(sfield->fieldDecl->PKWmode == PKW_initializeOnly || sfield->fieldDecl->PKWmode == PKW_inputOutput){
5628 union anyVrml *source_field, *dest_field;
5629 source_field = (
union anyVrml*)&(sfield->value);
5630 dest_field = (
union anyVrml*)&(dfield->value);
5631 copy_field(dfield->fieldDecl->fieldType,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5633 dfield->valueSet = sfield->valueSet;
5640 if( FIELDNAMES[field->nameIndex][0] !=
'_'){
5641 union anyVrml *source_field, *dest_field;
5642 source_field = (
union anyVrml*)&((
char*)*source)[field->offset];
5643 dest_field = (
union anyVrml*)&((
char*)*dest )[field->offset];
5651 copy_field(field->typeIndex,source_field,dest_field,p2p,instancedScripts,ctx,parent);
5655 field = &offsets[ifield];
5658 if((*source)->_nodeType == NODE_Proto)
5664 unsigned char pdepthflag;
5665 pdest = X3D_PROTO(*dest);
5668 pdepthflag = ciflag_get(ctx->__protoFlags,0);
5669 pdest->__protoFlags = ciflag_set(pdest->__protoFlags,pdepthflag,0);
5674int nextScriptHandle (
void);
5681 ss->num = nextScriptHandle();
5685 for(j=0;j<ss->fields->n;j++)
5700 script_initCodeFromMFUri(ss, url);
5703void initialize_scripts(Stack *instancedScripts)
5732 if(instancedScripts)
5741 n = instancedScripts->n;
5744 p = vector_get(
struct X3D_Node*,instancedScripts,i);
5747 ss = sn->__scriptObj;
5749 initialize_one_script(ss,&sn->url);
5754 ss->num = nextScriptHandle();
5758 for(j=0;j<ss->fields->n;j++)
5764 scriptFieldDecl_jsFieldInit(field, ss->num);
5772 script_initCodeFromMFUri(ss, &sn->url);
5807 struct X3D_Proto *scenePlaceholderProto;
5811 Stack *instancedScripts = newStack(
struct X3D_Node*);
5812 children = childrenField(sceneInstance);
5815 parent = (
struct X3D_Node*)sceneInstance;
5816 scenePlaceholderProto = createNewX3DNode0(NODE_Proto);
5824 copy_field(FIELDTYPE_MFNode,(
union anyVrml*)&(sceneProto->__children),(
union anyVrml*)children,
5825 p2p,instancedScripts,scenePlaceholderProto,parent);
5828 copy_routes(sceneProto->__ROUTES, NULL, p2p);
5830 copy_IS(sceneProto->__IS, NULL, p2p);
5832 copy_defnames(sceneProto->__DEFnames, NULL, p2p);
5834 initialize_scripts(instancedScripts);
5882BOOL nodeTypeSupportsUserFields(
struct X3D_Node *node)
5885 user = node->_nodeType == NODE_Proto || node->_nodeType == NODE_Script ||
5886 node->_nodeType == NODE_ComposedShader || node->_nodeType == NODE_ShaderProgram ||
5887 node->_nodeType == NODE_PackagedShader || node->_nodeType == NODE_Effect ? TRUE : FALSE;
5892const char *rootFieldName(
const char* fieldname,
int* len,
int *has_changed,
int *has_set)
5899 static char* str_changed =
"_changed";
5901 static int len_changed = 8;
5902 static int len_set = 4;
5907 ln = (int) strlen(fieldname);
5909 *has_changed = ln > len_changed ? !strncmp(&fieldname[ln-len_changed],str_changed,len_changed) : FALSE;
5910 *has_set = ln > len_set ? !strncmp(fieldname,
"set_",len_set) : FALSE;
5911 s = *has_set ? &fieldname[len_set] : fieldname;
5912 *len = *has_changed? (int)(&fieldname[ln - len_changed] - s) : (int)(&fieldname[ln] - s);
5915BOOL fieldSynonymCompare(
const char *routeFieldName,
const char* nodeFieldName)
5920 int lr,hsr,hcr,ln,hsn,hcn;
5921 const char *rf, *nf;
5923 if(!strcmp(routeFieldName,nodeFieldName) )
return FALSE;
5926 rf = rootFieldName(routeFieldName,&lr,&hsr,&hcr);
5927 nf = rootFieldName(nodeFieldName, &ln,&hsn,&hcn);
5929 if(lr != ln)
return TRUE;
5930 if(strncmp(rf,nf,lr))
return TRUE;
5953 case PKW_initializeOnly:
5954 iret = PKW_initializeOnly;
break;
5955 case PKW_exposedField:
5956 case PKW_inputOutput:
5957 iret = PKW_inputOutput;
break;
5960 iret = PKW_inputOnly;
break;
5962 case PKW_outputOnly:
5963 iret = PKW_outputOnly;
break;
5965 printf(
"ouch from X3DMODE\n");
5971BOOL walk_fields(
struct X3D_Node* node,
int (*callbackFunc)(),
void* callbackData);
5973BOOL walk_fields(
struct X3D_Node* node, BOOL (*callbackFunc)(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
5974 const char *fieldName, indexT mode, indexT type,
int isource,BOOL publicfield),
void* callbackData);
5986BOOL cbExactName(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
5989 s_cbDataExactName *cbd = (s_cbDataExactName*)callbackData;
5990 found = !strcmp(fieldName,cbd->fname);
5992 cbd->fieldValue = fieldPtr;
5993 cbd->fname = fieldName;
5994 cbd->jfield = jfield;
5997 cbd->publicfield = publicfield;
5998 cbd->source = source;
6003 int *imode,
int *itype,
char* nodeFieldName,
int *isource,
void** fdecl,
int *ifield)
6005 int found, prototest11_x3dv;
6006 prototest11_x3dv = TRUE;
6007 s_cbDataExactName cbd;
6008 cbd.fname = nodeFieldName;
6009 found = walk_fields(node,cbExactName,&cbd);
6011 *anyptr = cbd.fieldValue;
6014 *isource = cbd.source;
6015 *ifield = cbd.jfield;
6016 }
else if(prototest11_x3dv){
6019 nf = rootFieldName(nodeFieldName, &ln,&hcn,&hsn);
6024 found = walk_fields(node,cbExactName,&cbd);
6026 *anyptr = cbd.fieldValue;
6029 *isource = cbd.source;
6030 *ifield = cbd.jfield;
6036 char rootname[MAXJSVARIABLELENGTH];
6037 strncpy(rootname,nodeFieldName,ln);
6038 rootname[ln] =
'\0';
6039 cbd.fname = rootname;
6040 found = walk_fields(node,cbExactName,&cbd);
6042 *anyptr = cbd.fieldValue;
6045 *isource = cbd.source;
6046 *ifield = cbd.jfield;
6066} s_cbDataRootNameAndRouteDir;
6068BOOL cbRootNameAndRouteDir(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6072 s_cbDataRootNameAndRouteDir *cbd = (s_cbDataRootNameAndRouteDir*)callbackData;
6073 found = !fieldSynonymCompare(fieldName,cbd->fname) ? TRUE : FALSE;
6074 found = found && (mode == cbd->PKW_eventType || mode == PKW_inputOutput);
6076 cbd->fname = fieldName;
6077 cbd->jfield = jfield;
6080 cbd->publicfield = publicfield;
6081 cbd->source = source;
6085BOOL cbExactNameAndRouteDir(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6089 s_cbDataRootNameAndRouteDir *cbd = (s_cbDataRootNameAndRouteDir*)callbackData;
6090 found = !strcmp(fieldName,cbd->fname) ? TRUE : FALSE;
6091 found = found && (mode == cbd->PKW_eventType || mode == PKW_inputOutput);
6093 cbd->fname = fieldName;
6094 cbd->jfield = jfield;
6097 cbd->publicfield = publicfield;
6098 cbd->source = source;
6102BOOL find_anyfield_by_nameAndRouteDir(
struct X3D_Node* node,
union anyVrml **anyptr,
6103 int *imode,
int *itype,
char* nodeFieldName,
int *isource,
void** fdecl,
int *ifield,
int PKW_eventType)
6106 s_cbDataRootNameAndRouteDir cbd;
6107 cbd.fname = nodeFieldName;
6108 cbd.PKW_eventType = PKW_eventType;
6109 found = walk_fields(node,cbExactNameAndRouteDir,&cbd);
6111 found = walk_fields(node,cbRootNameAndRouteDir,&cbd);
6113 *anyptr = cbd.fieldValue;
6116 *isource = cbd.source;
6117 *ifield = cbd.jfield;
6123BOOL cbCountFields(
void *callbackData,
struct X3D_Node* node,
int jfield,
union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6126 int *count = (
int*)callbackData;
6130int count_fields(
struct X3D_Node* node)
6135 walk_fields(node,cbCountFields,&count);
6139void **shaderFields(
struct X3D_Node* node);
6141int getFieldFromNodeAndName0(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
6142 int *iifield,
int *builtIn,
union anyVrml **value,
int *iunca,
const char **cname){
6151 shaderfield = shaderFields(node);
6154 if(node->_nodeType == NODE_Script)
6166 sfields = sp->fields;
6167 for(k=0;k<sfields->n;k++)
6172 fdecl = sfield->fieldDecl;
6173 fieldName = fieldDecl_getShaderScriptName(fdecl);
6174 if(!strcmp(fieldName,fieldname)){
6175 *type = fdecl->fieldType;
6176 *kind = fdecl->PKWmode;
6177 *value = &(sfield->value);
6185 else if(shaderfield)
6195 sfields = sp->fields;
6196 for(k=0;k<sfields->n;k++)
6201 fdecl = sfield->fieldDecl;
6202 fieldName = fieldDecl_getShaderScriptName(fdecl);
6203 if(!strcmp(fieldName,fieldname)){
6204 *type = fdecl->fieldType;
6205 *kind = fdecl->PKWmode;
6206 *value = &(sfield->value);
6213 }
else if(node->_nodeType == NODE_Proto) {
6220 for(k=0; k!=vectorSize(pstruct->iface); ++k)
6222 const char *fieldName;
6225 fieldName = pfield->cname;
6226 if(!strcmp(fieldName,fieldname)){
6227 *type = pfield->type;
6228 *kind = pfield->mode;
6230 *value = &(pfield->defaultVal);
6255 offsets = (fieldinfo)NODE_OFFSETS[node->_nodeType];
6257 field = &offsets[ifield];
6258 while( field->nameIndex > -1)
6260 if(!strcmp(FIELDNAMES[field->nameIndex],fieldname)){
6262 *type = field->typeIndex;
6264 switch(field->ioType){
6265 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6266 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6267 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6268 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6273 *value = (
union anyVrml*)&((
char*)node)[field->offset];
6274 *iunca = field->unca;
6275 *cname = FIELDNAMES[field->nameIndex];
6279 field = &offsets[ifield];
6284int getFieldFromNodeAndNameU(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
int* builtIn,
union anyVrml **value,
int *iunca,
const char **cname){
6286 ifound = getFieldFromNodeAndName0(node,fieldname,type,kind,iifield,builtIn,value,iunca,cname);
6290 nf = rootFieldName(fieldname, &ln,&hcn,&hsn);
6294 ifound = getFieldFromNodeAndName0(node,nf,type,kind,iifield,builtIn,value,iunca,cname);
6299 char rootname[MAXJSVARIABLELENGTH];
6300 memcpy(rootname,fieldname,ln);
6301 rootname[ln] =
'\0';
6302 ifound = getFieldFromNodeAndName0(node,rootname,type,kind,iifield,builtIn,value,iunca,cname);
6307int getFieldFromNodeAndName(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
union anyVrml **value){
6311 const char *cname = NULL;
6312 ifound = getFieldFromNodeAndNameU(node,fieldname,type,kind,iifield,&builtIn,value,&iunca,&cname);
6315int getFieldFromNodeAndNameC(
struct X3D_Node* node,
const char *fieldname,
int *type,
int *kind,
int *iifield,
int *builtIn,
union anyVrml **value,
const char **cname){
6318 ifound = getFieldFromNodeAndNameU(node,fieldname,type,kind,iifield,builtIn,value,&iunca,cname);
6322int getFieldFromNodeAndIndex(
struct X3D_Node* node,
int ifield,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value){
6328 if(node->_nodeType == NODE_Script )
6342 sfields = sp->fields;
6345 if(k > -1 && k < sfields->n)
6349 fdecl = sfield->fieldDecl;
6350 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6351 *type = fdecl->fieldType;
6352 *kind = fdecl->PKWmode;
6353 *value = &(sfield->value);
6357 }
else if(node->_nodeType == NODE_Proto ) {
6365 if(k > -1 && k < vectorSize(pstruct->iface))
6369 *fieldname = pfield->cname;
6370 *type = pfield->type;
6371 *kind = pfield->mode;
6372 if(pfield->mode == PKW_initializeOnly || pfield->mode == PKW_inputOutput)
6373 *value = &(pfield->defaultVal);
6396 offsets = (fieldinfo)NODE_OFFSETS[node->_nodeType];
6399 if(kfield >= offsets[0].offset){
6401 while(offsets[k].nameIndex > -1){
6402 if(ifield == offsets[k].offset){
6409 for(k=0;k<=kfield;k++)
6410 if(offsets[k].nameIndex == -1)
return 0;
6411 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6412 *type = offsets[kfield].typeIndex;
6414 switch(offsets[kfield].ioType){
6415 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6416 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6417 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6418 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6421 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6426int getFieldFromNodeAndIterator(
struct X3D_Node* node,
int ifield,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value,
int *builtIn){
6433 if(node->_nodeType == NODE_Script )
6447 sfields = sp->fields;
6451 if(k > -1 && k < nuser)
6455 fdecl = sfield->fieldDecl;
6456 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6457 *type = fdecl->fieldType;
6458 *kind = fdecl->PKWmode;
6459 *value = &(sfield->value);
6465 }
else if(node->_nodeType == NODE_Proto ) {
6473 nuser = vectorSize(pstruct->iface);
6474 if(k > -1 && k < nuser)
6478 *fieldname = pfield->cname;
6479 *type = pfield->type;
6480 *kind = pfield->mode;
6483 *value = &(pfield->defaultVal);
6504 int kfield, nbuiltin;
6507 offsets = (fieldinfo)NODE_OFFSETS[node->_nodeType];
6510 kfield = ifield - nuser;
6511 for(k=0;k<=kfield;k++)
6512 if(offsets[k].nameIndex == -1)
return -1;
6513 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6514 *type = offsets[kfield].typeIndex;
6517 switch(offsets[kfield].ioType){
6518 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6519 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6520 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6521 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6524 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6530int getFieldFromNodeAndIndexSource(
struct X3D_Node* node,
int ifield,
int builtIn,
const char **fieldname,
int *type,
int *kind,
union anyVrml **value){
6537 if(node->_nodeType == NODE_Script && !builtIn)
6551 sfields = sp->fields;
6555 if(k > -1 && k < nuser)
6559 fdecl = sfield->fieldDecl;
6560 *fieldname = fieldDecl_getShaderScriptName(fdecl);
6561 *type = fdecl->fieldType;
6562 *kind = fdecl->PKWmode;
6563 *value = &(sfield->value);
6567 }
else if(node->_nodeType == NODE_Proto && !builtIn ) {
6575 nuser = vectorSize(pstruct->iface);
6576 if(k > -1 && k < nuser)
6580 *fieldname = pfield->cname;
6581 *type = pfield->type;
6582 *kind = pfield->mode;
6584 *value = &(pfield->defaultVal);
6607 offsets = (fieldinfo)NODE_OFFSETS[node->_nodeType];
6611 if(kfield >= offsets[0].offset){
6613 while(offsets[k].nameIndex > -1){
6614 if(ifield == offsets[k].offset){
6621 for(k=0;k<=kfield;k++)
6622 if(offsets[k].nameIndex == -1)
return -1;
6623 *fieldname = FIELDNAMES[offsets[kfield].nameIndex];
6624 *type = offsets[kfield].typeIndex;
6626 switch(offsets[kfield].ioType){
6627 case KW_initializeOnly: kkind = PKW_initializeOnly;
break;
6628 case KW_inputOnly: kkind = PKW_inputOnly;
break;
6629 case KW_outputOnly: kkind = PKW_outputOnly;
break;
6630 case KW_inputOutput: kkind = PKW_inputOutput;
break;
6633 *value = (
union anyVrml*)&((
char*)node)[offsets[kfield].offset];
6640void broto_store_IS(
struct X3D_Proto *proto,
char *protofieldname,
int pmode,
int iprotofield,
int pBuiltIn,
int type,
6641 struct X3D_Node *node,
char* nodefieldname,
int mode,
int ifield,
int nBuiltIn,
int source)
6648 is->protofieldname = strdup(protofieldname);
6650 is->iprotofield = iprotofield;
6651 is->pBuiltIn = pBuiltIn;
6654 is->nodefieldname = strdup(nodefieldname);
6656 is->ifield = ifield;
6657 is->builtIn = nBuiltIn;
6658 is->source = source;
6662 ISs = newStack(
struct brotoIS *);
6665 stack_push(
struct brotoIS *, ISs, is);
6679 int source, builtIn, pbuiltIn;
6680 int ifield, iprotofield;
6683 char *protoFieldName;
6684 char *nodeFieldName;
6687 BOOL foundProtoField;
6692 const char* pname = NULL;
6699 if(!lexer_setCurID(me->lexer))
return FALSE;
6700 ASSERT(me->lexer->curID);
6701 nodeFieldName = STRDUP(me->lexer->curID);
6703 FREE_IF_NZ(me->lexer->curID);
6718 foundField = find_anyfield_by_name(me->lexer, node, &fieldPtr, &mode, &type, nodeFieldName, &source, &fdecl, &ifield);
6723 FREE_IF_NZ(nodeFieldName);
6729 if(!lexer_keyword(me->lexer, KW_IS)) {
6731 FREE_IF_NZ(nodeFieldName);
6738 if(!lexer_setCurID(me->lexer))
return FALSE;
6739 ASSERT(me->lexer->curID);
6740 protoFieldName = STRDUP(me->lexer->curID);
6741 FREE_IF_NZ(me->lexer->curID);
6757 foundProtoField = FALSE;
6762 const char* pname = NULL;
6765 if(!strcasecmp(protoFieldName,
"metadata")){
6767 foundProtoField = getFieldFromNodeAndNameC(X3D_NODE(proto),protoFieldName,&ptype, &pmode, &iprotofield, &pbuiltIn, &defaultPtr, &pname);
6769 for(i=0; i!=vectorSize(pdef->iface); ++i)
6774 foundProtoField = !strcmp(pname,protoFieldName) ? TRUE : FALSE;
6775 if(foundProtoField ) {
6782 defaultPtr = &f->defaultVal;
6787 if( !foundProtoField ){
6788 ConsoleMessage(
"Parser error: no matching protoField for %s IS %s\n",
6789 nodeFieldName,protoFieldName);
6790 FREE_IF_NZ(me->lexer->curID);
6792 FREE_IF_NZ(nodeFieldName);
6793 FREE_IF_NZ(protoFieldName);
6798 if(!pname) pname =
"";
6799 ConsoleMessage(
"Parser error: IS - we have a name match: %s IS %s found protofield %s\n",
6800 nodeFieldName,protoFieldName,pname);
6801 ConsoleMessage(
"...But the types don't match: nodefield %s protofield %s\n",
6802 FIELDTYPES[type],FIELDTYPES[ptype]);
6803 FREE_IF_NZ(me->lexer->curID);
6805 FREE_IF_NZ(nodeFieldName);
6806 FREE_IF_NZ(protoFieldName);
6821 if(X3DMODE(mode) != PKW_inputOutput && X3DMODE(mode) != X3DMODE(pmode)){
6822 if(X3DMODE(pmode) != PKW_inputOutput){
6823 ConsoleMessage(
"Parser Error: IS - we have a name match: %s IS %s found protofield %s\n",
6824 nodeFieldName,protoFieldName,f->fieldString);
6825 ConsoleMessage(
"...But the modes don't jive: nodefield %s protofield %s\n",
6826 PROTOKEYWORDS[mode],PROTOKEYWORDS[pmode]);
6827 FREE_IF_NZ(me->lexer->curID);
6829 FREE_IF_NZ(nodeFieldName);
6830 FREE_IF_NZ(protoFieldName);
6833 ConsoleMessage(
"Parser Warning: IS - we have a name match: %s IS %s found protofield %s\n",
6834 nodeFieldName,protoFieldName,pname);
6835 ConsoleMessage(
"...But the modes don't jive: nodefield %s protofield %s\n",
6836 PROTOKEYWORDS[mode],PROTOKEYWORDS[pmode]);
6837 ConsoleMessage(
"...will thunk\n");
6844 if(X3DMODE(pmode) == PKW_initializeOnly || X3DMODE(pmode) == PKW_inputOutput)
6855 shallow_copy_field(type, defaultPtr , fieldPtr);
6868 builtIn = source ? FALSE : TRUE;
6869 broto_store_IS(proto,protoFieldName,X3DMODE(f->mode),iprotofield,pbuiltIn,type,
6870 node,nodeFieldName,X3DMODE(mode),ifield,builtIn,source);
6879 FREE_IF_NZ(nodeFieldName);
6880 FREE_IF_NZ(protoFieldName);
6891resource_item_t * resLibraryAlreadyRequested(resource_item_t *res){
6898 ulr = librarySearch(res->URLrequest);
6899 if(ulr)
return ulr->three;
6905#define LOAD_INITIAL_STATE 0
6906#define LOAD_REQUEST_RESOURCE 1
6907#define LOAD_FETCHING_RESOURCE 2
6909#define LOAD_STABLE 10
6938void load_externProtoDeclare (
struct X3D_Proto *node) {
6939 resource_item_t *res, *res2;
6943 char flagInstance, flagExtern;
6944 flagInstance = ciflag_get(node->__protoFlags,2);
6945 flagExtern = ciflag_get(node->__protoFlags,3);
6946 if(flagInstance == 0 && flagExtern == 1) {
6949 switch (node->__loadstatus) {
6950 case LOAD_INITIAL_STATE:
6952 if (node->url.n == 0) {
6953 node->__loadstatus = LOAD_STABLE;
6956 res = resource_create_multi(&(node->url));
6957 res->media_type = resm_unknown;
6958 node->__loadstatus = LOAD_REQUEST_RESOURCE;
6959 node->__loadResource = res;
6963 case LOAD_REQUEST_RESOURCE:
6964 res = node->__loadResource;
6965 resource_identify(node->_parentResource, res);
6966 node->__afterPound = (
void*)res->afterPoundCharacters;
6969 if(node->__afterPound)
6970 res2 = resLibraryAlreadyRequested(res);
6972 node->__loadResource = res2;
6977 res->actions = resa_download | resa_load;
6978 pushInputResource(res);
6979 libraryScene = createNewX3DNode0(NODE_Proto);
6981 res->ectx = (
void*)libraryScene;
6982 res->whereToPlaceData = X3D_NODE(libraryScene);
6983 res->offsetFromWhereToPlaceData = offsetof (
struct X3D_Proto, __children);
6984 addLibrary(res->URLrequest,libraryScene,res);
6985 resitem_enqueue(ml_new(res));
6987 node->__loadstatus = LOAD_FETCHING_RESOURCE;
6990 case LOAD_FETCHING_RESOURCE:
6991 res = node->__loadResource;
6995 if (res->status == ress_loaded) {
6996 res->actions = resa_process;
6997 res->complete = FALSE;
6998 resitem_enqueue(ml_new(res));
6999 }
else if ((res->status == ress_failed) || (res->status == ress_invalid)) {
7001 printf (
"resource failed to load\n");
7002 node->__loadstatus = LOAD_STABLE;
7003 }
else if (res->status == ress_parsed) {
7006 struct X3D_Proto *libraryScene = res->whereToPlaceData;
7007 if(node->__externProtoDeclares == NULL)
7008 node->__externProtoDeclares = newVector(
struct X3D_Proto*,1);
7009 vector_pushBack(
struct X3D_Proto*,node->__externProtoDeclares,libraryScene);
7011 if(node->__externProtoDeclares){
7012 int n = vectorSize(node->__externProtoDeclares);
7014 struct X3D_Proto *libraryScene = vector_get(
struct X3D_Proto*,node->__externProtoDeclares,0);
7015 if(libraryScene->__protoDeclares){
7016 int m = vectorSize(libraryScene->__protoDeclares);
7023 if(node->__afterPound){
7025 char *
typename, *matchstring;
7027 matchstring = node->__afterPound;
7028 pDefinition = vector_get(
struct X3D_Proto*,libraryScene->__protoDeclares,k);
7029 typename = (
char *)pDefinition->__typename;
7031 if(!strcmp(matchstring,
typename)){
7034 node->__protoDeclares = newVector(
struct X3D_Proto*,1);
7035 vector_pushBack(
struct X3D_Proto*,node->__protoDeclares,pDefinition);
7041 pDefinition = vector_get(
struct X3D_Proto*,libraryScene->__protoDeclares,0);
7042 node->__protoDeclares = newVector(
struct X3D_Proto*,1);
7043 vector_pushBack(
struct X3D_Proto*,node->__protoDeclares,pDefinition);
7049 node->__loadstatus = LOAD_STABLE;
7061void load_externProtoInstance (
struct X3D_Proto *node) {
7066 char flagInstance, flagExtern;
7067 flagInstance = ciflag_get(node->__protoFlags,2);
7068 flagExtern = ciflag_get(node->__protoFlags,3);
7069 if(flagInstance == 1 && flagExtern == 1) {
7071 if(node->__children.n)
return;
7072 pnode = (
struct X3D_Proto*)node->__prototype;
7074 if(pnode->__loadstatus != LOAD_STABLE){
7076 load_externProtoDeclare(pnode);
7078 if(pnode->__loadstatus == LOAD_STABLE){
7080 if(pnode->__protoDeclares){
7081 int n = vectorSize(pnode->__protoDeclares);
7085 pdeclare = vector_get(
struct X3D_Proto*,pnode->__protoDeclares,0);
7086 pinstance = brotoInstance(pdeclare,1);
7087 if (pinstance != NULL) {
7092 pushInputResource(pinstance->_parentResource);
7093 ed = node->__protoDef;
7095 pd = pinstance->__protoDef;
7097 add_node_to_broto_context(node,X3D_NODE(pinstance));
7102 char *ename, *pname;
7107 for(i=0;i<ei->n;i++){
7108 ef = protoDefinition_getFieldByNum(ed, i);
7110 for(j=0;j<pi->n;j++){
7111 pf = protoDefinition_getFieldByNum(pd, j);
7113 if(!strcmp(ename,pname) || !fieldSynonymCompare(ename,pname)){
7116 if(ef->type == pf->type){
7120 broto_store_IS(node,ef->cname,ef->mode, i, FALSE, ef->type, X3D_NODE(pinstance), pf->cname, pf->mode, j, FALSE, 3);
7129 p2pentry.pp = X3D_NODE(pinstance);
7130 p2pentry.pn = X3D_NODE(pinstance);
7132 copy_IS(node->__IS, node, p2p);
7139 Stack *istable = (Stack*) node->__IS;
7141 for(i=0;i<istable->n;i++)
7145 is = vector_get(
struct brotoIS*, istable, i);
7146 if(is->pmode == PKW_inputOutput || is->pmode == PKW_initializeOnly){
7147 ef = protoDefinition_getFieldByNum(ed, is->iprotofield);
7148 pf = protoDefinition_getFieldByNum(pd, is->ifield);
7149 if(ef->alreadySet ){
7151 shallow_copy_field(is->type, &ef->defaultVal, &pf->defaultVal);
7152 pf->alreadySet = TRUE;
7158 deep_copy_broto_body2(&pdeclare,&pinstance);
7159 nnode = X3D_NODE(pinstance);
7160 AddRemoveChildren(X3D_NODE(node), &node->__children, &nnode, 1, 1,__FILE__,__LINE__);
7181 if(context && hasContext(X3D_NODE(context))){
7183 if(!context->__nodes)
7184 context->__nodes = newVector(
struct X3D_Node*,4);
7185 __nodes = context->__nodes;
7186 node->_executionContext = (
struct X3D_Node*)context;
7187 stack_push(
struct X3D_Node*,__nodes,node);
7188 if(hasContext(node)){
7190 if(!context->__subcontexts)
7191 context->__subcontexts = newVector(
struct X3D_Node*,4);
7192 __subctxs = context->__subcontexts;
7193 stack_push(
struct X3D_Node*,__subctxs,node);
7197void remove_node_from_broto_context(
struct X3D_Proto *context,
struct X3D_Node *node){
7207 if(context && hasContext(X3D_NODE(context))){
7208 if(context->__nodes){
7210 for(i=0;i<vectorSize(context->__nodes);i++){
7213 vector_remove_elem(
struct X3D_Node*,context->__nodes,i);
7218 if(context->__subcontexts && hasContext(node) ){
7220 for(i=0;i<vectorSize(context->__subcontexts);i++){
7221 struct X3D_Node *ns = vector_get(
struct X3D_Node*,context->__subcontexts,i);
7223 vector_remove_elem(
struct X3D_Node*,context->__subcontexts,i);
7230void lock_and_do_routes_register();
7231int unregister_broutes(
struct X3D_Proto * node){
7234 if(node && hasContext(X3D_NODE(node))){
7235 unsigned char depthflag = ciflag_get(node->__protoFlags,0);
7241 for(i=0;i<vectorSize(node->__ROUTES);i++){
7242 route = vector_get(
struct brotoRoute*,node->__ROUTES,i);
7243 if(route && route->lastCommand){
7244 CRoutes_RemoveSimpleB(route->from.node,route->from.ifield,route->from.builtIn,route->to.node,route->to.ifield,route->to.builtIn,route->ft);
7245 route->lastCommand = 0;
7252 lock_and_do_routes_register();
7261void unRegisterTexture(
struct X3D_Node *tmp);
7262void unRegisterBindable (
struct X3D_Node *node);
7263void remove_OSCsensor(
struct X3D_Node * node);
7264void remove_picksensor(
struct X3D_Node * node);
7265void delete_first(
struct X3D_Node *node);
7266void removeNodeFromKeySensorList(
struct X3D_Node* node);
7267int unInitializeScript(
struct X3D_Node *node);
7268void delete_geomrep(
struct X3D_Node* node);
7269void delete_glbuffers(
struct X3D_Node *node);
7270void unRegisterGeoElevationGrid(
struct X3D_Node *node);
7272int unRegisterX3DAnyNode(
struct X3D_Node *node){
7300 unRegisterTexture(node);
7302 unRegisterX3DNode(node);
7304 unRegisterBindable(node);
7306 unRegisterGeoElevationGrid(node);
7308 remove_OSCsensor(node);
7310 remove_picksensor(node);
7314 removeNodeFromKeySensorList(X3D_NODE(node));
7317 unInitializeScript(node);
7320 delete_geomrep(node);
7321 delete_glbuffers(node);
7324int print_broto_stats(
int level,
struct X3D_Proto *node){
7327 for(i=0;i<level;i++)
7329 spaces[level] =
'\0';
7330 nr = node->__ROUTES ? vectorSize(node->__ROUTES) : 0;
7331 nn = node->__nodes ? vectorSize(node->__nodes) : 0;
7332 nc = node->__subcontexts ? vectorSize(node->__subcontexts) : 0;
7334 printf(
"%sctx=%p routes=%d nodes=%d subcontexts=%d\n",spaces,node,nr,nn,nc);
7336 int nextlevel = level + 1;
7339 print_broto_stats(nextlevel,sc);
7345int unregister_broto_instance(
struct X3D_Proto* node){
7362 if(node && hasContext(X3D_NODE(node))){
7363 unsigned char depthflag = ciflag_get(node->__protoFlags,0);
7367 if(node->__subcontexts){
7369 for(i=0;i<vectorSize(node->__subcontexts);i++){
7371 unregister_broto_instance(subcontext);
7375 unregister_IStableRoutes((Stack*)node->__IS, node);
7377 unregister_broutes(node);
7384 for(i=0;i<vectorSize(node->__nodes);i++){
7386 unRegisterX3DAnyNode(ns);
7387 broto_clear_DEF_by_node(node,ns);
7395int gc_broto_instance(
struct X3D_Proto* node){
7406 if(node && hasContext(X3D_NODE(node))){
7407 node->__children.n = 0;
7408 node->_sortedChildren.n = 0;
7409 if(node->__subcontexts){
7411 for(i=0;i<vectorSize(node->__subcontexts);i++){
7412 subctx = vector_get(
struct X3D_Proto*,node->__subcontexts,i);
7413 gc_broto_instance(subctx);
7415 deleteVector(
struct X3D_Proto*,node->__subcontexts);
7419 for(i=0;i<vectorSize(node->__ROUTES);i++){
7424 deleteVector(
struct brotoRoute *, node->__ROUTES);
7428 deleteVector(
struct X3D_Node *,node->__scripts);
7431 for(i=0;i<vectorSize(node->__IS);i++) {
7435 deleteVector(
struct brotoIS *,node->__IS);
7438 if(node->__DEFnames) {
7439 for(i=0;i<vectorSize(node->__DEFnames);i++) {
7441 FREE_IF_NZ(def.name);
7447 deleteVector(
struct EXIMPORT *,node->__IMPORTS);
7450 deleteVector(
struct EXIMPORT *,node->__EXPORTS);
7460 int crash_challenge = 1;
7461 if(crash_challenge) {
7462 for(i=0;i<vectorSize(node->__nodes);i++){
7463 nx = vector_get(
struct X3D_Node*,node->__nodes,i);
7464 freeMallocedNodeFields(nx);
7468 deleteVector(
struct X3D_Node *,node->__nodes);
7470 if(node->__protoDeclares){
7473 char flagInstance, flagExtern;
7474 flagInstance = ciflag_get(node->__protoFlags,2);
7475 flagExtern = ciflag_get(node->__protoFlags,3);
7476 if(!(flagExtern && !flagInstance))
7477 for(i=0;i<vectorSize(node->__protoDeclares);i++){
7478 subctx = vector_get(
struct X3D_Proto*,node->__protoDeclares,i);
7480 gc_broto_instance(subctx);
7481 freeMallocedNodeFields(X3D_NODE(subctx));
7484 deleteVector(
void*,node->__protoDeclares);
7486 if(node->__externProtoDeclares){
7489 char flagInstance, flagExtern;
7490 flagInstance = ciflag_get(node->__protoFlags,2);
7491 flagExtern = ciflag_get(node->__protoFlags,3);
7492 if(!(flagExtern && !flagInstance))
7493 for(i=0;i<vectorSize(node->__externProtoDeclares);i++){
7497 subctx = vector_get(
struct X3D_Proto*,node->__externProtoDeclares,i);
7498 gc_broto_instance(subctx);
7499 freeMallocedNodeFields(X3D_NODE(subctx));
7502 deleteVector(
void*,node->__externProtoDeclares);
7508int unload_broto(
struct X3D_Proto* node){
7531 if(node && hasContext(X3D_NODE(node))){
7533 unregister_broto_instance(node);
7534 gc_broto_instance(node);
7542 if(context && hasContext(X3D_NODE(context))){
7543 if(context->__ROUTES){
7545 nr = vectorSize(context->__ROUTES);
7549 route = vector_get(
struct brotoRoute*,context->__ROUTES,ii);
7550 if(route->from.node == node || route->to.node == node){
7551 if( route->lastCommand){
7552 CRoutes_RemoveSimpleB(route->from.node,route->from.ifield,route->from.builtIn, route->to.node,route->to.ifield,route->to.builtIn,route->ft);
7553 route->lastCommand = 0;
7555 vector_remove_elem(
struct X3D_Node*,context->__ROUTES,ii);
7567 if(context && hasContext(X3D_NODE(context))){
7568 if(node && hasContext(node))
7569 unload_broto(X3D_PROTO(node));
7570 unRegisterX3DAnyNode(node);
7571 unRegisterNodeRoutes(context,node);
7572 remove_node_from_broto_context(context,node);