33#include <libFreeWRL.h>
39#include "../vrml_parser/Structs.h"
40#include "../main/headers.h"
41#include "../vrml_parser/CParseGeneral.h"
42#include "../scenegraph/Vector.h"
43#include "../vrml_parser/CFieldDecls.h"
44#include "../world_script/JScript.h"
45#include "../world_script/CScripts.h"
46#include "../vrml_parser/CParseParser.h"
47#include "../vrml_parser/CParseLexer.h"
48#include "EAIHeaders.h"
49#include "EAIHelpers.h"
55}* ppEAI_C_CommonFunctions;
56void *EAI_C_CommonFunctions_constructor()
63void EAI_C_CommonFunctions_init(
struct tEAI_C_CommonFunctions* t){
65 t->eaiverbose = FALSE;
67 t->prv = EAI_C_CommonFunctions_constructor();
71#define PST_MF_STRUCT_ELEMENT(type1,type2) \
72 case FIELDTYPE_MF##type1: { \
73 struct Multi_##type1 *myv; \
74 myv = (struct Multi_##type1 *) nst; \
76 myv->p = myVal.mf##type2.p; \
77 myv->n = myVal.mf##type2.n; \
82#define PST_SF_SIMPLE_ELEMENT(type1,type2,size3) \
83 case FIELDTYPE_SF##type1: { \
84 memcpy(nst, &myVal.sf##type2, size3); \
89struct Uni_String *newASCIIString(
const char *str) {
92 int eaiverbose = gglobal()->EAI_C_CommonFunctions.eaiverbose;
95 printf (
"newASCIIString for :%s:\n",str);
100 len = (int) strlen(str);
102 retval->strptr = MALLOC (
char *,
sizeof(
char) * len+1);
103 memcpy(retval->strptr,str,len+1);
121 FREE_IF_NZ(us->strptr);
127 clearASCIIString(us);
134 for(i=0;i<ms->n;i++){
137 freeASCIIString(ms->p[i]);
150void verify_Uni_String(
struct Uni_String *unis,
const char *str) {
158 printf (
"Warning, verify_Uni_String, comparing to NULL Uni_String, %s\n",str);
164 unis->strptr = strdup(str);
166 if (strcmp(str,unis->strptr)!= 0) {
169 ns = MALLOC (
char *,len+1);
170 memcpy(ns,str,len+1);
181int returnElementLength(
int type) {
183 case FIELDTYPE_SFVec2d:
184 case FIELDTYPE_MFVec2d:
185 case FIELDTYPE_MFVec3d:
186 case FIELDTYPE_SFVec3d:
187 case FIELDTYPE_MFDouble:
188 case FIELDTYPE_SFDouble:
189 case FIELDTYPE_SFVec4d:
190 case FIELDTYPE_MFVec4d:
191 case FIELDTYPE_SFMatrix3d:
192 case FIELDTYPE_MFMatrix3d:
193 case FIELDTYPE_SFMatrix4d:
194 case FIELDTYPE_MFMatrix4d:
195 case FIELDTYPE_SFTime :
196 case FIELDTYPE_MFTime :
return (
int)
sizeof(double);
break;
197 case FIELDTYPE_SFImage:
198 case FIELDTYPE_MFInt32:
return (
int)
sizeof(int) ;
break;
199 case FIELDTYPE_FreeWRLPTR:
200 case FIELDTYPE_MFString:
201 case FIELDTYPE_SFString:
202 case FIELDTYPE_SFNode :
203 case FIELDTYPE_MFNode :
return (
int)
sizeof(
void *);
break;
206 return (
int)
sizeof(float) ;
214int returnRoutingElementLength(
int type) {
216 case FIELDTYPE_SFFloat:
return (
int)
sizeof(float);
break;
217 case FIELDTYPE_SFBool:
218 case FIELDTYPE_SFInt32:
return (
int)
sizeof(int);
break;
219 case FIELDTYPE_SFTime:
return (
int)
sizeof(double);
break;
220 case FIELDTYPE_SFDouble:
return (
int)
sizeof(double);
break;
221 case FIELDTYPE_SFNode:
return (
int)ROUTING_SFNODE;
break;
222 case FIELDTYPE_SFColor:
return (
int)
sizeof(
struct SFColor);
break;
223 case FIELDTYPE_SFColorRGBA:
return (
int)
sizeof(
struct SFColorRGBA);
break;
224 case FIELDTYPE_SFRotation:
return (
int)
sizeof(
struct SFRotation);
break;
225 case FIELDTYPE_SFVec2f:
return (
int)
sizeof (
struct SFVec2f);
break;
226 case FIELDTYPE_SFVec3f:
return (
int)
sizeof(
struct SFVec3f);
break;
227 case FIELDTYPE_SFVec4f:
return (
int)
sizeof(
struct SFVec4f);
break;
228 case FIELDTYPE_SFVec2d:
return (
int)
sizeof(
struct SFVec2d);
break;
229 case FIELDTYPE_SFVec3d:
return (
int)
sizeof (
struct SFVec3d);
break;
230 case FIELDTYPE_SFVec4d:
return (
int)
sizeof(
struct SFVec4d);
break;
231 case FIELDTYPE_SFString:
return (
int)ROUTING_SFSTRING;
break;
232 case FIELDTYPE_SFImage:
return (
int)ROUTING_SFIMAGE;
break;
234 case FIELDTYPE_SFMatrix3f:
return (
int)
sizeof (
struct SFMatrix3f);
break;
235 case FIELDTYPE_SFMatrix4f:
return (
int)
sizeof(
struct SFMatrix4f);
break;
236 case FIELDTYPE_SFMatrix3d:
return (
int)
sizeof (
struct SFMatrix3d);
break;
237 case FIELDTYPE_SFMatrix4d:
return (
int)
sizeof(
struct SFMatrix4d);
break;
239 case FIELDTYPE_MFFloat:
return (
int)ROUTING_MFFLOAT;
break;
240 case FIELDTYPE_MFBool:
241 case FIELDTYPE_MFInt32:
return (
int)ROUTING_MFINT32;
break;
242 case FIELDTYPE_MFTime:
return (
int)ROUTING_MFDOUBLE;
break;
243 case FIELDTYPE_MFDouble:
return (
int)ROUTING_MFDOUBLE;
break;
244 case FIELDTYPE_MFNode:
return (
int) ROUTING_MFNODE;
break;
245 case FIELDTYPE_MFColor:
return (
int)ROUTING_MFCOLOR;
break;
246 case FIELDTYPE_MFColorRGBA:
return (
int)ROUTING_MFROTATION;
break;
247 case FIELDTYPE_MFRotation:
return (
int)ROUTING_MFROTATION;
break;
248 case FIELDTYPE_MFVec2f:
return (
int) ROUTING_MFVEC2F;
break;
249 case FIELDTYPE_MFVec3f:
return (
int) ROUTING_MFVEC3F;
break;
250 case FIELDTYPE_MFVec4f:
return (
int) ROUTING_MFVEC4F;
break;
251 case FIELDTYPE_MFVec2d:
return (
int)ROUTING_MFVEC2D;
break;
252 case FIELDTYPE_MFVec3d:
return (
int)ROUTING_MFVEC3D;
break;
253 case FIELDTYPE_MFVec4d:
return (
int) ROUTING_MFVEC4D;
break;
254 case FIELDTYPE_MFString:
return (
int)ROUTING_MFSTRING;
break;
255 case FIELDTYPE_MFMatrix3f:
return (
int) ROUTING_MFMATRIX3F;
break;
256 case FIELDTYPE_MFMatrix3d:
return (
int) ROUTING_MFMATRIX3D;
break;
257 case FIELDTYPE_MFMatrix4f:
return (
int)ROUTING_MFMATRIX4F;
break;
258 case FIELDTYPE_MFMatrix4d:
return (
int)ROUTING_MFMATRIX4D;
break;
261 printf (
"warning - returnRoutingElementLength not a handled type, %d\n",type);
264 return (
int)
sizeof(int);
271int returnElementRowSize (
int type) {
273 case FIELDTYPE_SFVec2f:
274 case FIELDTYPE_MFVec2f:
275 case FIELDTYPE_SFVec2d:
276 case FIELDTYPE_MFVec2d:
278 case FIELDTYPE_SFColor:
279 case FIELDTYPE_MFColor:
280 case FIELDTYPE_SFVec3f:
281 case FIELDTYPE_SFVec3d:
282 case FIELDTYPE_MFVec3f:
283 case FIELDTYPE_MFVec3d:
284 case FIELDTYPE_SFImage:
286 case FIELDTYPE_SFRotation:
287 case FIELDTYPE_MFRotation:
288 case FIELDTYPE_SFVec4d:
289 case FIELDTYPE_SFVec4f:
290 case FIELDTYPE_MFVec4d:
291 case FIELDTYPE_MFVec4f:
292 case FIELDTYPE_SFColorRGBA:
293 case FIELDTYPE_MFColorRGBA:
295 case FIELDTYPE_MFMatrix3f:
296 case FIELDTYPE_SFMatrix3f:
297 case FIELDTYPE_MFMatrix3d:
298 case FIELDTYPE_SFMatrix3d:
300 case FIELDTYPE_MFMatrix4f:
301 case FIELDTYPE_SFMatrix4f:
302 case FIELDTYPE_MFMatrix4d:
303 case FIELDTYPE_SFMatrix4d:
329int isSForMFType(
int itype){
336 case FIELDTYPE_SFFloat:
337 case FIELDTYPE_SFRotation:
338 case FIELDTYPE_SFVec3f:
339 case FIELDTYPE_SFBool:
340 case FIELDTYPE_SFInt32:
341 case FIELDTYPE_SFNode:
342 case FIELDTYPE_SFColor:
343 case FIELDTYPE_SFColorRGBA:
344 case FIELDTYPE_SFTime:
345 case FIELDTYPE_SFString:
346 case FIELDTYPE_SFVec2f:
347 case FIELDTYPE_SFImage:
348 case FIELDTYPE_SFVec3d:
349 case FIELDTYPE_SFDouble:
350 case FIELDTYPE_SFMatrix3f:
351 case FIELDTYPE_SFMatrix3d:
352 case FIELDTYPE_SFMatrix4f:
353 case FIELDTYPE_SFMatrix4d:
354 case FIELDTYPE_SFVec2d:
355 case FIELDTYPE_SFVec4f:
356 case FIELDTYPE_SFVec4d:
360 case FIELDTYPE_MFFloat:
361 case FIELDTYPE_MFRotation:
362 case FIELDTYPE_MFVec3f:
363 case FIELDTYPE_MFBool:
364 case FIELDTYPE_MFInt32:
365 case FIELDTYPE_MFNode:
366 case FIELDTYPE_MFColor:
367 case FIELDTYPE_MFColorRGBA:
368 case FIELDTYPE_MFTime:
369 case FIELDTYPE_MFString:
370 case FIELDTYPE_MFVec2f:
371 case FIELDTYPE_MFImage:
372 case FIELDTYPE_MFVec3d:
373 case FIELDTYPE_MFDouble:
374 case FIELDTYPE_MFMatrix3f:
375 case FIELDTYPE_MFMatrix3d:
376 case FIELDTYPE_MFMatrix4f:
377 case FIELDTYPE_MFMatrix4d:
378 case FIELDTYPE_MFVec2d:
379 case FIELDTYPE_MFVec4f:
380 case FIELDTYPE_MFVec4d:
387int type2SF(
int itype){
389 int jtype, sformf = isSForMFType(itype);
390 if(sformf < 0)
return -1;
392 if(sformf == 1) jtype = mf2sf(itype);
395int isSFType(
int itype){
396 return (isSForMFType(itype) == 0) ? 1 : 0;
399int sizeofSForMF(
int itype){
404 case FIELDTYPE_SFFloat: iz =
sizeof(float);
break;
405 case FIELDTYPE_SFRotation: iz =
sizeof(
struct SFRotation);
break;
406 case FIELDTYPE_SFVec3f: iz =
sizeof(
struct SFVec3f);
break;
407 case FIELDTYPE_SFBool: iz =
sizeof(int);
break;
408 case FIELDTYPE_SFInt32: iz =
sizeof(int);
break;
409 case FIELDTYPE_SFNode: iz =
sizeof(
void*);
break;
410 case FIELDTYPE_SFColor: iz =
sizeof(
struct SFColor);
break;
411 case FIELDTYPE_SFColorRGBA: iz =
sizeof(
struct SFColorRGBA);
break;
412 case FIELDTYPE_SFTime: iz =
sizeof(double);
break;
413 case FIELDTYPE_SFString: iz =
sizeof(
struct Uni_String *);
break;
414 case FIELDTYPE_SFVec2f: iz =
sizeof(
struct SFVec2f);
break;
415 case FIELDTYPE_SFImage: iz =
sizeof(
struct SFImage);
break;
416 case FIELDTYPE_SFVec3d: iz =
sizeof(
struct SFVec3d);
break;
417 case FIELDTYPE_SFDouble: iz =
sizeof(double);
break;
418 case FIELDTYPE_SFMatrix3f: iz =
sizeof(
struct SFMatrix3f);
break;
419 case FIELDTYPE_SFMatrix3d: iz =
sizeof(
struct SFMatrix3d);
break;
420 case FIELDTYPE_SFMatrix4f: iz =
sizeof(
struct SFMatrix4f);
break;
421 case FIELDTYPE_SFMatrix4d: iz =
sizeof(
struct SFMatrix4d);
break;
422 case FIELDTYPE_SFVec2d: iz =
sizeof(
struct SFVec2d);
break;
423 case FIELDTYPE_SFVec4f: iz =
sizeof(
struct SFVec4f);
break;
424 case FIELDTYPE_SFVec4d: iz =
sizeof(
struct SFVec4d);
break;
426 case FIELDTYPE_MFImage:
427 case FIELDTYPE_MFFloat:
428 case FIELDTYPE_MFRotation:
429 case FIELDTYPE_MFVec3f:
430 case FIELDTYPE_MFBool:
431 case FIELDTYPE_MFInt32:
432 case FIELDTYPE_MFNode:
433 case FIELDTYPE_MFColor:
434 case FIELDTYPE_MFColorRGBA:
435 case FIELDTYPE_MFTime:
436 case FIELDTYPE_MFString:
437 case FIELDTYPE_MFVec2f:
438 case FIELDTYPE_MFVec3d:
439 case FIELDTYPE_MFDouble:
440 case FIELDTYPE_MFMatrix3f:
441 case FIELDTYPE_MFMatrix3d:
442 case FIELDTYPE_MFMatrix4f:
443 case FIELDTYPE_MFMatrix4d:
444 case FIELDTYPE_MFVec2d:
445 case FIELDTYPE_MFVec4f:
446 case FIELDTYPE_MFVec4d:
456int sizeofSF(
int itype){
458 int sformf = isSForMFType(itype);
459 if( sformf < 0)
return 0;
461 if( sformf == 1 ) jtype = mf2sf(itype);
462 return sizeofSForMF(jtype);
469void Parser_deleteParserForScanStringValueToMem(
void) {
470 ppEAI_C_CommonFunctions p = (ppEAI_C_CommonFunctions)gglobal()->EAI_C_CommonFunctions.prv;
472 if (p->parser != NULL) {
473 lexer_destroyData(p->parser->lexer);
474 deleteParser(p->parser);
480void Parser_scanStringValueToMem(
struct X3D_Node *node,
size_t coffset, indexT ctype,
char *value,
int isXML) {
483 char *mfstringtmp = NULL;
486 struct VRMLParser *parser = ((ppEAI_C_CommonFunctions)gglobal()->EAI_C_CommonFunctions.prv)->parser;
487 #ifdef SETFIELDVERBOSE
488 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
495 if (parser == NULL) {
496 parser=newParser(NULL,NULL, 0, TRUE);
499 ((ppEAI_C_CommonFunctions)gglobal()->EAI_C_CommonFunctions.prv)->parser = parser;
502 lexer_forceStringCleanup(parser->lexer);
509 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
511 lexer_forceStringCleanup(parser->lexer);
519 oldXMLflag = parser->parsingX3DfromXML;
520 parser->parsingX3DfromXML = isXML;
523 if (ctype == FIELDTYPE_MFString) {
524 #ifdef SETFIELDVERBOSE
525 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
532 while ((*value ==
' ') && (*value !=
'\0')) value ++;
535 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
539 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
540 memcpy (&mfstringtmp[1],value,len);
541 mfstringtmp[0] =
'"';
542 mfstringtmp[len+1] =
'"';
543 mfstringtmp[len+2] =
'\0';
547 mfstringtmp = STRDUP(value);
549 parser_fromString(parser,mfstringtmp);
551 }
else if (ctype == FIELDTYPE_SFNode) {
553 np = getEAINodeFromTable(atoi(value), -1);
554 }
else if (ctype == FIELDTYPE_SFString) {
558 char *mv, *pv, *v = value;
559 while (*v && *v !=
'\0')
564 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
568 while(*v && *v !=
'\0')
571 if(!(pv && *pv ==
'\\')){
583 mfstringtmp = STRDUP(value);
585 parser_fromString(parser,mfstringtmp);
587 mfstringtmp = STRDUP(value);
588 parser_fromString(parser,mfstringtmp);
592 ASSERT(parser->lexer);
593 FREE_IF_NZ(parser->lexer->curID);
595 if (ctype == FIELDTYPE_SFNode) {
597 nst = offsetPointer_deref(
void *,node,coffset);
598 memcpy (&oldvalue, nst,
sizeof(
struct X3D_Node*));
600 remove_parent(oldvalue, node);
603 memcpy(nst, (
void*)&np,
sizeof(
struct X3D_Node*));
604 add_parent(np, node,
"sarah's add", 0);
606 }
else if (parseType(parser, ctype, &myVal)) {
608 nst = offsetPointer_deref(
void *,node,coffset);
616 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
617 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
618 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
619 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
620 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
621 PST_MF_STRUCT_ELEMENT(Color,color)
622 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
623 PST_MF_STRUCT_ELEMENT(Int32,int32)
624 PST_MF_STRUCT_ELEMENT(Float,
float)
625 PST_MF_STRUCT_ELEMENT(Double,
double)
626 PST_MF_STRUCT_ELEMENT(Bool,
bool)
627 PST_MF_STRUCT_ELEMENT(Time,time)
628 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
629 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
630 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
631 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
632 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
633 PST_MF_STRUCT_ELEMENT(String,
string)
635 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
636 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
637 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
638 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
639 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
640 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
641 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
642 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
643 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
644 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
645 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
646 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
647 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
648 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
649 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
650 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
651 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
652 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
653 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
654 PST_SF_SIMPLE_ELEMENT(Image,image,
sizeof(
struct Multi_Int32))
656 case FIELDTYPE_SFString: {
658 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
671 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
672 lexer_forceStringCleanup(parser->lexer);
678 if (strlen (value) > 50) {
684 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
688 lexer_forceStringCleanup(parser->lexer);
691 parser->parsingX3DfromXML = oldXMLflag;
695void Parser_scanStringValueToMem_B(
union anyVrml* any, indexT ctype,
char *value,
int isXML)
702 char *mfstringtmp = NULL;
705 struct VRMLParser *parser = ((ppEAI_C_CommonFunctions)gglobal()->EAI_C_CommonFunctions.prv)->parser;
706 #ifdef SETFIELDVERBOSE
707 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
714 if (parser == NULL) {
715 parser=newParser(NULL,NULL, 0, TRUE);
718 ((ppEAI_C_CommonFunctions)gglobal()->EAI_C_CommonFunctions.prv)->parser = parser;
721 lexer_forceStringCleanup(parser->lexer);
728 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
730 lexer_forceStringCleanup(parser->lexer);
738 oldXMLflag = parser->parsingX3DfromXML;
739 parser->parsingX3DfromXML = isXML;
742 if (ctype == FIELDTYPE_MFString) {
743 #ifdef SETFIELDVERBOSE
744 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
751 while ((*value ==
' ') && (*value !=
'\0')) value ++;
754 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
755 static int MFS_warning_given = 0;
759 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
760 memcpy (&mfstringtmp[1],value,len);
761 mfstringtmp[0] =
'"';
762 mfstringtmp[len+1] =
'"';
763 mfstringtmp[len+2] =
'\0';
764 if(0)
if(!MFS_warning_given){
765 ConsoleMessage(
"Warning - an MFString needs internal quotes ie '%s' should be '%s'\n",value,mfstringtmp);
766 MFS_warning_given = 1;
771 mfstringtmp = STRDUP(value);
773 parser_fromString(parser,mfstringtmp);
775 }
else if (ctype == FIELDTYPE_SFNode) {
777 np = getEAINodeFromTable(atoi(value), -1);
778 }
else if (ctype == FIELDTYPE_SFString) {
782 char *mv, *pv, *v = value;
783 while (*v && *v !=
'\0')
788 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
792 while(*v && *v !=
'\0')
795 if(!(pv && *pv ==
'\\')){
807 mfstringtmp = STRDUP(value);
809 parser_fromString(parser,mfstringtmp);
811 mfstringtmp = STRDUP(value);
812 parser_fromString(parser,mfstringtmp);
816 ASSERT(parser->lexer);
817 FREE_IF_NZ(parser->lexer->curID);
819 if (ctype == FIELDTYPE_SFNode) {
826 memcpy(any, (
void*)&np,
sizeof(
struct X3D_Node*));
827 any->sfnode->_parentVector = NULL;
829 }
else if (parseType(parser, ctype, &myVal)) {
839 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
840 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
841 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
842 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
843 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
844 PST_MF_STRUCT_ELEMENT(Color,color)
845 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
846 PST_MF_STRUCT_ELEMENT(Int32,int32)
847 PST_MF_STRUCT_ELEMENT(Float,
float)
848 PST_MF_STRUCT_ELEMENT(Double,
double)
849 PST_MF_STRUCT_ELEMENT(Bool,
bool)
850 PST_MF_STRUCT_ELEMENT(Time,time)
851 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
852 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
853 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
854 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
855 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
856 PST_MF_STRUCT_ELEMENT(String,
string)
857 PST_MF_STRUCT_ELEMENT(Image, image)
859 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
860 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
861 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
862 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
863 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
864 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
865 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
866 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
867 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
868 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
869 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
870 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
871 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
872 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
873 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
874 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
875 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
876 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
877 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
878 case FIELDTYPE_SFImage:
879 printf(
"in case FIELDTYPE_SFImage\n");
881 memcpy(nst, &myVal.sfimage,
sizeof(
struct SFImage));
883 case FIELDTYPE_SFString: {
885 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
898 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
899 lexer_forceStringCleanup(parser->lexer);
905 if (strlen (value) > 50) {
911 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
915 lexer_forceStringCleanup(parser->lexer);
917 FREE_IF_NZ(mfstringtmp);
920 parser->parsingX3DfromXML = oldXMLflag;
923void Parser_scanStringValueToMem_C0(
struct VRMLParser *parser,
union anyVrml* any, indexT ctype,
char *value,
int isXML)
931 char *mfstringtmp = NULL;
934 #ifdef SETFIELDVERBOSE
935 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
942 if (parser == NULL) {
943 parser=newParser(NULL,NULL, 0, TRUE);
947 lexer_forceStringCleanup(parser->lexer);
954 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
956 lexer_forceStringCleanup(parser->lexer);
964 oldXMLflag = parser->parsingX3DfromXML;
965 parser->parsingX3DfromXML = isXML;
968 if (ctype == FIELDTYPE_MFString) {
969 #ifdef SETFIELDVERBOSE
970 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
977 while ((*value ==
' ') && (*value !=
'\0')) value ++;
980 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
984 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
985 memcpy (&mfstringtmp[1],value,len);
986 mfstringtmp[0] =
'"';
987 mfstringtmp[len+1] =
'"';
988 mfstringtmp[len+2] =
'\0';
992 mfstringtmp = STRDUP(value);
994 parser_fromString(parser,mfstringtmp);
996 }
else if (ctype == FIELDTYPE_SFNode) {
998 np = getEAINodeFromTable(atoi(value), -1);
999 }
else if (ctype == FIELDTYPE_SFString) {
1003 char *mv, *pv, *v = value;
1004 while (*v && *v !=
'\0')
1009 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
1013 while(*v && *v !=
'\0')
1016 if(!(pv && *pv ==
'\\')){
1028 mfstringtmp = STRDUP(value);
1030 parser_fromString(parser,mfstringtmp);
1032 mfstringtmp = STRDUP(value);
1033 parser_fromString(parser,mfstringtmp);
1037 ASSERT(parser->lexer);
1038 FREE_IF_NZ(parser->lexer->curID);
1040 if (ctype == FIELDTYPE_SFNode) {
1047 memcpy(any, (
void*)&np,
sizeof(
struct X3D_Node*));
1048 any->sfnode->_parentVector = NULL;
1050 }
else if (parseType(parser, ctype, &myVal)) {
1060 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
1061 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
1062 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
1063 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
1064 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
1065 PST_MF_STRUCT_ELEMENT(Color,color)
1066 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
1067 PST_MF_STRUCT_ELEMENT(Int32,int32)
1068 PST_MF_STRUCT_ELEMENT(Float,
float)
1069 PST_MF_STRUCT_ELEMENT(Double,
double)
1070 PST_MF_STRUCT_ELEMENT(Bool,
bool)
1071 PST_MF_STRUCT_ELEMENT(Time,time)
1072 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
1073 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
1074 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
1075 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
1076 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
1077 PST_MF_STRUCT_ELEMENT(String,
string)
1079 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
1080 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
1081 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
1082 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
1083 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
1084 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
1085 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
1086 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
1087 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
1088 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
1089 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
1090 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
1091 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
1092 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
1093 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
1094 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
1095 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
1096 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
1097 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
1098 PST_SF_SIMPLE_ELEMENT(Image,image,
sizeof(
struct Multi_Int32))
1100 case FIELDTYPE_SFString: {
1102 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
1115 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
1116 lexer_forceStringCleanup(parser->lexer);
1122 if (strlen (value) > 50) {
1128 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
1132 lexer_forceStringCleanup(parser->lexer);
1135 parser->parsingX3DfromXML = oldXMLflag;
1137void Parser_scanStringValueToMem_C(
void *any0,
int ctype0,
char *value,
int isXML)
1144 ctype = (indexT)ctype0;
1145 parser=newParser(NULL,NULL, 0, TRUE);
1146 Parser_scanStringValueToMem_C0(parser, any, ctype, value, isXML);
1147 if (parser != NULL) {
1148 lexer_destroyData(parser->lexer);
1149 deleteParser(parser);