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"
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_SFTime:
return (
int)
sizeof(double);
break;
217 case FIELDTYPE_SFBool:
218 case FIELDTYPE_SFInt32:
return (
int)
sizeof(int);
break;
219 case FIELDTYPE_SFFloat:
return (
int)
sizeof (float);
break;
220 case FIELDTYPE_SFVec2f:
return (
int)
sizeof (
struct SFVec2f);
break;
221 case FIELDTYPE_SFVec3f:
222 case FIELDTYPE_SFColor:
return (
int)
sizeof (
struct SFColor);
break;
223 case FIELDTYPE_SFVec3d:
return (
int)
sizeof (
struct SFVec3d);
break;
224 case FIELDTYPE_SFColorRGBA:
225 case FIELDTYPE_SFRotation:
return (
int)
sizeof (
struct SFRotation);
break;
226 case FIELDTYPE_SFNode:
return (
int) ROUTING_SFNODE;
break;
227 case FIELDTYPE_SFMatrix3f:
return (
int)
sizeof (
struct SFMatrix3f);
break;
228 case FIELDTYPE_SFMatrix3d:
return (
int)
sizeof (
struct SFMatrix3d);
break;
231 case FIELDTYPE_SFVec4f:
return (
int)
sizeof (
struct SFVec4f) ;
break;
233 case FIELDTYPE_SFMatrix4f:
return (
int)
sizeof (
struct SFMatrix4f);
break;
234 case FIELDTYPE_SFVec2d:
return (
int)
sizeof (
struct SFVec2d);
break;
235 case FIELDTYPE_SFDouble:
return (
int)
sizeof (double);
break;
236 case FIELDTYPE_SFVec4d:
return (
int)
sizeof (
struct SFVec4d);
break;
238 case FIELDTYPE_SFString:
return (
int) ROUTING_SFSTRING;
break;
239 case FIELDTYPE_SFImage:
return (
int) ROUTING_SFIMAGE;
break;
241 case FIELDTYPE_MFNode:
return (
int) ROUTING_MFNODE;
break;
242 case FIELDTYPE_MFString:
return (
int) ROUTING_MFSTRING;
break;
243 case FIELDTYPE_MFFloat:
return (
int) ROUTING_MFFLOAT;
break;
244 case FIELDTYPE_MFColorRGBA:
245 case FIELDTYPE_MFRotation:
return (
int) ROUTING_MFROTATION;
break;
246 case FIELDTYPE_MFBool:
247 case FIELDTYPE_MFInt32:
return (
int) ROUTING_MFINT32;
break;
248 case FIELDTYPE_MFColor:
return (
int) ROUTING_MFCOLOR;
break;
249 case FIELDTYPE_MFVec2f:
return (
int) ROUTING_MFVEC2F;
break;
250 case FIELDTYPE_MFVec3f:
return (
int) ROUTING_MFVEC3F;
break;
251 case FIELDTYPE_MFVec3d:
return (
int) ROUTING_MFVEC3D;
break;
252 case FIELDTYPE_MFDouble:
return (
int) ROUTING_MFDOUBLE;
break;
253 case FIELDTYPE_MFTime:
return (
int) ROUTING_MFDOUBLE;
break;
254 case FIELDTYPE_MFMatrix4f:
return (
int) ROUTING_MFMATRIX4F;
break;
255 case FIELDTYPE_MFMatrix4d:
return (
int) ROUTING_MFMATRIX4D;
break;
256 case FIELDTYPE_MFVec2d:
return (
int) ROUTING_MFVEC2D;
break;
257 case FIELDTYPE_MFVec4f:
return (
int) ROUTING_MFVEC4F;
break;
258 case FIELDTYPE_MFVec4d:
return (
int) ROUTING_MFVEC4D;
break;
259 case FIELDTYPE_MFMatrix3f:
return (
int) ROUTING_MFMATRIX3F;
break;
260 case FIELDTYPE_MFMatrix3d:
return (
int) ROUTING_MFMATRIX3D;
break;
263 printf (
"warning - returnRoutingElementLength not a handled type, %d\n",type);
266 return (
int)
sizeof(int);
273int returnElementRowSize (
int type) {
275 case FIELDTYPE_SFVec2f:
276 case FIELDTYPE_MFVec2f:
277 case FIELDTYPE_SFVec2d:
278 case FIELDTYPE_MFVec2d:
280 case FIELDTYPE_SFColor:
281 case FIELDTYPE_MFColor:
282 case FIELDTYPE_SFVec3f:
283 case FIELDTYPE_SFVec3d:
284 case FIELDTYPE_MFVec3f:
285 case FIELDTYPE_MFVec3d:
286 case FIELDTYPE_SFImage:
288 case FIELDTYPE_SFRotation:
289 case FIELDTYPE_MFRotation:
290 case FIELDTYPE_SFVec4d:
291 case FIELDTYPE_SFVec4f:
292 case FIELDTYPE_MFVec4d:
293 case FIELDTYPE_MFVec4f:
294 case FIELDTYPE_SFColorRGBA:
295 case FIELDTYPE_MFColorRGBA:
297 case FIELDTYPE_MFMatrix3f:
298 case FIELDTYPE_SFMatrix3f:
299 case FIELDTYPE_MFMatrix3d:
300 case FIELDTYPE_SFMatrix3d:
302 case FIELDTYPE_MFMatrix4f:
303 case FIELDTYPE_SFMatrix4f:
304 case FIELDTYPE_MFMatrix4d:
305 case FIELDTYPE_SFMatrix4d:
317 if(itype == FIELDTYPE_SFImage)
318 return FIELDTYPE_SFInt32;
331int isSForMFType(
int itype){
338 case FIELDTYPE_SFFloat:
339 case FIELDTYPE_SFRotation:
340 case FIELDTYPE_SFVec3f:
341 case FIELDTYPE_SFBool:
342 case FIELDTYPE_SFInt32:
343 case FIELDTYPE_SFNode:
344 case FIELDTYPE_SFColor:
345 case FIELDTYPE_SFColorRGBA:
346 case FIELDTYPE_SFTime:
347 case FIELDTYPE_SFString:
348 case FIELDTYPE_SFVec2f:
350 case FIELDTYPE_SFVec3d:
351 case FIELDTYPE_SFDouble:
352 case FIELDTYPE_SFMatrix3f:
353 case FIELDTYPE_SFMatrix3d:
354 case FIELDTYPE_SFMatrix4f:
355 case FIELDTYPE_SFMatrix4d:
356 case FIELDTYPE_SFVec2d:
357 case FIELDTYPE_SFVec4f:
358 case FIELDTYPE_SFVec4d:
362 case FIELDTYPE_MFFloat:
363 case FIELDTYPE_MFRotation:
364 case FIELDTYPE_MFVec3f:
365 case FIELDTYPE_MFBool:
366 case FIELDTYPE_MFInt32:
367 case FIELDTYPE_MFNode:
368 case FIELDTYPE_MFColor:
369 case FIELDTYPE_MFColorRGBA:
370 case FIELDTYPE_MFTime:
371 case FIELDTYPE_MFString:
372 case FIELDTYPE_MFVec2f:
373 case FIELDTYPE_SFImage:
374 case FIELDTYPE_MFVec3d:
375 case FIELDTYPE_MFDouble:
376 case FIELDTYPE_MFMatrix3f:
377 case FIELDTYPE_MFMatrix3d:
378 case FIELDTYPE_MFMatrix4f:
379 case FIELDTYPE_MFMatrix4d:
380 case FIELDTYPE_MFVec2d:
381 case FIELDTYPE_MFVec4f:
382 case FIELDTYPE_MFVec4d:
389int type2SF(
int itype){
391 int jtype, sformf = isSForMFType(itype);
392 if(sformf < 0)
return -1;
394 if(sformf == 1) jtype = mf2sf(itype);
397int isSFType(
int itype){
398 return (isSForMFType(itype) == 0) ? 1 : 0;
400#define FIELDTYPE_MFImage 43
401int sizeofSForMF(
int itype){
406 case FIELDTYPE_SFFloat: iz =
sizeof(float);
break;
407 case FIELDTYPE_SFRotation: iz =
sizeof(
struct SFRotation);
break;
408 case FIELDTYPE_SFVec3f: iz =
sizeof(
struct SFVec3f);
break;
409 case FIELDTYPE_SFBool: iz =
sizeof(int);
break;
410 case FIELDTYPE_SFInt32: iz =
sizeof(int);
break;
411 case FIELDTYPE_SFNode: iz =
sizeof(
void*);
break;
412 case FIELDTYPE_SFColor: iz =
sizeof(
struct SFColor);
break;
413 case FIELDTYPE_SFColorRGBA: iz =
sizeof(
struct SFColorRGBA);
break;
414 case FIELDTYPE_SFTime: iz =
sizeof(double);
break;
415 case FIELDTYPE_SFString: iz =
sizeof(
struct Uni_String *);
break;
416 case FIELDTYPE_SFVec2f: iz =
sizeof(
struct SFVec2f);
break;
418 case FIELDTYPE_SFVec3d: iz =
sizeof(
struct SFVec3d);
break;
419 case FIELDTYPE_SFDouble: iz =
sizeof(double);
break;
420 case FIELDTYPE_SFMatrix3f: iz =
sizeof(
struct SFMatrix3f);
break;
421 case FIELDTYPE_SFMatrix3d: iz =
sizeof(
struct SFMatrix3d);
break;
422 case FIELDTYPE_SFMatrix4f: iz =
sizeof(
struct SFMatrix4f);
break;
423 case FIELDTYPE_SFMatrix4d: iz =
sizeof(
struct SFMatrix4d);
break;
424 case FIELDTYPE_SFVec2d: iz =
sizeof(
struct SFVec2d);
break;
425 case FIELDTYPE_SFVec4f: iz =
sizeof(
struct SFVec4f);
break;
426 case FIELDTYPE_SFVec4d: iz =
sizeof(
struct SFVec4d);
break;
428 case FIELDTYPE_SFImage:
429 case FIELDTYPE_MFFloat:
430 case FIELDTYPE_MFRotation:
431 case FIELDTYPE_MFVec3f:
432 case FIELDTYPE_MFBool:
433 case FIELDTYPE_MFInt32:
434 case FIELDTYPE_MFNode:
435 case FIELDTYPE_MFColor:
436 case FIELDTYPE_MFColorRGBA:
437 case FIELDTYPE_MFTime:
438 case FIELDTYPE_MFString:
439 case FIELDTYPE_MFVec2f:
440 case FIELDTYPE_MFImage:
441 case FIELDTYPE_MFVec3d:
442 case FIELDTYPE_MFDouble:
443 case FIELDTYPE_MFMatrix3f:
444 case FIELDTYPE_MFMatrix3d:
445 case FIELDTYPE_MFMatrix4f:
446 case FIELDTYPE_MFMatrix4d:
447 case FIELDTYPE_MFVec2d:
448 case FIELDTYPE_MFVec4f:
449 case FIELDTYPE_MFVec4d:
459int sizeofSF(
int itype){
461 int sformf = isSForMFType(itype);
462 if( sformf < 0)
return 0;
464 if( sformf == 1 ) jtype = mf2sf(itype);
465 return sizeofSForMF(jtype);
472void Parser_deleteParserForScanStringValueToMem(
void) {
475 if (p->parser != NULL) {
476 lexer_destroyData(p->parser->lexer);
477 deleteParser(p->parser);
483void Parser_scanStringValueToMem(
struct X3D_Node *node,
size_t coffset, indexT ctype,
char *value,
int isXML) {
486 char *mfstringtmp = NULL;
490 #ifdef SETFIELDVERBOSE
491 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
498 if (parser == NULL) {
499 parser=newParser(NULL,NULL, 0, TRUE);
505 lexer_forceStringCleanup(parser->lexer);
512 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
514 lexer_forceStringCleanup(parser->lexer);
522 oldXMLflag = parser->parsingX3DfromXML;
523 parser->parsingX3DfromXML = isXML;
526 if (ctype == FIELDTYPE_MFString) {
527 #ifdef SETFIELDVERBOSE
528 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
535 while ((*value ==
' ') && (*value !=
'\0')) value ++;
538 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
542 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
543 memcpy (&mfstringtmp[1],value,len);
544 mfstringtmp[0] =
'"';
545 mfstringtmp[len+1] =
'"';
546 mfstringtmp[len+2] =
'\0';
550 mfstringtmp = STRDUP(value);
552 parser_fromString(parser,mfstringtmp);
554 }
else if (ctype == FIELDTYPE_SFNode) {
556 np = getEAINodeFromTable(atoi(value), -1);
557 }
else if (ctype == FIELDTYPE_SFString) {
561 char *mv, *pv, *v = value;
562 while (*v && *v !=
'\0')
567 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
571 while(*v && *v !=
'\0')
574 if(!(pv && *pv ==
'\\')){
586 mfstringtmp = STRDUP(value);
588 parser_fromString(parser,mfstringtmp);
590 mfstringtmp = STRDUP(value);
591 parser_fromString(parser,mfstringtmp);
595 ASSERT(parser->lexer);
596 FREE_IF_NZ(parser->lexer->curID);
598 if (ctype == FIELDTYPE_SFNode) {
600 nst = offsetPointer_deref(
void *,node,coffset);
601 memcpy (&oldvalue, nst,
sizeof(
struct X3D_Node*));
603 remove_parent(oldvalue, node);
606 memcpy(nst, (
void*)&np,
sizeof(
struct X3D_Node*));
607 add_parent(np, node,
"sarah's add", 0);
609 }
else if (parseType(parser, ctype, &myVal)) {
611 nst = offsetPointer_deref(
void *,node,coffset);
619 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
620 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
621 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
622 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
623 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
624 PST_MF_STRUCT_ELEMENT(Color,color)
625 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
626 PST_MF_STRUCT_ELEMENT(Int32,int32)
627 PST_MF_STRUCT_ELEMENT(Float,
float)
628 PST_MF_STRUCT_ELEMENT(Double,
double)
629 PST_MF_STRUCT_ELEMENT(Bool,
bool)
630 PST_MF_STRUCT_ELEMENT(Time,time)
631 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
632 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
633 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
634 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
635 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
636 PST_MF_STRUCT_ELEMENT(String,
string)
638 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
639 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
640 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
641 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
642 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
643 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
644 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
645 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
646 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
647 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
648 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
649 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
650 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
651 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
652 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
653 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
654 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
655 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
656 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
657 PST_SF_SIMPLE_ELEMENT(Image,image,
sizeof(
struct Multi_Int32))
659 case FIELDTYPE_SFString: {
661 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
674 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
675 lexer_forceStringCleanup(parser->lexer);
681 if (strlen (value) > 50) {
687 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
691 lexer_forceStringCleanup(parser->lexer);
694 parser->parsingX3DfromXML = oldXMLflag;
698void Parser_scanStringValueToMem_B(
union anyVrml* any, indexT ctype,
char *value,
int isXML)
705 char *mfstringtmp = NULL;
709 #ifdef SETFIELDVERBOSE
710 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
717 if (parser == NULL) {
718 parser=newParser(NULL,NULL, 0, TRUE);
724 lexer_forceStringCleanup(parser->lexer);
731 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
733 lexer_forceStringCleanup(parser->lexer);
741 oldXMLflag = parser->parsingX3DfromXML;
742 parser->parsingX3DfromXML = isXML;
745 if (ctype == FIELDTYPE_MFString) {
746 #ifdef SETFIELDVERBOSE
747 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
754 while ((*value ==
' ') && (*value !=
'\0')) value ++;
757 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
758 static int MFS_warning_given = 0;
762 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
763 memcpy (&mfstringtmp[1],value,len);
764 mfstringtmp[0] =
'"';
765 mfstringtmp[len+1] =
'"';
766 mfstringtmp[len+2] =
'\0';
767 if(0)
if(!MFS_warning_given){
768 ConsoleMessage(
"Warning - an MFString needs internal quotes ie '%s' should be '%s'\n",value,mfstringtmp);
769 MFS_warning_given = 1;
774 mfstringtmp = STRDUP(value);
776 parser_fromString(parser,mfstringtmp);
778 }
else if (ctype == FIELDTYPE_SFNode) {
780 np = getEAINodeFromTable(atoi(value), -1);
781 }
else if (ctype == FIELDTYPE_SFString) {
785 char *mv, *pv, *v = value;
786 while (*v && *v !=
'\0')
791 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
795 while(*v && *v !=
'\0')
798 if(!(pv && *pv ==
'\\')){
810 mfstringtmp = STRDUP(value);
812 parser_fromString(parser,mfstringtmp);
814 mfstringtmp = STRDUP(value);
815 parser_fromString(parser,mfstringtmp);
819 ASSERT(parser->lexer);
820 FREE_IF_NZ(parser->lexer->curID);
822 if (ctype == FIELDTYPE_SFNode) {
829 memcpy(any, (
void*)&np,
sizeof(
struct X3D_Node*));
830 any->sfnode->_parentVector = NULL;
832 }
else if (parseType(parser, ctype, &myVal)) {
842 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
843 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
844 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
845 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
846 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
847 PST_MF_STRUCT_ELEMENT(Color,color)
848 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
849 PST_MF_STRUCT_ELEMENT(Int32,int32)
850 PST_MF_STRUCT_ELEMENT(Float,
float)
851 PST_MF_STRUCT_ELEMENT(Double,
double)
852 PST_MF_STRUCT_ELEMENT(Bool,
bool)
853 PST_MF_STRUCT_ELEMENT(Time,time)
854 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
855 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
856 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
857 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
858 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
859 PST_MF_STRUCT_ELEMENT(String,
string)
861 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
862 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
863 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
864 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
865 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
866 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
867 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
868 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
869 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
870 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
871 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
872 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
873 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
874 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
875 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
876 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
877 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
878 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
879 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
880 PST_SF_SIMPLE_ELEMENT(Image,image,
sizeof(
struct Multi_Int32))
882 case FIELDTYPE_SFString: {
884 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
897 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
898 lexer_forceStringCleanup(parser->lexer);
904 if (strlen (value) > 50) {
910 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
914 lexer_forceStringCleanup(parser->lexer);
916 FREE_IF_NZ(mfstringtmp);
919 parser->parsingX3DfromXML = oldXMLflag;
922void Parser_scanStringValueToMem_C0(
struct VRMLParser *parser,
union anyVrml* any, indexT ctype,
char *value,
int isXML)
930 char *mfstringtmp = NULL;
933 #ifdef SETFIELDVERBOSE
934 printf (
"\nPST, for %s we have %s strlen %lu\n",stringFieldtypeType(ctype), value, strlen(value));
941 if (parser == NULL) {
942 parser=newParser(NULL,NULL, 0, TRUE);
946 lexer_forceStringCleanup(parser->lexer);
953 if ((ctype==FIELDTYPE_SFNode) || (ctype==FIELDTYPE_MFNode)) {
955 lexer_forceStringCleanup(parser->lexer);
963 oldXMLflag = parser->parsingX3DfromXML;
964 parser->parsingX3DfromXML = isXML;
967 if (ctype == FIELDTYPE_MFString) {
968 #ifdef SETFIELDVERBOSE
969 printf (
"parsing type %s, string :%s:\n",stringFieldtypeType(ctype),value);
976 while ((*value ==
' ') && (*value !=
'\0')) value ++;
979 if ((*value !=
'"') && (*value !=
'\'') && (*value !=
'[')) {
983 mfstringtmp = MALLOC (
char *,
sizeof (
char *) * len + 10);
984 memcpy (&mfstringtmp[1],value,len);
985 mfstringtmp[0] =
'"';
986 mfstringtmp[len+1] =
'"';
987 mfstringtmp[len+2] =
'\0';
991 mfstringtmp = STRDUP(value);
993 parser_fromString(parser,mfstringtmp);
995 }
else if (ctype == FIELDTYPE_SFNode) {
997 np = getEAINodeFromTable(atoi(value), -1);
998 }
else if (ctype == FIELDTYPE_SFString) {
1002 char *mv, *pv, *v = value;
1003 while (*v && *v !=
'\0')
1008 mfstringtmp = (
char *)MALLOC(
void *, strlen(value)+nq+1);
1012 while(*v && *v !=
'\0')
1015 if(!(pv && *pv ==
'\\')){
1027 mfstringtmp = STRDUP(value);
1029 parser_fromString(parser,mfstringtmp);
1031 mfstringtmp = STRDUP(value);
1032 parser_fromString(parser,mfstringtmp);
1036 ASSERT(parser->lexer);
1037 FREE_IF_NZ(parser->lexer->curID);
1039 if (ctype == FIELDTYPE_SFNode) {
1046 memcpy(any, (
void*)&np,
sizeof(
struct X3D_Node*));
1047 any->sfnode->_parentVector = NULL;
1049 }
else if (parseType(parser, ctype, &myVal)) {
1059 PST_MF_STRUCT_ELEMENT(Vec2f,vec2f)
1060 PST_MF_STRUCT_ELEMENT(Vec3f,vec3f)
1061 PST_MF_STRUCT_ELEMENT(Vec3d,vec3d)
1062 PST_MF_STRUCT_ELEMENT(Vec4d,vec4d)
1063 PST_MF_STRUCT_ELEMENT(Vec2d,vec2d)
1064 PST_MF_STRUCT_ELEMENT(Color,color)
1065 PST_MF_STRUCT_ELEMENT(ColorRGBA,colorrgba)
1066 PST_MF_STRUCT_ELEMENT(Int32,int32)
1067 PST_MF_STRUCT_ELEMENT(Float,
float)
1068 PST_MF_STRUCT_ELEMENT(Double,
double)
1069 PST_MF_STRUCT_ELEMENT(Bool,
bool)
1070 PST_MF_STRUCT_ELEMENT(Time,time)
1071 PST_MF_STRUCT_ELEMENT(Rotation,rotation)
1072 PST_MF_STRUCT_ELEMENT(Matrix3f,matrix3f)
1073 PST_MF_STRUCT_ELEMENT(Matrix3d,matrix3d)
1074 PST_MF_STRUCT_ELEMENT(Matrix4f,matrix4f)
1075 PST_MF_STRUCT_ELEMENT(Matrix4d,matrix4d)
1076 PST_MF_STRUCT_ELEMENT(String,
string)
1078 PST_SF_SIMPLE_ELEMENT(Float,
float,
sizeof(
float))
1079 PST_SF_SIMPLE_ELEMENT(Time,time,
sizeof(
double))
1080 PST_SF_SIMPLE_ELEMENT(Double,
double,
sizeof(
double))
1081 PST_SF_SIMPLE_ELEMENT(Int32,int32,
sizeof(
int))
1082 PST_SF_SIMPLE_ELEMENT(Bool,
bool,
sizeof(
int))
1083 PST_SF_SIMPLE_ELEMENT(Node,node,
sizeof(
void *))
1084 PST_SF_SIMPLE_ELEMENT(Vec2f,vec2f,
sizeof(
struct SFVec2f))
1085 PST_SF_SIMPLE_ELEMENT(Vec2d,vec2d,
sizeof(
struct SFVec2d))
1086 PST_SF_SIMPLE_ELEMENT(Vec3f,vec3f,
sizeof(
struct SFColor))
1087 PST_SF_SIMPLE_ELEMENT(Vec3d,vec3d,
sizeof(
struct SFVec3d))
1088 PST_SF_SIMPLE_ELEMENT(Vec4f,vec4f,
sizeof(
struct SFVec4f))
1089 PST_SF_SIMPLE_ELEMENT(Vec4d,vec4d,
sizeof(
struct SFVec4d))
1090 PST_SF_SIMPLE_ELEMENT(Rotation,rotation,
sizeof(
struct SFRotation))
1091 PST_SF_SIMPLE_ELEMENT(Color,color,
sizeof(
struct SFColor))
1092 PST_SF_SIMPLE_ELEMENT(ColorRGBA,colorrgba,
sizeof(
struct SFColorRGBA))
1093 PST_SF_SIMPLE_ELEMENT(Matrix3f,matrix3f,
sizeof(
struct SFMatrix3f))
1094 PST_SF_SIMPLE_ELEMENT(Matrix4f,matrix4f,
sizeof(
struct SFMatrix4f))
1095 PST_SF_SIMPLE_ELEMENT(Matrix3d,matrix3d,
sizeof(
struct SFMatrix3d))
1096 PST_SF_SIMPLE_ELEMENT(Matrix4d,matrix4d,
sizeof(
struct SFMatrix4d))
1097 PST_SF_SIMPLE_ELEMENT(Image,image,
sizeof(
struct Multi_Int32))
1099 case FIELDTYPE_SFString: {
1101 memcpy(nst, &myVal.sfstring,
sizeof(
struct Uni_String*));
1114 printf (
"unhandled type, in EAIParse %s\n",stringFieldtypeType(ctype));
1115 lexer_forceStringCleanup(parser->lexer);
1121 if (strlen (value) > 50) {
1127 ConsoleMessage (
"parser problem on parsing fieldType %s, string :%s:", stringFieldtypeType(ctype),value);
1131 lexer_forceStringCleanup(parser->lexer);
1134 parser->parsingX3DfromXML = oldXMLflag;
1136void Parser_scanStringValueToMem_C(
void *any0,
int ctype0,
char *value,
int isXML)
1143 ctype = (indexT)ctype0;
1144 parser=newParser(NULL,NULL, 0, TRUE);
1145 Parser_scanStringValueToMem_C0(parser, any, ctype, value, isXML);
1146 if (parser != NULL) {
1147 lexer_destroyData(parser->lexer);
1148 deleteParser(parser);