3 #if defined(ECERE_BOOTSTRAP)
9 default extern Platform runtimePlatform;
12 public define MAXBYTE = 0xff;
13 public define MAXWORD = 0xffff;
14 public define MININT = ((int)0x80000000);
15 public define MAXINT = ((int)0x7fffffff);
16 public define MININT64 = ((int64)0x8000000000000000LL);
17 public define MAXINT64 = ((int64)0x7fffffffffffffffLL);
18 public define MAXDWORD = 0xffffffff;
19 public define MAXQWORD = 0xffffffffffffffffLL;
20 public define MINFLOAT = ((float)1.17549435082228750e-38);
21 public define MAXFLOAT = ((float)3.40282346638528860e+38);
22 public define MINDOUBLE = ((double) 2.2250738585072014e-308);
23 public define MAXDOUBLE = ((double) 1.7976931348623158e+308);
25 public define FORMAT64HEXLL = (GetRuntimePlatform() == win32) ? "0x%I64XLL" : "0x%llXLL";
26 public define FORMAT64HEX = (GetRuntimePlatform() == win32) ? "0x%I64X" : "0x%llX";
27 public define FORMAT64DLL = (GetRuntimePlatform() == win32) ? "%I64dLL" : "%lldLL";
28 public define FORMAT64D = (GetRuntimePlatform() == win32) ? "%I64d" : "%lld";
29 public define FORMAT64U = (GetRuntimePlatform() == win32) ? "%I64u" : "%llu";
31 #define PUTXWORD(b, w) \
32 (b)[0] = (byte)(((w) >> 8) & 0xFF); \
33 (b)[1] = (byte)(((w) ) & 0xFF);
35 #define GETXWORD(b) (uint16)(((b)[0] << 8) | (b)[1])
37 #define PUTXDWORD(b, d) \
38 (b)[0] = (byte)(((d) >> 24) & 0xFF); \
39 (b)[1] = (byte)(((d) >> 16) & 0xFF); \
40 (b)[2] = (byte)(((d) >> 8) & 0xFF); \
41 (b)[3] = (byte)( (d) & 0xFF);
43 #define GETXDWORD(b) (uint32)(((b)[0] << 24) | ((b)[1] << 16) | ((b)[2] << 8) | (b)[3])
45 #define PUTXQWORD(b, d) \
46 (b)[0] = (byte)(((d) >> 56) & 0xFF); \
47 (b)[1] = (byte)(((d) >> 48) & 0xFF); \
48 (b)[2] = (byte)(((d) >> 40) & 0xFF); \
49 (b)[3] = (byte)(((d) >> 32) & 0xFF); \
50 (b)[4] = (byte)(((d) >> 24) & 0xFF); \
51 (b)[5] = (byte)(((d) >> 16) & 0xFF); \
52 (b)[6] = (byte)(((d) >> 8) & 0xFF); \
53 (b)[7] = (byte)( (d) & 0xFF);
55 #define GETXQWORD(b) (uint64)(((uint64)(b)[0] << 56) | ((uint64)(b)[1] << 48) | ((uint64)(b)[2] << 40) | ((uint64)(b)[3] << 32) | ((uint64)(b)[4] << 24) | ((b)[5] << 16) | ((b)[6] << 8) | (b)[7])
57 static void UnusedFunction()
65 a.OnEdit(null,null,0,0,0,0,0);
66 a.OnDisplay(null,0,0,0,0,0,0);
67 a.OnGetDataFromString(null);
71 extern int __ecereVMethodID_class_OnGetString;
72 extern int __ecereVMethodID_class_OnGetDataFromString;
73 extern int __ecereVMethodID_class_OnCompare;
74 extern int __ecereVMethodID_class_OnSerialize;
75 extern int __ecereVMethodID_class_OnUnserialize;
76 extern int __ecereVMethodID_class_OnCopy;
79 // TOFIX: Declaration ordering
80 dllexport void eSystem_Delete(void * memory);
82 public class IOChannel
85 virtual uint WriteData(byte * data, uint numBytes);
86 virtual uint ReadData(byte * data, uint numBytes);
88 dllexport void Serialize(typed_object data)
90 data.OnSerialize(this);
93 dllexport void Unserialize(typed_object & data)
95 data.OnUnserialize(this);
98 dllexport void Put(typed_object data)
100 data.OnSerialize(this);
103 dllexport void Get(typed_object & data)
105 data.OnUnserialize(this);
109 public class SerialBuffer : IOChannel
117 uint WriteData(byte * bytes, uint numBytes)
121 if(count + numBytes > _size)
123 _size = count + numBytes;
125 _buffer = renew _buffer byte[_size];
127 memcpy(_buffer + count, bytes, numBytes);
134 uint ReadData(byte * bytes, uint numBytes)
138 int read = Min(numBytes, count - pos);
139 memcpy(bytes, _buffer + pos, read);
151 dllexport void Free()
162 // TODO: THIS IS VERY BAD!
163 property byte * buffer
165 get { return _buffer + pos; }
166 set { _buffer = value; }
171 get { return count - pos; }
172 set { count = value; }
176 /*static */char * Enum_OnGetString(Class _class, int * data, char * tempString, void * fieldData, bool * needClass)
178 EnumClassData enumeration = (EnumClassData)_class.data;
180 for(item = enumeration.values.first; item; item = item.next)
181 if((int)item.data == *data)
185 strcpy(tempString, item.name);
186 if(!needClass || !*needClass)
187 tempString[0] = (char)toupper(tempString[0]);
195 static bool Enum_OnGetDataFromString(Class _class, int * data, char * string)
197 EnumClassData enumeration = (EnumClassData)_class.data;
199 for(item = enumeration.values.first; item; item = item.next)
201 if(item.name && !strcmpi(item.name, string))
206 *data = (int)item.data;
210 return Integer_OnGetDataFromString(_class, data, string);
214 static void OnFree(Class _class, void * data)
216 if(_class.templateClass) _class = _class.templateClass;
217 if(_class.type == normalClass)
219 // eInstance_Delete(data);
220 eInstance_DecRef(data);
222 else if(_class.type == noHeadClass && data)
224 while(_class && _class.type == noHeadClass)
226 if(_class.Destructor)
227 _class.Destructor(data);
228 _class = _class.base;
234 static int DataMember_OnCompare(DataMember parentMember, void * data1, void * data2)
237 Module module = parentMember._class.module;
238 for(member = parentMember.members.first; member; member = member.next)
240 int memberResult = 0;
241 if(member.type == normalMember)
243 Class memberType = member.dataTypeClass;
246 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
248 memberType = member.dataTypeClass = eSystem_FindClass(module, "int");
250 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
252 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType,
253 (byte *)data1 + member.offset,
254 (byte *)data2 + member.offset);
260 DataValue value1, value2;
261 value1.i = *(int *)((byte *)data1 + member.offset);
262 value2.i = *(int *)((byte *)data2 + member.offset);
263 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType, &value1, &value2);
270 memberResult = DataMember_OnCompare(member,
271 (byte *)data1 + member.offset,
272 (byte *)data2 + member.offset);
280 static int OnCompare(Class _class, void * data1, void * data2)
282 Module module = _class.module;
283 if(_class.type == normalClass || _class.type == noHeadClass || _class.type == structClass)
287 // NOTE: Comparing from top class down here... might want to reverse it
288 for(; _class && _class.type != systemClass; _class = _class.base)
292 // TESTING THIS HERE...
293 if(_class.noExpansion)
295 if(data1 > data2) return 1;
296 else if(data1 < data2) return -1;
301 for(member = _class.membersAndProperties.first; member; member = member.next)
303 int memberResult = 0;
304 if(member.isProperty || member.type == normalMember)
306 Class memberType = member.dataTypeClass;
309 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
312 memberType = member.dataTypeClass = eSystem_FindClass(module, "int");
316 if(member.isProperty)
318 Property prop = (Property)member;
319 if(!prop.conversion && prop.Get && prop.Set)
321 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
323 if(!strcmp(memberType.dataTypeString, "char *"))
325 String a = ((String(*)())(void *)prop.Get)(data1);
326 String b = ((String(*)())(void *)prop.Get)(data2);
327 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType, a, b);
332 DataValue value1, value2;
333 if(!strcmp(memberType.dataTypeString, "float"))
335 value1.f = ((float(*)())(void *)prop.Get)(data1);
336 value2.f = ((float(*)())(void *)prop.Get)(data2);
340 value1.i = prop.Get(data1);
341 value2.i = prop.Get(data2);
343 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType, &value1, &value2);
349 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
351 if(memberType.type == normalClass || memberType.type == noHeadClass)
354 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType,
355 *(void **)((byte *)data1 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset)),
356 *(void **)((byte *)data2 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset)));
360 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType,
361 (byte *)data1 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset),
362 (byte *)data2 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
367 DataValue value1, value2;
368 if(memberType.typeSize == 8)
370 value1.ui64 = *(uint64 *)((byte *)data1 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
371 value2.ui64 = *(uint64 *)((byte *)data2 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
375 value1.i = *(int *)((byte *)data1 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
376 value2.i = *(int *)((byte *)data2 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
378 memberResult = memberType._vTbl[__ecereVMethodID_class_OnCompare](memberType, &value1, &value2);
384 // printf("Unknown type\n");
389 memberResult = DataMember_OnCompare(member,
390 (byte *)data1 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset),
391 (byte *)data2 + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
398 else if(!data1 && data2)
400 else if(data1 && !data2)
403 else if(_class.type == unitClass)
405 Class dataType = eSystem_FindClass(module, _class.dataTypeString);
406 return dataType._vTbl[__ecereVMethodID_class_OnCompare](dataType, data1, data2);
413 if(*(void **)data1 > *(void **)data2)
415 else if(*(void **)data1 < *(void **)data2)
418 else if(!data1 && data2)
420 else if(data1 && !data2)
427 static char * OnGetString(Class _class, void * data, char * tempString, void * fieldData, bool * needClass)
429 // WHY DOES _class.module NOT SEEM TO WORK?
430 Module module = _class.templateClass ? _class.templateClass.module : _class.module;
431 if(_class.type == enumClass)
433 return Enum_OnGetString(_class, data, tempString, fieldData, needClass);
435 else if(_class.type == unitClass)
437 Class dataType = eSystem_FindClass(module, _class.dataTypeString);
438 return (char *)dataType._vTbl[__ecereVMethodID_class_OnGetString](dataType, data, tempString, fieldData, needClass);
442 bool atMember = true;
444 Class mainClass = _class;
446 tempString[0] = '\0';
447 if(!data && (mainClass.type == normalClass || mainClass.type == noHeadClass)) return tempString;
449 while(_class != mainClass)
452 Class lastClass = _class;
454 for(_class = mainClass; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
456 for(member = _class.membersAndProperties.first; member; member = member.next)
458 char memberString[1024];
459 Class memberType = member.dataTypeClass;
460 char * name = member.name;
465 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
467 memberType = member.dataTypeClass = eSystem_FindClass(module, "int");
469 if(member.isProperty)
471 Property prop = (Property) member;
473 if(!prop.conversion && prop.Get && prop.Set && (!prop.IsSet || prop.IsSet(data)))
475 if(memberType.type != structClass && (memberType.type != normalClass || !strcmp(memberType.dataTypeString, "char *")) && memberType.type != bitClass && data)
477 DataValue value = { 0 };
478 if(!strcmp(prop.dataTypeString, "float"))
480 value.f = ((float(*)())(void *)prop.Get)(data);
483 bool needClass = true;
484 char * result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, &value, memberString, null, &needClass);
485 if(result && result != memberString)
486 strcpy(memberString, result);
488 if(strchr(memberString, '.'))
489 strcat(memberString, "f");
494 value.i = prop.Get(data);
495 if(value.i || prop.IsSet)
497 bool needClass = true;
498 char * result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType,
499 (memberType.type == normalClass) ? value.p : &value, memberString, null, &needClass);
500 if(result && result != memberString)
501 strcpy(memberString, result);
509 if(member.type == normalMember)
511 if(memberType.type == structClass || memberType.type == normalClass)
513 char internalMemberString[1024];
514 byte * memberData = ((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
516 for(c = 0; c < memberType.structSize; c++)
519 if(c < memberType.structSize)
521 bool needClass = true;
523 if(memberType.type == normalClass)
524 result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, *(Instance *)memberData, internalMemberString, null, &needClass);
526 result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, memberData, internalMemberString, null, &needClass);
529 //strcpy(memberString, memberType.name);
530 strcat(memberString, "{ ");
531 if(result) strcat(memberString, result);
532 strcat(memberString, " }");
535 strcpy(memberString, result);
538 //else if(_class /*memberType*/.type != bitClass)
539 else // if(_class /*memberType*/.type != bitClass)
541 DataValue value = { 0 };
542 if(_class.type == bitClass)
544 BitMember bitMember = (BitMember) member;
545 // TODO: Check if base type is 32 or 64 bit
547 //value.ui = (((uint)data & bitMember.mask) >> bitMember.pos);
548 value.ui64 = ((*(uint*)data & bitMember.mask) >> bitMember.pos);
551 bool needClass = true;
552 char internalMemberString[1024];
553 char * result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, &value, internalMemberString, null, &needClass);
555 if(needClass && memberType.type != systemClass && memberType.type != enumClass && memberType.type != unitClass)
557 //strcpy(memberString, memberType.name);
558 strcat(memberString, " { ");
559 if(result) strcat(memberString, result);
560 strcat(memberString, " }");
563 strcpy(memberString, result);
565 if(result && memberString != result)
566 strcpy(memberString, result);
570 else if(!memberType.noExpansion)
572 // TOCHECK: Is this still right??
573 if(memberType.typeSize <= 4)
575 value.i = *(int *)((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
578 bool needClass = true;
579 char * result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, &value, memberString, null, &needClass);
580 if(result && memberString != result)
581 strcpy(memberString, result);
586 bool needClass = true;
587 char * result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, ((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset)), memberString, null, &needClass);
588 if(result && memberString != result)
589 strcpy(memberString, result);
595 char internalMemberString[1024];
596 byte * memberData = ((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset));
597 bool needClass = true;
599 result = (char *)memberType._vTbl[__ecereVMethodID_class_OnGetString](memberType, memberData, internalMemberString, null, &needClass);
602 //strcpy(memberString, memberType.name);
603 strcat(memberString, "{ ");
604 if(result) strcat(memberString, result);
605 strcat(memberString, " }");
608 strcpy(memberString, result);
614 // TODO: Fix atID stuff
618 strcat(tempString, ", ");
619 if(!atMember || !strcmp(memberType.name, "bool"))
621 strcat(tempString, name);
622 strcat(tempString, " = ");
625 if(!strcmp(memberType.name, "char *"))
627 int len = strlen(tempString);
629 strcat(tempString, "\"");
631 for(c = 0; memberString[c]; c++)
633 if(memberString[c] == '\"')
635 strcat(tempString, "\\\"");
638 else if(memberString[c] == '\\')
640 strcat(tempString, "\\\\");
645 tempString[len++] = memberString[c];
649 strcat(tempString, "\"");
652 strcat(tempString, memberString);
657 else if(member && (!member.isProperty || !((Property)member).conversion))
665 static bool OnGetDataFromString(Class _class, void ** data, char * string)
668 Module module = _class.module;
669 if(_class.type == enumClass)
670 result = Enum_OnGetDataFromString(_class, (int *)data, string);
671 else if(_class.type == unitClass)
673 Class dataType = eSystem_FindClass(module, _class.dataTypeString);
674 return dataType._vTbl[__ecereVMethodID_class_OnGetDataFromString](dataType, data, string);
676 else if(!string[0] && _class.type == normalClass)
678 // result = false; // Why was this data = null commented?
685 char memberName[1024];
686 char memberString[10240];
694 Class curClass = null;
695 DataMember curMember = null;
696 DataMember subMemberStack[256];
697 int subMemberStackPos = 0;
701 if(_class.type == noHeadClass || _class.type == normalClass)
703 data = *data = eInstance_New(_class);
704 if(_class.type == normalClass)
705 ((Instance)data)._refCount++;
707 else if(/*_class.type == noHeadClass || */_class.type == structClass)
708 memset(data, 0, _class.structSize);
709 // Bit classes cleared outside?
711 memberName[0] = '\0';
713 for(c = 0; string[c] && count < sizeof(memberString); )
716 DataMember thisMember = null;
720 for(; (ch = string[c]) && count < sizeof(memberString); c++)
722 if(ch == '\"' && !escape)
728 if(!escape && ch == '\\')
734 memberString[count++] = ch;
738 // TOFIX: OnGetDataFromString is far from ready as a generic object notation reader...
739 // It has mostly been tested/used for entering data in the IDE's property sheet, as well as for parsing code in the Code Editor
740 // Is it used by the compiler?
741 else if(ch == ' ') // || ch == '\n' || ch == '\t' || ch == '\r')
744 memberString[count++] = ch;
750 memberString[count++] = ch;
760 // If bracket is not initialization
761 if(gotChar && !brackets)
769 memberString[count++] = ch;
780 memberString[count++] = ch;
787 memberString[count++] = ch;
791 memberString[count] = '\0';
792 //TrimLSpaces(memberString, memberName);
793 //TrimRSpaces(memberName, memberString);
794 //strcpy(memberName, memberString);
796 TrimRSpaces(memberString, memberName);
803 memberString[count++] = ch;
808 memberString[count] = '\0';
809 TrimRSpaces(memberString, memberString);
813 DataMember _subMemberStack[256];
814 int _subMemberStackPos = 0;
816 thisMember = eClass_FindDataMemberAndOffset(_class, memberName, &memberOffset, _class.module, _subMemberStack, &_subMemberStackPos);
819 thisMember = (DataMember)eClass_FindProperty(_class, memberName, _class.module);
822 if(thisMember.memberAccess == publicAccess)
824 curMember = thisMember;
825 curClass = thisMember._class;
826 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
827 subMemberStackPos = _subMemberStackPos;
834 eClass_FindNextMember(_class, &curClass, (DataMember *)&curMember, subMemberStack, &subMemberStackPos);
835 thisMember = curMember;
839 eClass_FindDataMemberAndOffset(_class, thisMember.name, &memberOffset, _class.module, null, null);
844 Class memberType = thisMember.dataTypeClass;
847 memberType = thisMember.dataTypeClass = eSystem_FindClass(module, thisMember.dataTypeString);
849 memberType = thisMember.dataTypeClass = eSystem_FindClass(module, "int");
850 if(memberType.type == structClass)
854 if(!memberType._vTbl[__ecereVMethodID_class_OnGetDataFromString](memberType,
855 (byte *)data + (((thisMember._class.type == normalClass) ? thisMember._class.offset : 0) + memberOffset), memberString))
861 DataValue value = { 0 };
862 // Patch for hotKey crash ( #556 )
863 // Key has a member KeyCode, which inherits from Key
864 // We don't want KeyCode to use its base class OnGetDataFromString
865 if(memberType._vTbl[__ecereVMethodID_class_OnGetDataFromString] == _class._vTbl[__ecereVMethodID_class_OnGetDataFromString])
867 if(!OnGetDataFromString(memberType, &value, memberString))
870 else if(!memberType._vTbl[__ecereVMethodID_class_OnGetDataFromString](memberType, &value, memberString))
872 if(thisMember && !thisMember.isProperty)
874 if(_class.type == bitClass)
876 BitMember bitMember = (BitMember) thisMember;
877 // TODO: Check if bit _class is 32 or 64 bit
878 *(uint *)data = (uint32)(((*(uint *)data & ~bitMember.mask)) | ((value.ui64<<bitMember.pos)&bitMember.mask));
881 *(int *)((byte *)data + (((thisMember._class.type == normalClass) ? thisMember._class.offset : 0) + thisMember.offset)) = value.i;
883 else if(thisMember.isProperty && ((Property)thisMember).Set)
884 ((Property)thisMember).Set(data, value.i);
891 memberName[0] = '\0';
897 static void OnCopy(Class _class, void ** data, void * newData)
899 // TO IMPROVE: Inherit from Unit class for better performance?
900 if(_class.type == unitClass || _class.type == bitClass || _class.type == enumClass)
902 Class dataType = eSystem_FindClass(_class.module, _class.dataTypeString);
904 dataType._vTbl[__ecereVMethodID_class_OnCopy](dataType, data, newData);
906 else if(_class.type != structClass && _class.type != systemClass)
910 // Here we have either a structClass or a systemClass
912 memcpy(data, newData, _class.typeSize);
914 memset(data, 0, _class.typeSize);
917 static int DataMember_OnSerialize(DataMember parentMember, void * data, IOChannel channel)
920 Module module = parentMember._class.module;
921 for(member = parentMember.members.first; member; member = member.next)
923 if(member.type == normalMember)
925 Class memberType = member.dataTypeClass;
928 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
930 memberType = member.dataTypeClass = eSystem_FindClass(module, "int");
932 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
934 memberType._vTbl[__ecereVMethodID_class_OnSerialize](memberType, (byte *)data + member.offset, channel);
939 value.i = *(int *)((byte *)data + member.offset);
940 memberType._vTbl[__ecereVMethodID_class_OnSerialize](memberType, &value);
945 DataMember_OnSerialize(member, (byte *)data + member.offset, channel);
951 static void OnSerialize(Class _class, void * data, IOChannel channel)
953 Module module = _class.module;
954 // TO IMPROVE: Inherit from Unit class for better performance?
955 if(_class.type == unitClass || _class.type == bitClass || _class.type == enumClass)
957 Class dataType = eSystem_FindClass(module, _class.dataTypeString);
959 dataType._vTbl[__ecereVMethodID_class_OnSerialize](dataType, data, channel);
961 else if(_class.type == normalClass || _class.type == noHeadClass || _class.type == structClass)
965 Class lastClass = null;
966 while(lastClass != _class)
969 for(; _class && (!_class.base || _class.base.type != systemClass) && _class != lastClass; _class = _class.base);
972 for(member = _class.membersAndProperties.first; member; member = member.next)
974 if(member.isProperty || member.type == normalMember)
976 Class memberType = member.dataTypeClass;
979 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
982 if(member.isProperty)
984 /*Property prop = (Property)member;
985 if(!prop.conversion && prop.Get && prop.Set)
987 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
994 if(!strcmp(memberType.dataTypeString, "float"))
996 value.f = ((float(*)())(void *)prop.Get)(data);
1000 value.i = prop.Get(data);
1002 memberType._vTbl[__ecereVMethodID_class_OnSerialize](memberType, &value, channel);
1008 if(!strcmp(memberType.name, "String") || memberType.type == normalClass || memberType.type == noHeadClass)
1010 memberType._vTbl[__ecereVMethodID_class_OnSerialize](memberType, data ? (*(void **)((byte *)data + member._class.offset + member.offset)) : null, channel);
1013 memberType._vTbl[__ecereVMethodID_class_OnSerialize](memberType, data ? (((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset))) : null, channel);
1018 // printf("Unknown type\n");
1023 DataMember_OnSerialize(member, data ? ((byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset)) : null, channel);
1031 static int DataMember_OnUnserialize(DataMember parentMember, void * data, IOChannel channel)
1034 Module module = parentMember._class.module;
1035 for(member = parentMember.members.first; member; member = member.next)
1037 if(member.type == normalMember)
1039 Class memberType = member.dataTypeClass;
1042 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
1044 memberType = member.dataTypeClass = eSystem_FindClass(module, "int");
1046 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
1048 memberType._vTbl[__ecereVMethodID_class_OnUnserialize](memberType, (byte *)data + member.offset, channel);
1053 memberType._vTbl[__ecereVMethodID_class_OnUnserialize](memberType, &value);
1054 *(int *)((byte *)data + member.offset) = value.i;
1059 DataMember_OnUnserialize(member, (byte *)data + member.offset, channel);
1065 static void OnUnserialize(Class _class, void ** data, IOChannel channel)
1067 Module module = _class.module;
1068 if(_class.type == unitClass || _class.type == bitClass || _class.type == enumClass)
1070 Class dataType = eSystem_FindClass(module, _class.dataTypeString);
1072 dataType._vTbl[__ecereVMethodID_class_OnUnserialize](dataType, data, channel);
1074 else if(_class.type == normalClass || _class.type == noHeadClass || _class.type == structClass)
1078 Class lastClass = null;
1079 if(_class.type == normalClass || _class.type == noHeadClass)
1081 data = *data = eInstance_New(_class);
1082 if(_class.type == normalClass)
1083 ((Instance)data)._refCount++;
1085 else if(/*_class.type == noHeadClass || */_class.type == structClass)
1086 memset(data, 0, _class.structSize);
1088 while(lastClass != _class)
1091 for(; _class && (!_class.base || _class.base.type != systemClass) && _class != lastClass; _class = _class.base);
1094 for(member = _class.membersAndProperties.first; member; member = member.next)
1096 if(member.isProperty || member.type == normalMember)
1098 Class memberType = member.dataTypeClass;
1101 memberType = member.dataTypeClass = eSystem_FindClass(module, member.dataTypeString);
1104 if(member.isProperty)
1106 /*Property prop = (Property)member;
1107 if(!prop.conversion && prop.Get && prop.Set)
1109 if(memberType.type == structClass || memberType.type == normalClass || memberType.type == noHeadClass)
1116 memberType._vTbl[__ecereVMethodID_class_OnUnserialize](memberType, &value, channel);
1117 prop.Set(data, value.i);
1122 memberType._vTbl[__ecereVMethodID_class_OnUnserialize](memberType,
1123 (byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset), channel);
1127 // printf("Unknown type\n");
1132 DataMember_OnUnserialize(member, (byte *)data + (((member._class.type == normalClass) ? member._class.offset : 0) + member.offset), channel);
1141 static int Integer_OnCompare(Class _class, int * data1, int * data2)
1146 else if(*data1 < *data2)
1151 /*static */char * Integer_OnGetString(Class _class, int * data, char * string, void * fieldData, bool * needClass)
1153 sprintf(string, "%d", *data);
1157 static bool Integer_OnGetDataFromString(Class _class, int * data, char * string)
1160 int result = strtol(string, &end, 0);
1170 static int UInteger_OnCompare(Class _class, unsigned int * data1, unsigned int * data2)
1175 else if(!data1 && data2)
1177 else if(!data1 && !data2)
1179 else if(*data1 > *data2)
1181 else if(*data1 < *data2)
1186 static char * UInteger_OnGetString(Class _class, unsigned int * data, char * string, void * fieldData, bool * needClass)
1188 sprintf(string, "%u", *data);
1192 static bool UInteger_OnGetDataFromString(Class _class, unsigned int * data, char * string)
1195 uint result = strtoul(string, &end, 0);
1204 static int Byte_OnCompare(Class _class, byte * data1, byte * data2)
1209 else if(*data1 < *data2)
1214 static char * Byte_OnGetString(Class _class, byte * data, char * string, void * fieldData, bool * needClass)
1216 sprintf(string, "%u", (int)*data);
1220 static char * Char_OnGetString(Class _class, char * data, char * string, void * fieldData, bool * needClass)
1222 if(needClass && *needClass)
1225 if(ch == '\t') strcpy(string, "'\t'");
1226 else if(ch == '\n') strcpy(string, "'\n'");
1227 else if(ch == '\r') strcpy(string, "'\r'");
1228 else if(ch == '\a') strcpy(string, "'\a'");
1229 else if(ch == '\\') strcpy(string, "'\\'");
1230 else if(ch < 32 || ch >= 127) sprintf(string, "'\o'", ch);
1231 else sprintf(string, "'%c'", ch);
1234 sprintf(string, "%c", *data);
1238 static bool Byte_OnGetDataFromString(Class _class, byte * data, char * string)
1241 byte result = (byte)strtoul(string, &end, 0);
1250 static char * Int64_OnGetString(Class _class, int64 * data, char * string, void * fieldData, bool * needClass)
1252 sprintf(string, FORMAT64D, *data);
1256 static char * UInt64_OnGetString(Class _class, uint64 * data, char * string, void * fieldData, bool * needClass)
1258 sprintf(string, FORMAT64U, *data);
1262 /*static */void Byte_OnSerialize(Class _class, byte * data, IOChannel channel)
1264 channel.WriteData(data, 1);
1267 /*static */void Byte_OnUnserialize(Class _class, byte * data, IOChannel channel)
1269 if(channel.ReadData(data, 1) != 1)
1274 /*static */void Int_OnSerialize(Class _class, int * data, IOChannel channel)
1277 PUTXDWORD(bytes, * data);
1278 channel.WriteData(bytes, 4);
1281 /*static */void Int_OnUnserialize(Class _class, int * data, IOChannel channel)
1284 if(channel.ReadData(bytes, 4) == 4)
1285 *data = GETXDWORD(bytes);
1290 /*static */void Int64_OnSerialize(Class _class, int64 * data, IOChannel channel)
1293 PUTXQWORD(bytes, * data);
1294 channel.WriteData(bytes, 8);
1297 /*static */void Int64_OnUnserialize(Class _class, int64 * data, IOChannel channel)
1300 if(channel.ReadData(bytes, 8) == 8)
1301 *data = GETXQWORD(bytes);
1306 /*static */void Word_OnSerialize(Class _class, uint16 * data, IOChannel channel)
1309 PUTXWORD(bytes, * data);
1310 channel.WriteData(bytes, 2);
1313 /*static */void Word_OnUnserialize(Class _class, uint16 * data, IOChannel channel)
1316 if(channel.ReadData(bytes, 2) == 2)
1317 *data = GETXWORD(bytes);
1322 static void RegisterClass_Integer(Module module)
1324 Class integerClass = eSystem_RegisterClass(normalClass, "int", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1325 integerClass.type = systemClass;
1326 delete integerClass.dataTypeString;
1327 integerClass.dataTypeString = CopyString("int");
1328 integerClass.structSize = 0;
1329 integerClass.typeSize = sizeof(int);
1331 eClass_AddMethod(integerClass, "OnCompare", null, Integer_OnCompare, publicAccess);
1332 eClass_AddMethod(integerClass, "OnGetString", null, Integer_OnGetString, publicAccess);
1333 eClass_AddMethod(integerClass, "OnGetDataFromString", null, Integer_OnGetDataFromString, publicAccess);
1334 eClass_AddMethod(integerClass, "OnSerialize", null, Int_OnSerialize, publicAccess);
1335 eClass_AddMethod(integerClass, "OnUnserialize", null, Int_OnUnserialize, publicAccess);
1337 integerClass = eSystem_RegisterClass(normalClass, "int64", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1338 integerClass.type = systemClass;
1339 integerClass.structSize = 0;
1340 integerClass.typeSize = sizeof(int64);
1341 delete integerClass.dataTypeString;
1342 integerClass.dataTypeString = CopyString("int64");
1343 eClass_AddMethod(integerClass, "OnGetString", null, Int64_OnGetString, publicAccess);
1346 eClass_AddMethod(integerClass, "OnCompare", null, Integer64_OnCompare, publicAccess);
1347 eClass_AddMethod(integerClass, "OnGetString", null, Integer64_OnGetString, publicAccess);
1348 eClass_AddMethod(integerClass, "OnGetDataFromString", null, Integer64_OnGetDataFromString, publicAccess);
1350 eClass_AddMethod(integerClass, "OnSerialize", null, Int64_OnSerialize, publicAccess);
1351 eClass_AddMethod(integerClass, "OnUnserialize", null, Int64_OnUnserialize, publicAccess);
1353 integerClass = eSystem_RegisterClass(normalClass, "uint", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1354 integerClass.type = systemClass;
1355 delete integerClass.dataTypeString;
1356 integerClass.dataTypeString = CopyString("unsigned int");
1357 integerClass.structSize = 0;
1358 integerClass.typeSize = sizeof(uint);
1359 eClass_AddMethod(integerClass, "OnCompare", null, UInteger_OnCompare, publicAccess);
1360 eClass_AddMethod(integerClass, "OnGetString", null, UInteger_OnGetString, publicAccess);
1361 eClass_AddMethod(integerClass, "OnGetDataFromString", null, UInteger_OnGetDataFromString, publicAccess);
1362 eClass_AddMethod(integerClass, "OnSerialize", null, Int_OnSerialize, publicAccess);
1363 eClass_AddMethod(integerClass, "OnUnserialize", null, Int_OnUnserialize, publicAccess);
1365 integerClass = eSystem_RegisterClass(normalClass, "unsigned int", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1366 integerClass.type = systemClass;
1367 delete integerClass.dataTypeString;
1368 integerClass.dataTypeString = CopyString("unsigned int");
1369 integerClass.structSize = 0;
1370 integerClass.typeSize = sizeof(uint);
1372 eClass_AddMethod(integerClass, "OnCompare", null, UInteger_OnCompare, publicAccess);
1373 eClass_AddMethod(integerClass, "OnGetString", null, UInteger_OnGetString, publicAccess);
1374 eClass_AddMethod(integerClass, "OnGetDataFromString", null, UInteger_OnGetDataFromString, publicAccess);
1375 eClass_AddMethod(integerClass, "OnSerialize", null, Int_OnSerialize, publicAccess);
1376 eClass_AddMethod(integerClass, "OnUnserialize", null, Int_OnUnserialize, publicAccess);
1378 integerClass = eSystem_RegisterClass(normalClass, "uint16", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1379 integerClass.type = systemClass;
1380 delete integerClass.dataTypeString;
1381 integerClass.dataTypeString = CopyString("unsigned short");
1382 integerClass.structSize = 0;
1383 integerClass.typeSize = sizeof(uint16);
1385 eClass_AddMethod(integerClass, "OnSerialize", null, Word_OnSerialize, publicAccess);
1386 eClass_AddMethod(integerClass, "OnUnserialize", null, Word_OnUnserialize, publicAccess);
1388 integerClass = eSystem_RegisterClass(normalClass, "short", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1389 integerClass.type = systemClass;
1390 delete integerClass.dataTypeString;
1391 integerClass.dataTypeString = CopyString("short");
1392 integerClass.structSize = 0;
1393 integerClass.typeSize = sizeof(short);
1395 eClass_AddMethod(integerClass, "OnSerialize", null, Word_OnSerialize, publicAccess);
1396 eClass_AddMethod(integerClass, "OnUnserialize", null, Word_OnUnserialize, publicAccess);
1399 integerClass = eSystem_RegisterClass(normalClass, "uint32", null, 0, 0, null, null, module, baseSystemAccess);
1400 integerClass.type = systemClass;
1401 delete integerClass.dataTypeString;
1402 integerClass.dataTypeString = CopyString("uint32");
1403 eClass_AddMethod(integerClass, "OnCompare", null, UInteger_OnCompare, publicAccess);
1404 eClass_AddMethod(integerClass, "OnGetString", null, UInteger_OnGetString, publicAccess);
1405 eClass_AddMethod(integerClass, "OnGetDataFromString", null, UInteger_OnGetDataFromString, publicAccess);
1407 integerClass = eSystem_RegisterClass(normalClass, "uint32", "uint", 0, 0, null, null, module, baseSystemAccess, publicAccess);
1408 integerClass.type = systemClass;
1409 delete integerClass.dataTypeString;
1410 integerClass.dataTypeString = CopyString("unsigned int");
1411 integerClass.structSize = 0;
1412 integerClass.typeSize = sizeof(uint32);
1414 integerClass = eSystem_RegisterClass(normalClass, "uint64", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1415 integerClass.type = systemClass;
1416 delete integerClass.dataTypeString;
1417 integerClass.dataTypeString = CopyString("uint64");
1418 integerClass.structSize = 0;
1419 integerClass.typeSize = sizeof(uint64);
1420 eClass_AddMethod(integerClass, "OnGetString", null, UInt64_OnGetString, publicAccess);
1421 eClass_AddMethod(integerClass, "OnSerialize", null, Int64_OnSerialize, publicAccess);
1422 eClass_AddMethod(integerClass, "OnUnserialize", null, Int64_OnUnserialize, publicAccess);
1424 integerClass = eSystem_RegisterClass(normalClass, "byte", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1425 integerClass.type = systemClass;
1426 delete integerClass.dataTypeString;
1427 integerClass.dataTypeString = CopyString("unsigned char");
1428 integerClass.structSize = 0;
1429 integerClass.typeSize = sizeof(byte);
1430 eClass_AddMethod(integerClass, "OnCompare", null, Byte_OnCompare, publicAccess);
1431 eClass_AddMethod(integerClass, "OnGetString", null, Byte_OnGetString, publicAccess);
1432 eClass_AddMethod(integerClass, "OnGetDataFromString", null, Byte_OnGetDataFromString, publicAccess);
1433 eClass_AddMethod(integerClass, "OnSerialize", null, Byte_OnSerialize, publicAccess);
1434 eClass_AddMethod(integerClass, "OnUnserialize", null, Byte_OnUnserialize, publicAccess);
1436 integerClass = eSystem_RegisterClass(normalClass, "char", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1437 integerClass.type = systemClass;
1438 delete integerClass.dataTypeString;
1439 integerClass.dataTypeString = CopyString("char");
1440 integerClass.structSize = 0;
1441 integerClass.typeSize = sizeof(char);
1442 eClass_AddMethod(integerClass, "OnCompare", null, Byte_OnCompare, publicAccess);
1443 eClass_AddMethod(integerClass, "OnGetString", null, Char_OnGetString, publicAccess);
1444 eClass_AddMethod(integerClass, "OnGetDataFromString", null, Byte_OnGetDataFromString, publicAccess);
1445 eClass_AddMethod(integerClass, "OnSerialize", null, Byte_OnSerialize, publicAccess);
1446 eClass_AddMethod(integerClass, "OnUnserialize", null, Byte_OnUnserialize, publicAccess);
1450 static int Float_OnCompare(Class _class, float * data1, float * data2)
1455 else if(*data1 < *data2)
1460 static char * Float_OnGetString(Class _class, float * data, char * string, void * fieldData, bool * needClass)
1464 int numDigits = 7, num = 1;
1466 while(numDigits && num < *data) numDigits--, num *= 10;
1467 sprintf(format, "%%.%df", numDigits);
1469 //sprintf(string, "%f", *data);
1470 sprintf(string, format, *data);
1472 c = strlen(string)-1;
1475 if(string[c] != '0')
1476 last = Max(last, c);
1477 if(string[c] == '.')
1489 static bool Float_OnGetDataFromString(Class _class, float * data, char * string)
1492 float result = (float)strtod(string, &end);
1493 //*data = atof(string);
1502 static void Float_OnSerialize(Class _class, float * data, IOChannel channel)
1505 PUTXDWORD(bytes, * (uint *)data);
1506 channel.WriteData(bytes, 4);
1509 static void Float_OnUnserialize(Class _class, float * data, IOChannel channel)
1512 if(channel.ReadData(bytes, 4) == 4)
1513 *(uint *)data = GETXDWORD(bytes);
1518 static void RegisterClass_Float(Module module)
1520 Class floatClass = eSystem_RegisterClass(normalClass, "float", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1521 floatClass.type = systemClass;
1522 delete floatClass.dataTypeString;
1523 floatClass.dataTypeString = CopyString("float");
1524 floatClass.structSize = 0;
1525 floatClass.typeSize = sizeof(float);
1526 eClass_AddMethod(floatClass, "OnCompare", null, Float_OnCompare, publicAccess);
1527 eClass_AddMethod(floatClass, "OnGetString", null, Float_OnGetString, publicAccess);
1528 eClass_AddMethod(floatClass, "OnGetDataFromString", null, Float_OnGetDataFromString, publicAccess);
1529 eClass_AddMethod(floatClass, "OnSerialize", null, Float_OnSerialize, publicAccess);
1530 eClass_AddMethod(floatClass, "OnUnserialize", null, Float_OnUnserialize, publicAccess);
1534 static int Double_OnCompare(Class _class, double * data1, double * data2)
1539 else if(*data1 < *data2)
1544 static char * Double_OnGetString(Class _class, double * data, char * string, void * fieldData, bool * needClass)
1548 //sprintf(string, "%.20f", *data);
1549 if(runtimePlatform == win32)
1550 // sprintf(string, "%.16g", *data);
1551 sprintf(string, "%.15g", *data);
1553 sprintf(string, "%.13lf", *data);
1555 c = strlen(string)-1;
1558 if(string[c] != '0')
1559 last = Max(last, c);
1560 if(string[c] == '.')
1572 static bool Double_OnGetDataFromString(Class _class, double * data, char * string)
1576 //*data = (double)strtod(string, null);
1577 result = strtod(string, &end);
1587 static void Double_OnSerialize(Class _class, double * data, IOChannel channel)
1590 PUTXQWORD(bytes, * (uint64 *)data);
1591 channel.WriteData(bytes, 8);
1594 static void Double_OnUnserialize(Class _class, double * data, IOChannel channel)
1597 if(channel.ReadData(bytes, 8) == 8)
1598 *(uint64 *)data = GETXQWORD(bytes);
1603 static void RegisterClass_Double(Module module)
1605 Class doubleClass = eSystem_RegisterClass(normalClass, "double", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1606 doubleClass.type = systemClass;
1607 delete doubleClass.dataTypeString;
1608 doubleClass.dataTypeString = CopyString("double");
1609 doubleClass.structSize = 0;
1610 doubleClass.typeSize = sizeof(double);
1611 eClass_AddMethod(doubleClass, "OnCompare", null, Double_OnCompare, publicAccess);
1612 eClass_AddMethod(doubleClass, "OnGetString", null, Double_OnGetString, publicAccess);
1613 eClass_AddMethod(doubleClass, "OnGetDataFromString", null, Double_OnGetDataFromString, publicAccess);
1614 eClass_AddMethod(doubleClass, "OnSerialize", null, Double_OnSerialize, publicAccess);
1615 eClass_AddMethod(doubleClass, "OnUnserialize", null, Double_OnUnserialize, publicAccess);
1618 public struct StaticString
1622 void OnSerialize(IOChannel channel)
1624 int len = this ? strlen(string) : 0;
1625 channel.WriteData(this ? string : "", len+1);
1628 void OnUnserialize(IOChannel channel)
1635 for(c = 0; channel.ReadData(&string[c], 1) && string[c]; c++);
1640 int OnCompare(StaticString string2)
1644 result = strcmpi(string, string2.string);
1645 else if(!this && string2)
1646 result = -1; // INVERTED THESE 2 CASES
1647 else if(this && !string2)
1652 char * OnGetString(char * tempString, void * fieldData, bool * needClass)
1654 return (char *)(this ? string : null); // Cast for memguard
1662 static void String_OnCopy(Class _class, char ** data, char * newData)
1666 int len = strlen(newData);
1669 *data = eSystem_New(len+1);
1670 memcpy(*data, newData, len+1);
1679 static bool String_OnGetDataFromString(Class _class, char ** data, char * newData)
1683 int len = strlen(newData);
1686 *data = eSystem_New(len+1);
1687 memcpy(*data, newData, len+1);
1695 /*static */int String_OnCompare(Class _class, char * string1, char * string2)
1698 if(string1 && string2)
1699 result = strcmpi(string1, string2);
1700 else if(!string1 && string2)
1702 else if(string1 && !string2)
1707 static char * String_OnGetString(Class _class, char * string, char * tempString, void * fieldData, bool * needClass)
1712 static void String_OnFree(Class _class, char * string)
1716 eSystem_Delete(string);
1720 static void String_OnSerialize(Class _class, char * string, IOChannel channel)
1722 int len = string ? strlen(string) : 0;
1723 channel.WriteData(string ? string : "", len+1);
1726 static void String_OnUnserialize(Class _class, char * * string, IOChannel channel)
1733 *string = new char[size];
1734 for(c = 0; channel.ReadData(&(*string)[c], 1) && (*string)[c]; c++)
1739 *string = renew *string char[size];
1742 (*string)[c++] = '\0';
1743 if(!UTF8Validate(*string))
1745 char * newString = new char[c*2];
1746 ISO8859_1toUTF8(*string, newString, c*2);
1748 *string = renew newString char[strlen(newString)+1];
1751 *string = renew *string char[c];
1755 static void RegisterClass_String(Module module)
1757 Class stringClass = eSystem_RegisterClass(normalClass, "char *", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
1758 delete stringClass.dataTypeString;
1759 stringClass.dataTypeString = CopyString("char *");
1760 stringClass.structSize = 0;
1762 eClass_AddMethod(stringClass, "OnCompare", null, String_OnCompare, publicAccess);
1763 eClass_AddMethod(stringClass, "OnCopy", null, String_OnCopy, publicAccess);
1764 eClass_AddMethod(stringClass, "OnFree", null, String_OnFree, publicAccess);
1765 eClass_AddMethod(stringClass, "OnGetString", null, String_OnGetString, publicAccess);
1766 eClass_AddMethod(stringClass, "OnGetDataFromString", null, String_OnGetDataFromString, publicAccess);
1767 eClass_AddMethod(stringClass, "OnSerialize", null, String_OnSerialize, publicAccess);
1768 eClass_AddMethod(stringClass, "OnUnserialize", null, String_OnUnserialize, publicAccess);
1769 // eClass_AddProperty(stringClass, null, "Class", null, String_GetClass, publicAccess);
1771 stringClass = eSystem_RegisterClass(normalClass, "String", "char *", 0, 0, null, null, module, baseSystemAccess, publicAccess);
1772 stringClass.structSize = 0;
1773 eClass_AddProperty(stringClass, null, "char *", null, null, publicAccess);
1776 void InitializeDataTypes1(Module module)
1778 Class baseClass = eSystem_FindClass(module, "class");
1780 eClass_AddVirtualMethod(baseClass, "OnDisplay", "void typed_object::OnDisplay(Surface surface, int x, int y, int width, void * fieldData, Alignment alignment, DataDisplayFlags displayFlags)", null, publicAccess);
1781 eClass_AddVirtualMethod(baseClass, "OnCompare", "int typed_object::OnCompare(any_object object)", OnCompare, publicAccess);
1782 eClass_AddVirtualMethod(baseClass, "OnCopy", "void typed_object&::OnCopy(any_object newData)", OnCopy, publicAccess);
1783 eClass_AddVirtualMethod(baseClass, "OnFree", "void typed_object::OnFree(void)", OnFree, publicAccess);
1784 eClass_AddVirtualMethod(baseClass, "OnGetString", "char * typed_object::OnGetString(char * tempString, void * fieldData, bool * needClass)", OnGetString, publicAccess);
1785 eClass_AddVirtualMethod(baseClass, "OnGetDataFromString", "bool typed_object&::OnGetDataFromString(char * string)", OnGetDataFromString, publicAccess);
1786 eClass_AddVirtualMethod(baseClass, "OnEdit", "Window typed_object::OnEdit(DataBox dataBox, DataBox obsolete, int x, int y, int w, int h, void * userData)", null, publicAccess);
1787 eClass_AddVirtualMethod(baseClass, "OnSerialize", "void typed_object::OnSerialize(IOChannel channel)", OnSerialize, publicAccess);
1788 eClass_AddVirtualMethod(baseClass, "OnUnserialize", "void typed_object&::OnUnserialize(IOChannel channel)", OnUnserialize, publicAccess);
1789 eClass_AddVirtualMethod(baseClass, "OnSaveEdit", "bool typed_object&::OnSaveEdit(Window window, void * object)", null, publicAccess);
1792 void InitializeDataTypes(Module module)
1794 Class enumClass = eSystem_FindClass(module, "enum");
1796 eClass_AddMethod(enumClass, "OnSerialize", null, Int_OnSerialize, publicAccess);
1797 eClass_AddMethod(enumClass, "OnUnserialize", null, Int_OnUnserialize, publicAccess);
1800 RegisterClass_Integer(module);
1801 RegisterClass_Float(module);
1802 RegisterClass_Double(module);
1803 RegisterClass_String(module);
1809 public int PrintStdArgsToBuffer(char * buffer, int maxLen, typed_object object, va_list args)
1812 // TOFIX: OnGetString will need a maxLen as well
1813 char * result = object.OnGetString(buffer, null, null);
1816 len = strlen(result);
1817 if(len >= maxLen) len = maxLen-1;
1818 if(result != buffer)
1819 memcpy(buffer, result, len);
1823 Class _class = null;
1826 _class = va_arg(args, void *);
1828 data = va_arg(args, void *);
1831 // TOFIX: OnGetString will need a maxLen as well
1832 result = (char *)_class._vTbl[__ecereVMethodID_class_OnGetString](_class, data, buffer + len, null, null);
1835 int newLen = strlen(result);
1836 if(len + newLen >= maxLen) newLen = maxLen-1-len;
1837 if(result != buffer + len)
1838 memcpy(buffer + len, result, newLen);
1847 public int PrintBuf(char * buffer, int maxLen, typed_object object, ...)
1851 va_start(args, object);
1852 len = PrintStdArgsToBuffer(buffer, maxLen, object, args);
1857 public int PrintLnBuf(char * buffer, int maxLen, typed_object object, ...)
1861 va_start(args, object);
1862 len = PrintStdArgsToBuffer(buffer, maxLen-1, object, args);
1863 buffer[len++] = '\n';
1869 public char * PrintString(typed_object object, ...)
1875 va_start(args, object);
1876 len = PrintStdArgsToBuffer(buffer, sizeof(buffer), object, args);
1877 string = new char[len + 1];
1878 memcpy(string, buffer, len + 1);
1883 public char * PrintLnString(typed_object object, ...)
1889 va_start(args, object);
1890 len = PrintStdArgsToBuffer(buffer, sizeof(buffer), object, args);
1891 string = new char[len + 2];
1892 memcpy(string, buffer, len);
1893 string[len++] = '\n';
1899 public void PrintLn(typed_object object, ...)
1903 va_start(args, object);
1904 PrintStdArgsToBuffer(buffer, sizeof(buffer), object, args);
1909 public void Print(typed_object object, ...)
1913 va_start(args, object);
1914 PrintStdArgsToBuffer(buffer, sizeof(buffer), object, args);
1916 fputs(buffer, stdout);