The Ecere SDK - sdk/blob - compiler/bootstrap/libec/bootstrap/pass1.c

   1 /* Code generated from eC source file: pass1.ec */
   2 #if defined(_WIN32)
   3 #define __runtimePlatform 1
   4 #elif defined(__APPLE__)
   5 #define __runtimePlatform 3
   6 #else
   7 #define __runtimePlatform 2
   8 #endif
   9 #if defined(__GNUC__)
  10 typedef long long int64;
  11 typedef unsigned long long uint64;
  12 #ifndef _WIN32
  13 #define __declspec(x)
  14 #endif
  15 #elif defined(__TINYC__)
  16 #include <stdarg.h>
  17 #define __builtin_va_list va_list
  18 #define __builtin_va_start va_start
  19 #define __builtin_va_end va_end
  20 #ifdef _WIN32
  21 #define strcasecmp stricmp
  22 #define strncasecmp strnicmp
  23 #define __declspec(x) __attribute__((x))
  24 #else
  25 #define __declspec(x)
  26 #endif
  27 typedef long long int64;
  28 typedef unsigned long long uint64;
  29 #else
  30 typedef __int64 int64;
  31 typedef unsigned __int64 uint64;
  32 #endif
  33 #ifdef __BIG_ENDIAN__
  34 #define __ENDIAN_PAD(x) (8 - (x))
  35 #else
  36 #define __ENDIAN_PAD(x) 0
  37 #endif
  38 #if defined(_WIN32)
  39 #   if defined(__GNUC__) || defined(__TINYC__)
  40 #      define ecere_stdcall __attribute__((__stdcall__))
  41 #      define ecere_gcc_struct __attribute__((gcc_struct))
  42 #   else
  43 #      define ecere_stdcall __stdcall
  44 #      define ecere_gcc_struct
  45 #   endif
  46 #else
  47 #   define ecere_stdcall
  48 #   define ecere_gcc_struct
  49 #endif
  50 #include <stdint.h>
  51 #include <sys/types.h>
  52 enum yytokentype
  53 {
  54 IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, INT128 = 294, LONG = 295, SIGNED = 296, UNSIGNED = 297, FLOAT = 298, DOUBLE = 299, CONST = 300, VOLATILE = 301, VOID = 302, VALIST = 303, STRUCT = 304, UNION = 305, ENUM = 306, ELLIPSIS = 307, CASE = 308, DEFAULT = 309, IF = 310, SWITCH = 311, WHILE = 312, DO = 313, FOR = 314, GOTO = 315, CONTINUE = 316, BREAK = 317, RETURN = 318, IFX = 319, ELSE = 320, CLASS = 321, THISCLASS = 322, CLASS_NAME = 323, PROPERTY = 324, SETPROP = 325, GETPROP = 326, NEWOP = 327, RENEW = 328, DELETE = 329, EXT_DECL = 330, EXT_STORAGE = 331, IMPORT = 332, DEFINE = 333, VIRTUAL = 334, ATTRIB = 335, PUBLIC = 336, PRIVATE = 337, TYPED_OBJECT = 338, ANY_OBJECT = 339, _INCREF = 340, EXTENSION = 341, ASM = 342, TYPEOF = 343, WATCH = 344, STOPWATCHING = 345, FIREWATCHERS = 346, WATCHABLE = 347, CLASS_DESIGNER = 348, CLASS_NO_EXPANSION = 349, CLASS_FIXED = 350, ISPROPSET = 351, CLASS_DEFAULT_PROPERTY = 352, PROPERTY_CATEGORY = 353, CLASS_DATA = 354, CLASS_PROPERTY = 355, SUBCLASS = 356, NAMESPACE = 357, NEW0OP = 358, RENEW0 = 359, VAARG = 360, DBTABLE = 361, DBFIELD = 362, DBINDEX = 363, DATABASE_OPEN = 364, ALIGNOF = 365, ATTRIB_DEP = 366, __ATTRIB = 367, BOOL = 368, _BOOL = 369, _COMPLEX = 370, _IMAGINARY = 371, RESTRICT = 372, THREAD = 373, WIDE_STRING_LITERAL = 374, BUILTIN_OFFSETOF = 375
  55 };
  56
  57 extern int propWatcherID;
  58
  59 unsigned int buildingECERECOM = 0;
  60
  61 unsigned int buildingECERECOMModule = 0;
  62
  63 extern unsigned int inCompiler;
  64
  65 extern const char *  outputFile;
  66
  67 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_Type_isPointerTypeSize;
  68
  69 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_first;
  70
  71 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__sys__BTNode_next;
  72
  73 extern unsigned int parsingType;
  74
  75 extern const char *  sourceFile;
  76
  77 static struct __ecereNameSpace__ecere__com__Instance * classPropValues;
  78
  79 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__Iterator_data;
  80
  81 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_Type_isPointerType;
  82
  83 struct __ecereNameSpace__ecere__sys__OldList
  84 {
  85 void *  first;
  86 void *  last;
  87 int count;
  88 unsigned int offset;
  89 unsigned int circ;
  90 } ecere_gcc_struct;
  91
  92 struct __ecereNameSpace__ecere__com__DataValue
  93 {
  94 union
  95 {
  96 char c;
  97 unsigned char uc;
  98 short s;
  99 unsigned short us;
 100 int i;
 101 unsigned int ui;
 102 void *  p;
 103 float f;
 104 double d;
 105 long long i64;
 106 uint64 ui64;
 107 } ecere_gcc_struct __anon1;
 108 } ecere_gcc_struct;
 109
 110 struct __ecereNameSpace__ecere__com__SerialBuffer
 111 {
 112 unsigned char *  _buffer;
 113 unsigned int count;
 114 unsigned int _size;
 115 unsigned int pos;
 116 } ecere_gcc_struct;
 117
 118 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
 119
 120 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
 121
 122 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
 123
 124 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
 125
 126 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
 127
 128 struct Pointer;
 129
 130 struct InitDeclarator;
 131
 132 struct AsmField;
 133
 134 struct Attrib;
 135
 136 struct ExtDecl;
 137
 138 struct Attribute;
 139
 140 struct Instantiation;
 141
 142 struct MembersInit;
 143
 144 struct MemberInit;
 145
 146 struct PropertyDef;
 147
 148 struct DBTableEntry;
 149
 150 struct DBIndexItem;
 151
 152 struct DBTableDef;
 153
 154 struct CodePosition
 155 {
 156 int line;
 157 int charPos;
 158 int pos;
 159 int included;
 160 } ecere_gcc_struct;
 161
 162 struct ModuleImport;
 163
 164 struct ClassImport;
 165
 166 struct __ecereNameSpace__ecere__com__LinkList
 167 {
 168 void * first;
 169 void * last;
 170 int count;
 171 } ecere_gcc_struct;
 172
 173 extern void Compiler_Error(const char *  format, ...);
 174
 175 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
 176
 177 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
 178
 179 extern char *  __ecereNameSpace__ecere__sys__GetLastDirectory(const char *  string, char *  output);
 180
 181 extern unsigned int __ecereNameSpace__ecere__sys__StripExtension(char *  string);
 182
 183 extern void FixModuleName(char *  moduleName);
 184
 185 extern int sprintf(char * , const char * , ...);
 186
 187 extern char *  QMkString(const char *  source);
 188
 189 extern char *  strcpy(char * , const char * );
 190
 191 extern void FullClassNameCat(char *  output, const char *  className, unsigned int includeTemplateParams);
 192
 193 extern char *  strcat(char * , const char * );
 194
 195 extern int strcmp(const char * , const char * );
 196
 197 extern char *  PrintInt64(long long result);
 198
 199 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
 200
 201 extern unsigned int DummyMethod(void);
 202
 203 extern char *  PrintUInt64(uint64 result);
 204
 205 extern size_t strlen(const char * );
 206
 207 struct __ecereNameSpace__ecere__com__IteratorPointer;
 208
 209 struct __ecereNameSpace__ecere__com__GlobalFunction;
 210
 211 int __ecereVMethodID_class_OnGetString;
 212
 213 void SetBuildingEcereCom(unsigned int b)
 214 {
 215 buildingECERECOM = b;
 216 }
 217
 218 unsigned int GetBuildingEcereCom()
 219 {
 220 return buildingECERECOM;
 221 }
 222
 223 void SetBuildingEcereComModule(unsigned int b)
 224 {
 225 buildingECERECOMModule = b;
 226 }
 227
 228 unsigned int GetBuildingEcereComModule()
 229 {
 230 return buildingECERECOMModule;
 231 }
 232
 233 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
 234
 235 extern struct __ecereNameSpace__ecere__sys__OldList *  excludedSymbols;
 236
 237 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
 238
 239 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
 240
 241 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
 242
 243 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
 244
 245 struct __ecereNameSpace__ecere__com__EnumClassData
 246 {
 247 struct __ecereNameSpace__ecere__sys__OldList values;
 248 long long largest;
 249 } ecere_gcc_struct;
 250
 251 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
 252
 253 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
 254
 255 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
 256
 257 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
 258
 259 extern struct Attrib * MkAttrib(int type, struct __ecereNameSpace__ecere__sys__OldList *  attribs);
 260
 261 extern struct ExtDecl * MkExtDeclAttrib(struct Attrib * attr);
 262
 263 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
 264
 265 struct Location
 266 {
 267 struct CodePosition start;
 268 struct CodePosition end;
 269 } ecere_gcc_struct;
 270
 271 extern struct Location yylloc;
 272
 273 struct Statement;
 274
 275 static struct Statement * registerModuleBody;
 276
 277 static struct Statement * unregisterModuleBody;
 278
 279 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
 280
 281 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
 282
 283 extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
 284
 285 struct External;
 286
 287 static struct External * registerModuleExternal;
 288
 289 static struct External * unregisterModuleExternal;
 290
 291 extern void FreeExternal(struct External * external);
 292
 293 extern struct External * DeclareStruct(struct External * neededBy, const char *  name, unsigned int skipNoHead, unsigned int needDereference);
 294
 295 extern struct External * curExternal;
 296
 297 struct Context;
 298
 299 extern struct Context * globalContext;
 300
 301 extern struct Context * curContext;
 302
 303 extern struct Context * PushContext(void);
 304
 305 extern void PopContext(struct Context * ctx);
 306
 307 struct Expression;
 308
 309 extern struct Attribute * MkAttribute(char * attr, struct Expression * exp);
 310
 311 extern struct Expression * MkExpConstant(const char *  string);
 312
 313 extern struct Expression * MkExpString(const char *  string);
 314
 315 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
 316
 317 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
 318
 319 extern struct Expression * CopyExpression(struct Expression * exp);
 320
 321 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
 322
 323 extern void ProcessExpressionType(struct Expression * exp);
 324
 325 extern void FreeExpContents(struct Expression * exp);
 326
 327 extern void ComputeExpression(struct Expression * exp);
 328
 329 extern struct Expression * MkExpInstance(struct Instantiation * inst);
 330
 331 extern void PrintExpression(struct Expression * exp, char *  string);
 332
 333 struct __ecereNameSpace__ecere__sys__BTNode;
 334
 335 struct __ecereNameSpace__ecere__sys__BTNode
 336 {
 337 uintptr_t key;
 338 struct __ecereNameSpace__ecere__sys__BTNode * parent;
 339 struct __ecereNameSpace__ecere__sys__BTNode * left;
 340 struct __ecereNameSpace__ecere__sys__BTNode * right;
 341 int depth;
 342 } ecere_gcc_struct;
 343
 344 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(struct __ecereNameSpace__ecere__sys__BTNode * this);
 345
 346 struct __ecereNameSpace__ecere__com__Class;
 347
 348 struct __ecereNameSpace__ecere__com__Instance
 349 {
 350 void * *  _vTbl;
 351 struct __ecereNameSpace__ecere__com__Class * _class;
 352 int _refCount;
 353 } ecere_gcc_struct;
 354
 355 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 356
 357 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 358
 359 extern void ReplaceThisClassSpecifiers(struct __ecereNameSpace__ecere__sys__OldList * specs, struct __ecereNameSpace__ecere__com__Class * _class);
 360
 361 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string, long long value);
 362
 363 extern long long __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string);
 364
 365 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
 366
 367 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 368
 369 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 370
 371 struct __ecereNameSpace__ecere__com__Iterator
 372 {
 373 struct __ecereNameSpace__ecere__com__Instance * container;
 374 struct __ecereNameSpace__ecere__com__IteratorPointer * pointer;
 375 } ecere_gcc_struct;
 376
 377 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Add;
 378
 379 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Free;
 380
 381 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 382
 383 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Iterator_Next();
 384
 385 uint64 __ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(struct __ecereNameSpace__ecere__com__Iterator * this);
 386
 387 void __ecereProp___ecereNameSpace__ecere__com__Iterator_Set_data(struct __ecereNameSpace__ecere__com__Iterator * this, uint64 value);
 388
 389 void __ecereDestroyModuleInstances_pass1()
 390 {
 391 (__ecereNameSpace__ecere__com__eInstance_DecRef(classPropValues), classPropValues = 0);
 392 }
 393
 394 struct __ecereNameSpace__ecere__com__Property;
 395
 396 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 397
 398 extern void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object);
 399
 400 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 401
 402 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 403
 404 struct Specifier;
 405
 406 extern struct Specifier * MkSpecifier(int specifier);
 407
 408 extern struct Specifier * CopySpecifier(struct Specifier * spec);
 409
 410 extern struct Specifier * MkSpecifierName(const char *  name);
 411
 412 extern struct Specifier * MkSpecifierExtended(struct ExtDecl * extDecl);
 413
 414 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
 415
 416 struct __ecereNameSpace__ecere__com__Method;
 417
 418 extern void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
 419
 420 extern void DeclareMethod(struct External * neededFor, struct __ecereNameSpace__ecere__com__Method * method, const char *  name);
 421
 422 struct Type;
 423
 424 struct __ecereNameSpace__ecere__com__Property
 425 {
 426 struct __ecereNameSpace__ecere__com__Property * prev;
 427 struct __ecereNameSpace__ecere__com__Property * next;
 428 const char *  name;
 429 unsigned int isProperty;
 430 int memberAccess;
 431 int id;
 432 struct __ecereNameSpace__ecere__com__Class * _class;
 433 const char *  dataTypeString;
 434 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 435 struct Type * dataType;
 436 void (*  Set)(void * , int);
 437 int (*  Get)(void * );
 438 unsigned int (*  IsSet)(void * );
 439 void *  data;
 440 void *  symbol;
 441 int vid;
 442 unsigned int conversion;
 443 unsigned int watcherOffset;
 444 const char *  category;
 445 unsigned int compiled;
 446 unsigned int selfWatchable;
 447 unsigned int isWatchable;
 448 } ecere_gcc_struct;
 449
 450 struct __ecereNameSpace__ecere__com__Method
 451 {
 452 const char *  name;
 453 struct __ecereNameSpace__ecere__com__Method * parent;
 454 struct __ecereNameSpace__ecere__com__Method * left;
 455 struct __ecereNameSpace__ecere__com__Method * right;
 456 int depth;
 457 int (*  function)();
 458 int vid;
 459 int type;
 460 struct __ecereNameSpace__ecere__com__Class * _class;
 461 void *  symbol;
 462 const char *  dataTypeString;
 463 struct Type * dataType;
 464 int memberAccess;
 465 } ecere_gcc_struct;
 466
 467 extern struct Type * ProcessTypeString(const char *  string, unsigned int staticMethod);
 468
 469 extern unsigned int MatchTypes(struct Type * source, struct Type * dest, struct __ecereNameSpace__ecere__sys__OldList * conversions, struct __ecereNameSpace__ecere__com__Class * owningClassSource, struct __ecereNameSpace__ecere__com__Class * owningClassDest, unsigned int doConversion, unsigned int enumBaseType, unsigned int acceptReversedParams, unsigned int isConversionExploration, unsigned int warnConst);
 470
 471 extern void FreeType(struct Type * type);
 472
 473 extern int ComputeTypeSize(struct Type * type);
 474
 475 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
 476
 477 struct Symbol;
 478
 479 struct Symbol
 480 {
 481 char *  string;
 482 struct Symbol * parent;
 483 struct Symbol * left;
 484 struct Symbol * right;
 485 int depth;
 486 struct Type * type;
 487 union
 488 {
 489 struct __ecereNameSpace__ecere__com__Method * method;
 490 struct __ecereNameSpace__ecere__com__Property * _property;
 491 struct __ecereNameSpace__ecere__com__Class * registered;
 492 } ecere_gcc_struct __anon1;
 493 unsigned int notYetDeclared;
 494 union
 495 {
 496 struct
 497 {
 498 struct External * pointerExternal;
 499 struct External * structExternal;
 500 } ecere_gcc_struct __anon1;
 501 struct
 502 {
 503 struct External * externalGet;
 504 struct External * externalSet;
 505 struct External * externalPtr;
 506 struct External * externalIsSet;
 507 } ecere_gcc_struct __anon2;
 508 struct
 509 {
 510 struct External * methodExternal;
 511 struct External * methodCodeExternal;
 512 } ecere_gcc_struct __anon3;
 513 } ecere_gcc_struct __anon2;
 514 unsigned int imported;
 515 unsigned int declaredStructSym;
 516 struct __ecereNameSpace__ecere__com__Class * _class;
 517 unsigned int declaredStruct;
 518 unsigned int needConstructor;
 519 unsigned int needDestructor;
 520 char *  constructorName;
 521 char *  structName;
 522 char *  className;
 523 char *  destructorName;
 524 struct ModuleImport * module;
 525 struct ClassImport * _import;
 526 struct Location nameLoc;
 527 unsigned int isParam;
 528 unsigned int isRemote;
 529 unsigned int isStruct;
 530 unsigned int fireWatchersDone;
 531 int declaring;
 532 unsigned int classData;
 533 unsigned int isStatic;
 534 char *  shortName;
 535 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 536 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 537 struct Context * ctx;
 538 int isIterator;
 539 struct Expression * propCategory;
 540 unsigned int mustRegister;
 541 } ecere_gcc_struct;
 542
 543 extern struct Symbol * FindClass(const char *  name);
 544
 545 struct Declarator;
 546
 547 extern struct Declarator * GetFuncDecl(struct Declarator * decl);
 548
 549 extern struct Declarator * CopyDeclarator(struct Declarator * declarator);
 550
 551 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
 552
 553 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
 554
 555 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
 556
 557 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
 558
 559 struct TemplateDatatype
 560 {
 561 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 562 struct Declarator * decl;
 563 } ecere_gcc_struct;
 564
 565 struct Identifier;
 566
 567 struct Declarator
 568 {
 569 struct Declarator * prev;
 570 struct Declarator * next;
 571 struct Location loc;
 572 int type;
 573 struct Symbol * symbol;
 574 struct Declarator * declarator;
 575 union
 576 {
 577 struct Identifier * identifier;
 578 struct
 579 {
 580 struct Expression * exp;
 581 struct Expression * posExp;
 582 struct Attrib * attrib;
 583 } ecere_gcc_struct structDecl;
 584 struct
 585 {
 586 struct Expression * exp;
 587 struct Specifier * enumClass;
 588 } ecere_gcc_struct array;
 589 struct
 590 {
 591 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 592 } ecere_gcc_struct function;
 593 struct
 594 {
 595 struct Pointer * pointer;
 596 } ecere_gcc_struct pointer;
 597 struct
 598 {
 599 struct ExtDecl * extended;
 600 } ecere_gcc_struct extended;
 601 } ecere_gcc_struct __anon1;
 602 } ecere_gcc_struct;
 603
 604 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
 605
 606 extern struct Identifier * MkIdentifier(const char *  string);
 607
 608 extern struct Expression * MkExpIdentifier(struct Identifier * id);
 609
 610 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
 611
 612 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
 613
 614 struct Identifier
 615 {
 616 struct Identifier * prev;
 617 struct Identifier * next;
 618 struct Location loc;
 619 struct Symbol * classSym;
 620 struct Specifier * _class;
 621 char *  string;
 622 struct Identifier * badID;
 623 } ecere_gcc_struct;
 624
 625 extern struct Identifier * GetDeclId(struct Declarator * decl);
 626
 627 struct ClassPropertyValue
 628 {
 629 struct __ecereNameSpace__ecere__com__Class * regClass;
 630 unsigned int staticClass;
 631 struct Identifier * id;
 632 struct Expression * exp;
 633 } ecere_gcc_struct;
 634
 635 extern void FreeIdentifier(struct Identifier * id);
 636
 637 struct __ecereNameSpace__ecere__sys__NamedLink64;
 638
 639 struct __ecereNameSpace__ecere__sys__NamedLink64
 640 {
 641 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
 642 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
 643 char *  name;
 644 long long data;
 645 } ecere_gcc_struct;
 646
 647 struct __ecereNameSpace__ecere__sys__OldLink;
 648
 649 struct __ecereNameSpace__ecere__sys__OldLink
 650 {
 651 struct __ecereNameSpace__ecere__sys__OldLink * prev;
 652 struct __ecereNameSpace__ecere__sys__OldLink * next;
 653 void *  data;
 654 } ecere_gcc_struct;
 655
 656 struct ClassFunction;
 657
 658 struct ClassFunction
 659 {
 660 struct ClassFunction * prev;
 661 struct ClassFunction * next;
 662 struct Location loc;
 663 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 664 struct Declarator * declarator;
 665 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 666 struct Statement * body;
 667 struct __ecereNameSpace__ecere__com__Class * _class;
 668 struct __ecereNameSpace__ecere__sys__OldList attached;
 669 int declMode;
 670 struct Type * type;
 671 struct Symbol * propSet;
 672 unsigned int isVirtual;
 673 unsigned int isConstructor;
 674 unsigned int isDestructor;
 675 unsigned int dontMangle;
 676 int id;
 677 int idCode;
 678 } ecere_gcc_struct;
 679
 680 extern struct ClassFunction * MkClassFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Specifier * _class, struct Declarator * decl, struct __ecereNameSpace__ecere__sys__OldList * declList);
 681
 682 extern void ProcessClassFunctionBody(struct ClassFunction * func, struct Statement * body);
 683
 684 struct PropertyWatch;
 685
 686 struct PropertyWatch
 687 {
 688 struct PropertyWatch * prev;
 689 struct PropertyWatch * next;
 690 struct Location loc;
 691 struct Statement * compound;
 692 struct __ecereNameSpace__ecere__sys__OldList *  properties;
 693 unsigned int deleteWatch;
 694 } ecere_gcc_struct;
 695
 696 extern void FreePropertyWatch(struct PropertyWatch * watcher);
 697
 698 struct Declaration;
 699
 700 struct Statement
 701 {
 702 struct Statement * prev;
 703 struct Statement * next;
 704 struct Location loc;
 705 int type;
 706 union
 707 {
 708 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 709 struct
 710 {
 711 struct Identifier * id;
 712 struct Statement * stmt;
 713 } ecere_gcc_struct labeled;
 714 struct
 715 {
 716 struct Expression * exp;
 717 struct Statement * stmt;
 718 } ecere_gcc_struct caseStmt;
 719 struct
 720 {
 721 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 722 struct __ecereNameSpace__ecere__sys__OldList * statements;
 723 struct Context * context;
 724 unsigned int isSwitch;
 725 } ecere_gcc_struct compound;
 726 struct
 727 {
 728 struct __ecereNameSpace__ecere__sys__OldList * exp;
 729 struct Statement * stmt;
 730 struct Statement * elseStmt;
 731 } ecere_gcc_struct ifStmt;
 732 struct
 733 {
 734 struct __ecereNameSpace__ecere__sys__OldList * exp;
 735 struct Statement * stmt;
 736 } ecere_gcc_struct switchStmt;
 737 struct
 738 {
 739 struct __ecereNameSpace__ecere__sys__OldList * exp;
 740 struct Statement * stmt;
 741 } ecere_gcc_struct whileStmt;
 742 struct
 743 {
 744 struct __ecereNameSpace__ecere__sys__OldList * exp;
 745 struct Statement * stmt;
 746 } ecere_gcc_struct doWhile;
 747 struct
 748 {
 749 struct Statement * init;
 750 struct Statement * check;
 751 struct __ecereNameSpace__ecere__sys__OldList * increment;
 752 struct Statement * stmt;
 753 } ecere_gcc_struct forStmt;
 754 struct
 755 {
 756 struct Identifier * id;
 757 } ecere_gcc_struct gotoStmt;
 758 struct
 759 {
 760 struct Specifier * spec;
 761 char * statements;
 762 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 763 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 764 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 765 } ecere_gcc_struct asmStmt;
 766 struct
 767 {
 768 struct Expression * watcher;
 769 struct Expression * object;
 770 struct __ecereNameSpace__ecere__sys__OldList * watches;
 771 } ecere_gcc_struct _watch;
 772 struct
 773 {
 774 struct Identifier * id;
 775 struct __ecereNameSpace__ecere__sys__OldList * exp;
 776 struct __ecereNameSpace__ecere__sys__OldList * filter;
 777 struct Statement * stmt;
 778 } ecere_gcc_struct forEachStmt;
 779 struct Declaration * decl;
 780 } ecere_gcc_struct __anon1;
 781 } ecere_gcc_struct;
 782
 783 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
 784
 785 struct Declaration
 786 {
 787 struct Declaration * prev;
 788 struct Declaration * next;
 789 struct Location loc;
 790 int type;
 791 union
 792 {
 793 struct
 794 {
 795 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 796 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 797 } ecere_gcc_struct __anon1;
 798 struct Instantiation * inst;
 799 struct
 800 {
 801 struct Identifier * id;
 802 struct Expression * exp;
 803 } ecere_gcc_struct __anon2;
 804 } ecere_gcc_struct __anon1;
 805 struct Specifier * extStorage;
 806 struct Symbol * symbol;
 807 int declMode;
 808 } ecere_gcc_struct;
 809
 810 struct Initializer;
 811
 812 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
 813
 814 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
 815
 816 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
 817
 818 struct Initializer
 819 {
 820 struct Initializer * prev;
 821 struct Initializer * next;
 822 struct Location loc;
 823 int type;
 824 union
 825 {
 826 struct Expression * exp;
 827 struct __ecereNameSpace__ecere__sys__OldList *  list;
 828 } ecere_gcc_struct __anon1;
 829 unsigned int isConstant;
 830 struct Identifier * id;
 831 } ecere_gcc_struct;
 832
 833 struct FunctionDefinition;
 834
 835 extern struct FunctionDefinition * _MkFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * declarationList, unsigned int errorOnOmit);
 836
 837 struct FunctionDefinition
 838 {
 839 struct FunctionDefinition * prev;
 840 struct FunctionDefinition * next;
 841 struct Location loc;
 842 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 843 struct Declarator * declarator;
 844 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 845 struct Statement * body;
 846 struct __ecereNameSpace__ecere__com__Class * _class;
 847 struct __ecereNameSpace__ecere__sys__OldList attached;
 848 int declMode;
 849 struct Type * type;
 850 struct Symbol * propSet;
 851 int tempCount;
 852 unsigned int propertyNoThis;
 853 } ecere_gcc_struct;
 854
 855 extern void ProcessFunctionBody(struct FunctionDefinition * func, struct Statement * body);
 856
 857 extern struct External * MkExternalFunction(struct FunctionDefinition * function);
 858
 859 struct TypeName;
 860
 861 struct TypeName
 862 {
 863 struct TypeName * prev;
 864 struct TypeName * next;
 865 struct Location loc;
 866 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 867 struct Declarator * declarator;
 868 int classObjectType;
 869 struct Expression * bitCount;
 870 } ecere_gcc_struct;
 871
 872 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
 873
 874 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
 875
 876 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
 877
 878 struct Expression
 879 {
 880 struct Expression * prev;
 881 struct Expression * next;
 882 struct Location loc;
 883 int type;
 884 union
 885 {
 886 struct
 887 {
 888 char *  constant;
 889 struct Identifier * identifier;
 890 } ecere_gcc_struct __anon1;
 891 struct Statement * compound;
 892 struct Instantiation * instance;
 893 struct
 894 {
 895 char *  string;
 896 unsigned int intlString;
 897 unsigned int wideString;
 898 } ecere_gcc_struct __anon2;
 899 struct __ecereNameSpace__ecere__sys__OldList *  list;
 900 struct
 901 {
 902 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 903 struct Declarator * decl;
 904 } ecere_gcc_struct _classExp;
 905 struct
 906 {
 907 struct Identifier * id;
 908 } ecere_gcc_struct classData;
 909 struct
 910 {
 911 struct Expression * exp;
 912 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 913 struct Location argLoc;
 914 } ecere_gcc_struct call;
 915 struct
 916 {
 917 struct Expression * exp;
 918 struct __ecereNameSpace__ecere__sys__OldList * index;
 919 } ecere_gcc_struct index;
 920 struct
 921 {
 922 struct Expression * exp;
 923 struct Identifier * member;
 924 int memberType;
 925 unsigned int thisPtr;
 926 } ecere_gcc_struct member;
 927 struct
 928 {
 929 int op;
 930 struct Expression * exp1;
 931 struct Expression * exp2;
 932 } ecere_gcc_struct op;
 933 struct TypeName * typeName;
 934 struct Specifier * _class;
 935 struct
 936 {
 937 struct TypeName * typeName;
 938 struct Expression * exp;
 939 } ecere_gcc_struct cast;
 940 struct
 941 {
 942 struct Expression * cond;
 943 struct __ecereNameSpace__ecere__sys__OldList * exp;
 944 struct Expression * elseExp;
 945 } ecere_gcc_struct cond;
 946 struct
 947 {
 948 struct TypeName * typeName;
 949 struct Expression * size;
 950 } ecere_gcc_struct _new;
 951 struct
 952 {
 953 struct TypeName * typeName;
 954 struct Expression * size;
 955 struct Expression * exp;
 956 } ecere_gcc_struct _renew;
 957 struct
 958 {
 959 char * table;
 960 struct Identifier * id;
 961 } ecere_gcc_struct db;
 962 struct
 963 {
 964 struct Expression * ds;
 965 struct Expression * name;
 966 } ecere_gcc_struct dbopen;
 967 struct
 968 {
 969 struct TypeName * typeName;
 970 struct Initializer * initializer;
 971 } ecere_gcc_struct initializer;
 972 struct
 973 {
 974 struct Expression * exp;
 975 struct TypeName * typeName;
 976 } ecere_gcc_struct vaArg;
 977 struct
 978 {
 979 struct TypeName * typeName;
 980 struct Identifier * id;
 981 } ecere_gcc_struct offset;
 982 } ecere_gcc_struct __anon1;
 983 unsigned int debugValue;
 984 struct __ecereNameSpace__ecere__com__DataValue val;
 985 uint64 address;
 986 unsigned int hasAddress;
 987 struct Type * expType;
 988 struct Type * destType;
 989 unsigned int usage;
 990 int tempCount;
 991 unsigned int byReference;
 992 unsigned int isConstant;
 993 unsigned int addedThis;
 994 unsigned int needCast;
 995 unsigned int thisPtr;
 996 unsigned int opDestType;
 997 unsigned int usedInComparison;
 998 unsigned int ambiguousUnits;
 999 unsigned int parentOpDestType;
1000 unsigned int needTemplateCast;
1001 } ecere_gcc_struct;
1002
1003 struct Operand;
1004
1005 struct OpTable
1006 {
1007 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1008 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1009 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1010 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1011 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1012 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1013 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1014 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1015 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1016 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1017 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1018 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1019 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1020 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1021 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
1022 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
1023 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
1024 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
1025 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
1026 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
1027 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
1028 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
1029 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
1030 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1031 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1032 unsigned int (*  Not)(struct Expression *, struct Operand *);
1033 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
1034 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
1035 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
1036 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
1037 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
1038 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
1039 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
1040 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
1041 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
1042 } ecere_gcc_struct;
1043
1044 struct Operand
1045 {
1046 int kind;
1047 struct Type * type;
1048 unsigned int ptrSize;
1049 union
1050 {
1051 char c;
1052 unsigned char uc;
1053 short s;
1054 unsigned short us;
1055 int i;
1056 unsigned int ui;
1057 float f;
1058 double d;
1059 long long i64;
1060 uint64 ui64;
1061 } ecere_gcc_struct __anon1;
1062 struct OpTable ops;
1063 } ecere_gcc_struct;
1064
1065 extern struct Operand GetOperand(struct Expression * exp);
1066
1067 struct __ecereNameSpace__ecere__sys__BinaryTree;
1068
1069 struct __ecereNameSpace__ecere__sys__BinaryTree
1070 {
1071 struct __ecereNameSpace__ecere__sys__BTNode * root;
1072 int count;
1073 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
1074 void (*  FreeKey)(void *  key);
1075 } ecere_gcc_struct;
1076
1077 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1078
1079 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(struct __ecereNameSpace__ecere__sys__BinaryTree * this);
1080
1081 struct TemplateParameter;
1082
1083 struct Specifier
1084 {
1085 struct Specifier * prev;
1086 struct Specifier * next;
1087 struct Location loc;
1088 int type;
1089 union
1090 {
1091 int specifier;
1092 struct
1093 {
1094 struct ExtDecl * extDecl;
1095 char *  name;
1096 struct Symbol * symbol;
1097 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
1098 struct Specifier * nsSpec;
1099 } ecere_gcc_struct __anon1;
1100 struct
1101 {
1102 struct Identifier * id;
1103 struct __ecereNameSpace__ecere__sys__OldList *  list;
1104 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
1105 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
1106 unsigned int addNameSpace;
1107 struct Context * ctx;
1108 struct ExtDecl * extDeclStruct;
1109 } ecere_gcc_struct __anon2;
1110 struct Expression * expression;
1111 struct Specifier * _class;
1112 struct TemplateParameter * templateParameter;
1113 } ecere_gcc_struct __anon1;
1114 } ecere_gcc_struct;
1115
1116 struct Type
1117 {
1118 struct Type * prev;
1119 struct Type * next;
1120 int refCount;
1121 union
1122 {
1123 struct Symbol * _class;
1124 struct
1125 {
1126 struct __ecereNameSpace__ecere__sys__OldList members;
1127 char *  enumName;
1128 } ecere_gcc_struct __anon1;
1129 struct
1130 {
1131 struct Type * returnType;
1132 struct __ecereNameSpace__ecere__sys__OldList params;
1133 struct Symbol * thisClass;
1134 unsigned int staticMethod;
1135 struct TemplateParameter * thisClassTemplate;
1136 } ecere_gcc_struct __anon2;
1137 struct
1138 {
1139 struct __ecereNameSpace__ecere__com__Method * method;
1140 struct __ecereNameSpace__ecere__com__Class * methodClass;
1141 struct __ecereNameSpace__ecere__com__Class * usedClass;
1142 } ecere_gcc_struct __anon3;
1143 struct
1144 {
1145 struct Type * arrayType;
1146 int arraySize;
1147 struct Expression * arraySizeExp;
1148 unsigned int freeExp;
1149 struct Symbol * enumClass;
1150 } ecere_gcc_struct __anon4;
1151 struct Type * type;
1152 struct TemplateParameter * templateParameter;
1153 } ecere_gcc_struct __anon1;
1154 int kind;
1155 unsigned int size;
1156 char *  name;
1157 char *  typeName;
1158 struct __ecereNameSpace__ecere__com__Class * thisClassFrom;
1159 int promotedFrom;
1160 int classObjectType;
1161 int alignment;
1162 unsigned int offset;
1163 int bitFieldCount;
1164 int count;
1165 int bitMemberSize;
1166 unsigned int isSigned : 1;
1167 unsigned int constant : 1;
1168 unsigned int truth : 1;
1169 unsigned int byReference : 1;
1170 unsigned int extraParam : 1;
1171 unsigned int directClassAccess : 1;
1172 unsigned int computing : 1;
1173 unsigned int keepCast : 1;
1174 unsigned int passAsTemplate : 1;
1175 unsigned int dllExport : 1;
1176 unsigned int attrStdcall : 1;
1177 unsigned int declaredWithStruct : 1;
1178 unsigned int typedByReference : 1;
1179 unsigned int casted : 1;
1180 unsigned int pointerAlignment : 1;
1181 unsigned int isLong : 1;
1182 unsigned int signedBeforePromotion : 1;
1183 unsigned int isVector : 1;
1184 } ecere_gcc_struct;
1185
1186 unsigned int __ecereProp_Type_Get_isPointerTypeSize(struct Type * this);
1187
1188 unsigned int __ecereProp_Type_Get_isPointerType(struct Type * this);
1189
1190 struct __ecereNameSpace__ecere__com__Module;
1191
1192 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1193
1194 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1195
1196 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
1197
1198 extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(const char *  name, const char *  type, void *  func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
1199
1200 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, const char *  name, const char *  baseName, int size, int sizeClass, unsigned int (*  Constructor)(void * ), void (*  Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
1201
1202 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1203
1204 struct __ecereNameSpace__ecere__com__DataMember;
1205
1206 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
1207 {
1208 union
1209 {
1210 struct
1211 {
1212 const char *  dataTypeString;
1213 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1214 } ecere_gcc_struct __anon1;
1215 struct __ecereNameSpace__ecere__com__DataValue expression;
1216 struct
1217 {
1218 const char *  memberString;
1219 union
1220 {
1221 struct __ecereNameSpace__ecere__com__DataMember * member;
1222 struct __ecereNameSpace__ecere__com__Property * prop;
1223 struct __ecereNameSpace__ecere__com__Method * method;
1224 } ecere_gcc_struct __anon1;
1225 } ecere_gcc_struct __anon2;
1226 } ecere_gcc_struct __anon1;
1227 } ecere_gcc_struct;
1228
1229 struct __ecereNameSpace__ecere__com__DataMember
1230 {
1231 struct __ecereNameSpace__ecere__com__DataMember * prev;
1232 struct __ecereNameSpace__ecere__com__DataMember * next;
1233 const char *  name;
1234 unsigned int isProperty;
1235 int memberAccess;
1236 int id;
1237 struct __ecereNameSpace__ecere__com__Class * _class;
1238 const char *  dataTypeString;
1239 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1240 struct Type * dataType;
1241 int type;
1242 int offset;
1243 int memberID;
1244 struct __ecereNameSpace__ecere__sys__OldList members;
1245 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
1246 int memberOffset;
1247 short structAlignment;
1248 short pointerAlignment;
1249 } ecere_gcc_struct;
1250
1251 extern struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  FindTemplateArg(struct __ecereNameSpace__ecere__com__Class * _class, struct TemplateParameter * param);
1252
1253 struct __ecereNameSpace__ecere__com__BitMember;
1254
1255 struct __ecereNameSpace__ecere__com__BitMember
1256 {
1257 struct __ecereNameSpace__ecere__com__BitMember * prev;
1258 struct __ecereNameSpace__ecere__com__BitMember * next;
1259 const char *  name;
1260 unsigned int isProperty;
1261 int memberAccess;
1262 int id;
1263 struct __ecereNameSpace__ecere__com__Class * _class;
1264 const char *  dataTypeString;
1265 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1266 struct Type * dataType;
1267 int type;
1268 int size;
1269 int pos;
1270 uint64 mask;
1271 } ecere_gcc_struct;
1272
1273 struct __ecereNameSpace__ecere__com__ClassProperty;
1274
1275 struct __ecereNameSpace__ecere__com__ClassProperty
1276 {
1277 const char *  name;
1278 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1279 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1280 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1281 int depth;
1282 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1283 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1284 const char *  dataTypeString;
1285 struct Type * dataType;
1286 unsigned int constant;
1287 } ecere_gcc_struct;
1288
1289 struct ClassDefinition;
1290
1291 struct External
1292 {
1293 struct External * prev;
1294 struct External * next;
1295 struct Location loc;
1296 int type;
1297 struct Symbol * symbol;
1298 union
1299 {
1300 struct FunctionDefinition * function;
1301 struct ClassDefinition * _class;
1302 struct Declaration * declaration;
1303 char *  importString;
1304 struct Identifier * id;
1305 struct DBTableDef * table;
1306 } ecere_gcc_struct __anon1;
1307 int importType;
1308 struct External * fwdDecl;
1309 struct __ecereNameSpace__ecere__com__Instance * outgoing;
1310 struct __ecereNameSpace__ecere__com__Instance * incoming;
1311 int nonBreakableIncoming;
1312 } ecere_gcc_struct;
1313
1314 struct Context
1315 {
1316 struct Context * parent;
1317 struct __ecereNameSpace__ecere__sys__BinaryTree types;
1318 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1319 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
1320 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
1321 int nextID;
1322 int simpleID;
1323 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
1324 struct ClassDefinition * classDef;
1325 unsigned int templateTypesOnly;
1326 unsigned int hasNameSpace;
1327 } ecere_gcc_struct;
1328
1329 struct ClassDefinition
1330 {
1331 struct ClassDefinition * prev;
1332 struct ClassDefinition * next;
1333 struct Location loc;
1334 struct Specifier * _class;
1335 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
1336 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
1337 struct Symbol * symbol;
1338 struct Location blockStart;
1339 struct Location nameLoc;
1340 int declMode;
1341 unsigned int deleteWatchable;
1342 } ecere_gcc_struct;
1343
1344 void __ecereMethod_External_CreateUniqueEdge(struct External * this, struct External * from, unsigned int soft);
1345
1346 struct Enumerator;
1347
1348 struct Enumerator
1349 {
1350 struct Enumerator * prev;
1351 struct Enumerator * next;
1352 struct Location loc;
1353 struct Identifier * id;
1354 struct Expression * exp;
1355 } ecere_gcc_struct;
1356
1357 struct TemplateArgument;
1358
1359 struct TemplateParameter
1360 {
1361 struct TemplateParameter * prev;
1362 struct TemplateParameter * next;
1363 struct Location loc;
1364 int type;
1365 struct Identifier * identifier;
1366 union
1367 {
1368 struct TemplateDatatype * dataType;
1369 int memberType;
1370 } ecere_gcc_struct __anon1;
1371 struct TemplateArgument * defaultArgument;
1372 const char *  dataTypeString;
1373 struct Type * baseType;
1374 } ecere_gcc_struct;
1375
1376 struct TemplateArgument
1377 {
1378 struct TemplateArgument * prev;
1379 struct TemplateArgument * next;
1380 struct Location loc;
1381 struct Identifier * name;
1382 int type;
1383 union
1384 {
1385 struct Expression * expression;
1386 struct Identifier * identifier;
1387 struct TemplateDatatype * templateDatatype;
1388 } ecere_gcc_struct __anon1;
1389 } ecere_gcc_struct;
1390
1391 struct ClassDef;
1392
1393 typedef union YYSTYPE
1394 {
1395 int specifierType;
1396 int i;
1397 int declMode;
1398 struct Identifier * id;
1399 struct Expression * exp;
1400 struct Specifier * specifier;
1401 struct __ecereNameSpace__ecere__sys__OldList * list;
1402 struct Enumerator * enumerator;
1403 struct Declarator * declarator;
1404 struct Pointer * pointer;
1405 struct Initializer * initializer;
1406 struct InitDeclarator * initDeclarator;
1407 struct TypeName * typeName;
1408 struct Declaration * declaration;
1409 struct Statement * stmt;
1410 struct FunctionDefinition * function;
1411 struct External * external;
1412 struct Context * context;
1413 struct AsmField * asmField;
1414 struct Attrib * attrib;
1415 struct ExtDecl * extDecl;
1416 struct Attribute * attribute;
1417 struct Instantiation * instance;
1418 struct MembersInit * membersInit;
1419 struct MemberInit * memberInit;
1420 struct ClassFunction * classFunction;
1421 struct ClassDefinition * _class;
1422 struct ClassDef * classDef;
1423 struct PropertyDef * prop;
1424 char * string;
1425 struct Symbol * symbol;
1426 struct PropertyWatch * propertyWatch;
1427 struct TemplateParameter * templateParameter;
1428 struct TemplateArgument * templateArgument;
1429 struct TemplateDatatype * templateDatatype;
1430 struct DBTableEntry * dbtableEntry;
1431 struct DBIndexItem * dbindexItem;
1432 struct DBTableDef * dbtableDef;
1433 } ecere_gcc_struct YYSTYPE;
1434
1435 extern YYSTYPE yylval;
1436
1437 struct ClassDef
1438 {
1439 struct ClassDef * prev;
1440 struct ClassDef * next;
1441 struct Location loc;
1442 int type;
1443 union
1444 {
1445 struct Declaration * decl;
1446 struct ClassFunction * function;
1447 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1448 struct PropertyDef * propertyDef;
1449 struct PropertyWatch * propertyWatch;
1450 char *  designer;
1451 struct Identifier * defaultProperty;
1452 struct
1453 {
1454 struct Identifier * id;
1455 struct Initializer * initializer;
1456 } ecere_gcc_struct __anon1;
1457 } ecere_gcc_struct __anon1;
1458 int memberAccess;
1459 void *  object;
1460 } ecere_gcc_struct;
1461
1462 extern struct ClassDef * MkClassDefFunction(struct ClassFunction * function);
1463
1464 struct __ecereNameSpace__ecere__com__NameSpace;
1465
1466 struct __ecereNameSpace__ecere__com__NameSpace
1467 {
1468 const char *  name;
1469 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1470 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1471 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1472 int depth;
1473 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1474 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1475 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1476 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1477 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1478 } ecere_gcc_struct;
1479
1480 struct __ecereNameSpace__ecere__com__Class
1481 {
1482 struct __ecereNameSpace__ecere__com__Class * prev;
1483 struct __ecereNameSpace__ecere__com__Class * next;
1484 const char *  name;
1485 int offset;
1486 int structSize;
1487 void * *  _vTbl;
1488 int vTblSize;
1489 unsigned int (*  Constructor)(void * );
1490 void (*  Destructor)(void * );
1491 int offsetClass;
1492 int sizeClass;
1493 struct __ecereNameSpace__ecere__com__Class * base;
1494 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
1495 struct __ecereNameSpace__ecere__sys__BinaryTree members;
1496 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
1497 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
1498 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
1499 struct __ecereNameSpace__ecere__sys__OldList derivatives;
1500 int memberID;
1501 int startMemberID;
1502 int type;
1503 struct __ecereNameSpace__ecere__com__Instance * module;
1504 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
1505 const char *  dataTypeString;
1506 struct Type * dataType;
1507 int typeSize;
1508 int defaultAlignment;
1509 void (*  Initialize)();
1510 int memberOffset;
1511 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
1512 const char *  designerClass;
1513 unsigned int noExpansion;
1514 const char *  defaultProperty;
1515 unsigned int comRedefinition;
1516 int count;
1517 int isRemote;
1518 unsigned int internalDecl;
1519 void *  data;
1520 unsigned int computeSize;
1521 short structAlignment;
1522 short pointerAlignment;
1523 int destructionWatchOffset;
1524 unsigned int fixed;
1525 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
1526 int inheritanceAccess;
1527 const char *  fullName;
1528 void *  symbol;
1529 struct __ecereNameSpace__ecere__sys__OldList conversions;
1530 struct __ecereNameSpace__ecere__sys__OldList templateParams;
1531 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
1532 struct __ecereNameSpace__ecere__com__Class * templateClass;
1533 struct __ecereNameSpace__ecere__sys__OldList templatized;
1534 int numParams;
1535 unsigned int isInstanceClass;
1536 unsigned int byValueSystemClass;
1537 } ecere_gcc_struct;
1538
1539 struct __ecereNameSpace__ecere__com__Application
1540 {
1541 int argc;
1542 const char * *  argv;
1543 int exitCode;
1544 unsigned int isGUIApp;
1545 struct __ecereNameSpace__ecere__sys__OldList allModules;
1546 char *  parsedCommand;
1547 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1548 } ecere_gcc_struct;
1549
1550 void GetNameSpaceString(struct __ecereNameSpace__ecere__com__NameSpace * ns, char * string)
1551 {
1552 if(ns->parent)
1553 GetNameSpaceString(ns->parent, string);
1554 if(ns->name)
1555 {
1556 strcat(string, ns->name);
1557 strcat(string, "::");
1558 }
1559 }
1560
1561 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassPropertyValue;
1562
1563 struct External * ProcessClassFunction(struct __ecereNameSpace__ecere__com__Class * owningClass, struct ClassFunction * func, struct __ecereNameSpace__ecere__sys__OldList * defs, struct External * after, unsigned int makeStatic)
1564 {
1565 struct Type * type = (((void *)0));
1566 struct Symbol * symbol;
1567 struct External * external = (((void *)0));
1568
1569 if(defs && func->declarator)
1570 {
1571 struct FunctionDefinition * function = (((void *)0));
1572 struct Symbol * propSymbol;
1573
1574 if(inCompiler)
1575 {
1576 if(!func->specifiers)
1577 func->specifiers = MkList();
1578 if(makeStatic)
1579 {
1580 struct Specifier * s;
1581
1582 for(s = (*func->specifiers).first; s; s = s->next)
1583 if(s->type == 0 && s->__anon1.specifier == STATIC)
1584 break;
1585 if(!s)
1586 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*func->specifiers), (((void *)0)), MkSpecifier(STATIC));
1587 }
1588 }
1589 propSymbol = func->declarator->symbol;
1590 ReplaceThisClassSpecifiers(func->specifiers, owningClass);
1591 if(propSymbol->__anon2.__anon2.externalGet == (struct External *)func)
1592 func->declarator->symbol = (((void *)0));
1593 else if(propSymbol->__anon2.__anon2.externalSet == (struct External *)func)
1594 func->declarator->symbol = (((void *)0));
1595 else if(propSymbol->__anon2.__anon2.externalIsSet == (struct External *)func)
1596 func->declarator->symbol = (((void *)0));
1597 {
1598 function = _MkFunction(func->specifiers, func->declarator, (((void *)0)), 0);
1599 function->propSet = func->propSet;
1600 function->type = func->type;
1601 if(func->type)
1602 func->type->refCount++;
1603 ProcessFunctionBody(function, func->body);
1604 external = MkExternalFunction(function);
1605 external->symbol = func->declarator->symbol;
1606 external->__anon1.function->_class = func->_class;
1607 }
1608 symbol = func->declarator->symbol;
1609 if(!func->dontMangle)
1610 {
1611 struct __ecereNameSpace__ecere__com__Method * method = func->declarator->symbol->__anon1.method;
1612
1613 func->declarator->symbol->__anon2.__anon3.methodExternal = external;
1614 if(method && method->symbol)
1615 ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal = external;
1616 if(method && method->type == 1)
1617 {
1618 struct Type * methodDataType;
1619
1620 ProcessMethodType(method);
1621 methodDataType = method->dataType;
1622 type = symbol->type;
1623 if(!type->__anon1.__anon2.staticMethod && !type->__anon1.__anon2.thisClass && !type->__anon1.__anon2.thisClassTemplate)
1624 {
1625 if(method->dataType->__anon1.__anon2.thisClassTemplate)
1626 {
1627 if(owningClass->templateArgs)
1628 {
1629 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = FindTemplateArg(owningClass, method->dataType->__anon1.__anon2.thisClassTemplate);
1630
1631 type->byReference = method->dataType->byReference;
1632 methodDataType = ProcessTypeString(method->dataTypeString, 0);
1633 type->__anon1.__anon2.thisClass = methodDataType->__anon1.__anon2.thisClass = (arg && (*arg).__anon1.__anon1.dataTypeString) ? FindClass((*arg).__anon1.__anon1.dataTypeString) : (((void *)0));
1634 }
1635 }
1636 else if(method->dataType->__anon1.__anon2.staticMethod)
1637 type->__anon1.__anon2.staticMethod = 1;
1638 else if(method->dataType->__anon1.__anon2.thisClass)
1639 {
1640 type->__anon1.__anon2.thisClass = method->dataType->__anon1.__anon2.thisClass;
1641 type->byReference = method->dataType->byReference;
1642 }
1643 else
1644 {
1645 if(!owningClass->symbol)
1646 owningClass->symbol = FindClass(owningClass->fullName);
1647 type->__anon1.__anon2.thisClass = owningClass->symbol;
1648 type->extraParam = 1;
1649 }
1650 }
1651 yylloc = func->loc;
1652 if(!MatchTypes(type, methodDataType, (((void *)0)), owningClass, method->_class, 1, 1, 1, 0, 1))
1653 {
1654 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Incompatible virtual function %s\n", (((void *)0))), method->name);
1655 }
1656 else
1657 {
1658 struct Type * typeParam;
1659 struct Declarator * funcDecl = GetFuncDecl(func->declarator);
1660
1661 if(funcDecl->__anon1.function.parameters && (*funcDecl->__anon1.function.parameters).first)
1662 {
1663 struct TypeName * param = (*funcDecl->__anon1.function.parameters).first;
1664
1665 for(typeParam = methodDataType->__anon1.__anon2.params.first; typeParam && param; typeParam = typeParam->next)
1666 {
1667 if(typeParam->classObjectType)
1668 {
1669 param->classObjectType = typeParam->classObjectType;
1670 if(param->declarator && param->declarator->symbol)
1671 param->declarator->symbol->type->classObjectType = typeParam->classObjectType;
1672 }
1673 param = param ? param->next : (((void *)0));
1674 }
1675 }
1676 }
1677 if(methodDataType != method->dataType)
1678 FreeType(methodDataType);
1679 }
1680 else
1681 {
1682 type = symbol->type;
1683 if(!type->__anon1.__anon2.staticMethod && !type->__anon1.__anon2.thisClass)
1684 {
1685 if(owningClass && !owningClass->symbol)
1686 owningClass->symbol = FindClass(owningClass->fullName);
1687 type->__anon1.__anon2.thisClass = owningClass ? FindClass(owningClass->fullName) : (((void *)0));
1688 }
1689 }
1690 }
1691 else
1692 {
1693 if(symbol->type && !symbol->type->__anon1.__anon2.staticMethod && !symbol->type->__anon1.__anon2.thisClass)
1694 {
1695 if(!owningClass->symbol)
1696 owningClass->symbol = FindClass(owningClass->fullName);
1697 symbol->type->__anon1.__anon2.thisClass = owningClass->symbol;
1698 }
1699 if(propSymbol->__anon2.__anon2.externalSet == (struct External *)func && propSymbol->__anon1._property && propSymbol->__anon1._property->conversion)
1700 {
1701 if(symbol->type->__anon1.__anon2.thisClass && symbol->type->classObjectType != 1)
1702 {
1703 if(owningClass->type != 1)
1704 symbol->type->__anon1.__anon2.thisClass = (((void *)0));
1705 }
1706 }
1707 if(propSymbol->__anon2.__anon2.externalGet == (struct External *)func)
1708 {
1709 propSymbol->__anon2.__anon2.externalGet = external;
1710 }
1711 else if(propSymbol->__anon2.__anon2.externalSet == (struct External *)func)
1712 {
1713 propSymbol->__anon2.__anon2.externalSet = external;
1714 }
1715 else if(propSymbol->__anon2.__anon2.externalIsSet == (struct External *)func)
1716 {
1717 propSymbol->__anon2.__anon2.externalIsSet = external;
1718 }
1719 else
1720 {
1721 }
1722 }
1723 if(inCompiler)
1724 {
1725 if(func->body)
1726 {
1727 func->declarator = (((void *)0));
1728 func->specifiers = (((void *)0));
1729 func->body = (((void *)0));
1730 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1731 }
1732 else
1733 {
1734 struct __ecereNameSpace__ecere__com__Method * method = func->declarator->symbol->__anon1.method;
1735
1736 if(method && method->symbol)
1737 ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal = (((void *)0));
1738 if(func->declarator->symbol && func->declarator->symbol->__anon2.__anon3.methodExternal == external)
1739 func->declarator->symbol->__anon2.__anon3.methodExternal = (((void *)0));
1740 func->declarator = (((void *)0));
1741 func->specifiers = (((void *)0));
1742 FreeExternal(external);
1743 }
1744 }
1745 else
1746 {
1747 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)symbol);
1748 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), symbol);
1749 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1750 external->__anon1.function->declarator = CopyDeclarator(external->__anon1.function->declarator);
1751 external->__anon1.function->specifiers = CopyList(external->__anon1.function->specifiers, (void *)(CopySpecifier));
1752 external->__anon1.function->body = (((void *)0));
1753 }
1754 }
1755 return external;
1756 }
1757
1758 void RegisterMembersAndProperties(struct __ecereNameSpace__ecere__com__Class * regClass, unsigned int isMember, const char * className, struct Statement * statement)
1759 {
1760 struct __ecereNameSpace__ecere__com__DataMember * dataMember = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)regClass : (((void *)0));
1761 struct __ecereNameSpace__ecere__com__DataMember * member;
1762 struct __ecereNameSpace__ecere__com__Property * prop;
1763 struct Expression * exp;
1764 struct Statement * stmt;
1765 char dataMemberSize[16];
1766 unsigned int lastOffset = 0;
1767 int privateID = 0;
1768 unsigned int privateMembers = 0;
1769
1770 sprintf(dataMemberSize, "%d", (int)sizeof(struct __ecereNameSpace__ecere__com__DataMember *));
1771 if(!isMember)
1772 {
1773 for(prop = regClass->conversions.first; prop; prop = prop->next)
1774 {
1775 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1776 char name[1024];
1777
1778 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1779 ListAdd(args, MkExpConstant("0"));
1780 {
1781 char * string = QMkString(prop->dataTypeString);
1782
1783 ListAdd(args, MkExpString(string));
1784 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1785 }
1786 if(prop->Set)
1787 {
1788 strcpy(name, "__ecereProp_");
1789 FullClassNameCat(name, regClass->fullName, 0);
1790 strcat(name, "_Set_");
1791 FullClassNameCat(name, prop->name, 1);
1792 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1793 }
1794 else
1795 ListAdd(args, MkExpConstant("0"));
1796 if(prop->Get)
1797 {
1798 strcpy(name, "__ecereProp_");
1799 FullClassNameCat(name, regClass->fullName, 0);
1800 strcat(name, "_Get_");
1801 FullClassNameCat(name, prop->name, 1);
1802 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1803 }
1804 else
1805 ListAdd(args, MkExpConstant("0"));
1806 switch(prop->memberAccess)
1807 {
1808 case 3:
1809 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1810 break;
1811 case 2:
1812 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1813 break;
1814 case 1:
1815 default:
1816 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1817 break;
1818 }
1819 strcpy(name, "__ecereProp_");
1820 FullClassNameCat(name, regClass->fullName, 0);
1821 strcat(name, "_");
1822 FullClassNameCat(name, prop->name, 1);
1823 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1824 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
1825 }
1826 }
1827 for(member = isMember ? dataMember->members.first : regClass->membersAndProperties.first; member; member = member->next)
1828 {
1829 if(member->isProperty)
1830 {
1831 prop = (struct __ecereNameSpace__ecere__com__Property *)member;
1832 {
1833 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1834 char name[1024], nameM[1024];
1835 char * string = QMkString(prop->name);
1836
1837 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1838 ListAdd(args, MkExpString(string));
1839 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1840 {
1841 char * string = QMkString(prop->dataTypeString);
1842
1843 ListAdd(args, MkExpString(string));
1844 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1845 }
1846 if(prop->Set)
1847 {
1848 strcpy(name, "__ecereProp_");
1849 FullClassNameCat(name, regClass->fullName, 0);
1850 strcat(name, "_Set_");
1851 FullClassNameCat(name, prop->name, 1);
1852 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1853 }
1854 else
1855 ListAdd(args, MkExpConstant("0"));
1856 if(prop->Get)
1857 {
1858 strcpy(name, "__ecereProp_");
1859 FullClassNameCat(name, regClass->fullName, 0);
1860 strcat(name, "_Get_");
1861 FullClassNameCat(name, prop->name, 1);
1862 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1863 }
1864 else
1865 ListAdd(args, MkExpConstant("0"));
1866 switch(prop->memberAccess)
1867 {
1868 case 3:
1869 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1870 break;
1871 case 2:
1872 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1873 break;
1874 case 1:
1875 default:
1876 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1877 break;
1878 }
1879 strcpy(name, "__ecereProp_");
1880 FullClassNameCat(name, regClass->fullName, 0);
1881 strcat(name, "_");
1882 FullClassNameCat(name, prop->name, 1);
1883 strcpy(nameM, "__ecerePropM_");
1884 FullClassNameCat(nameM, regClass->fullName, 0);
1885 strcat(nameM, "_");
1886 FullClassNameCat(nameM, prop->name, 1);
1887 if(prop->dataTypeString)
1888 {
1889 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1890 }
1891 else
1892 {
1893 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args)));
1894 }
1895 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
1896 if(prop->IsSet)
1897 {
1898 char name[1024];
1899
1900 strcpy(name, "__ecereProp_");
1901 FullClassNameCat(name, regClass->fullName, 1);
1902 strcat(name, "_IsSet_");
1903 FullClassNameCat(name, prop->name, 0);
1904 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier(nameM)), MkIdentifier("IsSet")), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(name))))));
1905 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
1906 }
1907 if(prop->symbol && ((struct Symbol *)prop->symbol)->propCategory)
1908 {
1909 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier(nameM)), MkIdentifier("category")), '=', CopyExpression(((struct Symbol *)prop->symbol)->propCategory))));
1910 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
1911 }
1912 if(prop->dataTypeString)
1913 {
1914 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1915
1916 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpIdentifier(MkIdentifier(nameM))));
1917 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0"))));
1918 stmt = MkIfStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("module")), MkIdentifier("application")), EQ_OP, MkExpMember(MkExpIdentifier(MkIdentifier("__thisModule")), MkIdentifier("application")))), MkExpressionStmt(list), (((void *)0)));
1919 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
1920 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")))));
1921 ListAdd(unregisterModuleBody->__anon1.compound.statements, stmt);
1922 }
1923 }
1924 }
1925 else if(member->type == 0 && !isMember && regClass->type == 2)
1926 {
1927 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)member;
1928 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1929
1930 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1931 {
1932 char * string = QMkString(bitMember->name);
1933
1934 ListAdd(args, MkExpString(string));
1935 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1936 }
1937 {
1938 char * string = QMkString(bitMember->dataTypeString);
1939
1940 ListAdd(args, MkExpString(string));
1941 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1942 }
1943 {
1944 char string[256];
1945
1946 sprintf(string, "%d", bitMember->size);
1947 ListAdd(args, (exp = MkExpConstant(string)));
1948 }
1949 {
1950 char string[256];
1951
1952 sprintf(string, "%d", bitMember->pos);
1953 ListAdd(args, (exp = MkExpConstant(string)));
1954 }
1955 switch(member->memberAccess)
1956 {
1957 case 3:
1958 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1959 break;
1960 case 2:
1961 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1962 break;
1963 case 1:
1964 default:
1965 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1966 break;
1967 }
1968 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddBitMember")), args)));
1969 ListAdd(statement->__anon1.compound.statements, stmt);
1970 }
1971 else if(member->memberAccess == 1 || (member->type == 0 && !member->dataTypeString))
1972 {
1973 struct __ecereNameSpace__ecere__sys__OldList * args;
1974
1975 if(privateMembers)
1976 {
1977 unsigned int offset = member->offset - lastOffset;
1978
1979 args = MkList();
1980 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1981 {
1982 char string[200];
1983
1984 sprintf(string, "\"__ecerePrivateData%d\"", privateID++);
1985 ListAdd(args, MkExpString(string));
1986 }
1987 {
1988 char string[200];
1989
1990 sprintf(string, "\"byte[%d]\"", offset);
1991 ListAdd(args, MkExpString(string));
1992 }
1993 {
1994 char string[256];
1995
1996 sprintf(string, "%d", offset);
1997 ListAdd(args, (exp = MkExpConstant(string)));
1998 }
1999 ListAdd(args, (exp = MkExpConstant("1")));
2000 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2001 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
2002 ListAdd(statement->__anon1.compound.statements, stmt);
2003 privateMembers = 0;
2004 }
2005 if(member->type == 0)
2006 {
2007 if(!member->dataType)
2008 member->dataType = ProcessTypeString(member->dataTypeString, 0);
2009 ComputeTypeSize(member->dataType);
2010 args = MkList();
2011 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
2012 {
2013 char * string = QMkString(member->name);
2014
2015 ListAdd(args, MkExpString(string));
2016 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2017 }
2018 {
2019 char * string = QMkString(member->dataTypeString);
2020
2021 ListAdd(args, MkExpString(string));
2022 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2023 }
2024 {
2025 if(__ecereProp_Type_Get_isPointerTypeSize(member->dataType))
2026 {
2027 ListAdd(args, (exp = MkExpTypeSize(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))))));
2028 ListAdd(args, (exp = MkExpConstant("0xF000F000")));
2029 }
2030 else
2031 {
2032 char string[256];
2033
2034 if(member->dataType->kind == 8 && member->dataType->__anon1._class && member->dataType->__anon1._class->__anon1.registered && member->dataType->__anon1._class->__anon1.registered->offset == 0 && (member->dataType->__anon1._class->__anon1.registered->type == 1 || member->dataType->__anon1._class->__anon1.registered->type == 5 || member->dataType->__anon1._class->__anon1.registered->type == 0))
2035 {
2036 string[0] = '\0';
2037 DeclareStruct(registerModuleExternal, member->dataType->__anon1._class->string, 0, 1);
2038 FullClassNameCat(string, member->dataType->__anon1._class->string, 0);
2039 exp = MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(string), (((void *)0)))), (((void *)0))));
2040 }
2041 else
2042 {
2043 sprintf(string, "%d", member->dataType->size);
2044 exp = MkExpConstant(string);
2045 }
2046 ListAdd(args, exp);
2047 if(member->dataType->pointerAlignment)
2048 exp = MkExpConstant("0xF000F000");
2049 else
2050 {
2051 sprintf(string, "%d", member->dataType->alignment);
2052 exp = MkExpConstant(string);
2053 }
2054 ListAdd(args, exp);
2055 }
2056 }
2057 switch(member->memberAccess)
2058 {
2059 case 3:
2060 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2061 break;
2062 case 2:
2063 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2064 break;
2065 case 1:
2066 default:
2067 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2068 break;
2069 }
2070 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
2071 ListAdd(statement->__anon1.compound.statements, stmt);
2072 lastOffset = member->offset + member->dataType->size;
2073 }
2074 else
2075 {
2076 static int memberCount = 0;
2077 struct Context * context;
2078 struct Statement * compound;
2079 char memberName[256];
2080
2081 sprintf(memberName, "dataMember%d", memberCount);
2082 memberCount++;
2083 curContext = statement->__anon1.compound.context;
2084 context = PushContext();
2085 args = MkListOne(MkExpIdentifier(MkIdentifier((member->type == 1) ? "unionMember" : "structMember")));
2086 switch(member->memberAccess)
2087 {
2088 case 3:
2089 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2090 break;
2091 case 2:
2092 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2093 break;
2094 case 1:
2095 default:
2096 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2097 break;
2098 }
2099 compound = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifierName("DataMember")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(memberName)), MkInitializerAssignment(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_New")), args)))))), MkList());
2100 compound->__anon1.compound.context = context;
2101 args = MkList();
2102 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
2103 ListAdd(args, MkExpIdentifier(MkIdentifier(memberName)));
2104 RegisterMembersAndProperties((struct __ecereNameSpace__ecere__com__Class *)member, 1, memberName, compound);
2105 if(isMember)
2106 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_AddMember")), args)));
2107 else
2108 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMember")), args)));
2109 ListAdd(compound->__anon1.compound.statements, stmt);
2110 PopContext(context);
2111 ListAdd(statement->__anon1.compound.statements, compound);
2112 memberCount--;
2113 lastOffset = member->offset + member->memberOffset;
2114 }
2115 }
2116 else
2117 privateMembers = 1;
2118 }
2119 if(!isMember)
2120 {
2121 struct __ecereNameSpace__ecere__com__ClassProperty * classProperty;
2122
2123 for(prop = regClass->membersAndProperties.first; prop; prop = prop->next)
2124 {
2125 if(prop->isProperty && prop->isWatchable)
2126 {
2127 struct __ecereNameSpace__ecere__sys__OldList * args;
2128 char name[1024], nameM[1024];
2129
2130 strcpy(name, "__ecereProp_");
2131 FullClassNameCat(name, regClass->fullName, 1);
2132 strcat(name, "_");
2133 FullClassNameCat(name, prop->name, 0);
2134 strcpy(nameM, "__ecerePropM_");
2135 FullClassNameCat(nameM, regClass->fullName, 1);
2136 strcat(nameM, "_");
2137 FullClassNameCat(nameM, prop->name, 0);
2138 args = MkListOne(MkExpCondition(MkExpIdentifier(MkIdentifier(nameM)), MkListOne(MkExpIdentifier(MkIdentifier(nameM))), MkExpIdentifier(MkIdentifier(name))));
2139 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_Watchable")), args)));
2140 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2141 }
2142 }
2143 for(classProperty = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&regClass->classProperties); classProperty; classProperty = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)classProperty)))
2144 {
2145 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2146 char name[1024];
2147 char * string = QMkString(classProperty->name);
2148
2149 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
2150 ListAdd(args, MkExpString(string));
2151 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2152 {
2153 char * string = QMkString(classProperty->dataTypeString);
2154
2155 ListAdd(args, MkExpString(string));
2156 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2157 }
2158 if(classProperty->Set)
2159 {
2160 strcpy(name, "__ecereClassProp_");
2161 FullClassNameCat(name, regClass->fullName, 1);
2162 strcat(name, "_Set_");
2163 strcat(name, classProperty->name);
2164 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
2165 }
2166 else
2167 ListAdd(args, MkExpConstant("0"));
2168 if(classProperty->Get)
2169 {
2170 strcpy(name, "__ecereClassProp_");
2171 FullClassNameCat(name, regClass->fullName, 1);
2172 strcat(name, "_Get_");
2173 strcat(name, classProperty->name);
2174 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
2175 }
2176 else
2177 ListAdd(args, MkExpConstant("0"));
2178 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddClassProperty")), args)));
2179 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2180 }
2181 }
2182 }
2183
2184 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
2185
2186 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
2187
2188 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
2189
2190 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List_TPL_ClassPropertyValue_;
2191
2192 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType;
2193
2194 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List;
2195
2196 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
2197
2198 struct __ecereNameSpace__ecere__com__Module
2199 {
2200 struct __ecereNameSpace__ecere__com__Instance * application;
2201 struct __ecereNameSpace__ecere__sys__OldList classes;
2202 struct __ecereNameSpace__ecere__sys__OldList defines;
2203 struct __ecereNameSpace__ecere__sys__OldList functions;
2204 struct __ecereNameSpace__ecere__sys__OldList modules;
2205 struct __ecereNameSpace__ecere__com__Instance * prev;
2206 struct __ecereNameSpace__ecere__com__Instance * next;
2207 const char *  name;
2208 void *  library;
2209 void *  Unload;
2210 int importType;
2211 int origImportType;
2212 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
2213 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
2214 } ecere_gcc_struct;
2215
2216 void __ecereDestructor_ClassPropertyValue(struct __ecereNameSpace__ecere__com__Instance * this)
2217 {
2218 __attribute__((unused)) struct ClassPropertyValue * __ecerePointer_ClassPropertyValue = (struct ClassPropertyValue *)(this ? (((char *)this) + __ecereClass_ClassPropertyValue->offset) : 0);
2219
2220 {
2221 FreeIdentifier(__ecerePointer_ClassPropertyValue->id);
2222 }
2223 }
2224
2225 void CreateRegisterModuleBody()
2226 {
2227 if(!registerModuleBody && inCompiler)
2228 {
2229 char registerName[1024], moduleName[274];
2230 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
2231 struct Declarator * declarator;
2232 struct TypeName * moduleParam;
2233
2234 registerModuleBody = MkCompoundStmt(MkList(), MkList());
2235 registerModuleBody->__anon1.compound.context = __extension__ ({
2236 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2237
2238 __ecereInstance1->parent = globalContext, __ecereInstance1;
2239 });
2240 ListAdd(registerModuleBody->__anon1.compound.declarations, MkDeclaration((specifiers = MkListOne(MkSpecifierName("ecere::com::Class"))), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("class")), (((void *)0))))));
2241 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*specifiers), MkSpecifierExtended(MkExtDeclAttrib(MkAttrib(ATTRIB, MkListOne(MkAttribute(__ecereNameSpace__ecere__sys__CopyString("unused"), (((void *)0))))))));
2242 specifiers = MkList();
2243 ListAdd(specifiers, MkSpecifier(VOID));
2244 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
2245 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
2246 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
2247 FixModuleName(moduleName);
2248 sprintf(registerName, "__ecereRegisterModule_%s", moduleName);
2249 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
2250 {
2251 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0);
2252
2253 ProcessFunctionBody(function, registerModuleBody);
2254 function->declMode = 0;
2255 if(!ast)
2256 ast = MkList();
2257 ListAdd(ast, (registerModuleExternal = MkExternalFunction(function)));
2258 DeclareStruct(registerModuleExternal, "ecere::com::Instance", 0, 1);
2259 DeclareStruct(registerModuleExternal, "ecere::com::Module", 0, 1);
2260 }
2261 }
2262 if(!unregisterModuleBody && inCompiler)
2263 {
2264 char registerName[1024], moduleName[274];
2265 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
2266 struct Declarator * declarator;
2267 struct TypeName * moduleParam;
2268
2269 unregisterModuleBody = MkCompoundStmt(MkList(), MkList());
2270 unregisterModuleBody->__anon1.compound.context = __extension__ ({
2271 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2272
2273 __ecereInstance1->parent = globalContext, __ecereInstance1;
2274 });
2275 specifiers = MkList();
2276 ListAdd(specifiers, MkSpecifier(VOID));
2277 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
2278 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
2279 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
2280 FixModuleName(moduleName);
2281 sprintf(registerName, "__ecereUnregisterModule_%s", moduleName);
2282 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
2283 {
2284 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0);
2285
2286 ProcessFunctionBody(function, unregisterModuleBody);
2287 function->declMode = 0;
2288 if(!ast)
2289 ast = MkList();
2290 ListAdd(ast, (unregisterModuleExternal = MkExternalFunction(function)));
2291 DeclareStruct(unregisterModuleExternal, "ecere::com::Instance", 0, 1);
2292 DeclareStruct(unregisterModuleExternal, "ecere::com::Module", 0, 1);
2293 }
2294 }
2295 }
2296
2297 void __ecereCreateModuleInstances_pass1()
2298 {
2299 classPropValues = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__List_TPL_ClassPropertyValue_);
2300 __ecereNameSpace__ecere__com__eInstance_IncRef(classPropValues);
2301 }
2302
2303 void __ecereUnregisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
2304 {
2305
2306 }
2307
2308 static void ProcessClass(int classType, struct __ecereNameSpace__ecere__sys__OldList * definitions, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * baseSpecs, struct __ecereNameSpace__ecere__sys__OldList * enumValues, struct __ecereNameSpace__ecere__sys__OldList * defs, struct External * external, int declMode)
2309 {
2310 struct ClassDef * def;
2311 struct __ecereNameSpace__ecere__com__Class * regClass = symbol->__anon1.registered;
2312
2313 if(regClass)
2314 {
2315 classType = regClass->type;
2316 if(classType == 4 && enumValues && (inCompiler || !buildingECERECOMModule))
2317 {
2318 struct Enumerator * e;
2319
2320 for(e = enumValues->first; e; e = e->next)
2321 {
2322 if(e->exp)
2323 {
2324 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->kind = 4, destType->refCount = 1, destType);
2325
2326 e->exp->destType = destType;
2327 parsingType = 1;
2328 ProcessExpressionType(e->exp);
2329 parsingType = 0;
2330 if(!e->exp->expType)
2331 {
2332 destType->kind = 8;
2333 destType->__anon1._class = symbol;
2334 ProcessExpressionType(e->exp);
2335 }
2336 if(e->exp->type == 0 && e->exp->expType && e->exp->__anon1.__anon1.identifier && e->exp->__anon1.__anon1.identifier->string && e->exp->expType->kind == 15)
2337 {
2338 struct __ecereNameSpace__ecere__sys__NamedLink64 * l;
2339 char * string = e->exp->__anon1.__anon1.identifier->string;
2340
2341 for(l = e->exp->expType->__anon1.__anon1.members.first; l; l = l->next)
2342 {
2343 if(!strcmp(l->name, string))
2344 {
2345 if(l->data)
2346 {
2347 FreeExpContents(e->exp);
2348 e->exp->type = 2;
2349 e->exp->__anon1.__anon1.constant = PrintInt64(l->data);
2350 FreeType(e->exp->expType);
2351 e->exp->expType = ProcessTypeString("int64", 0);
2352 }
2353 break;
2354 }
2355 }
2356 }
2357 else
2358 ComputeExpression(e->exp);
2359 if(e->exp->isConstant && e->exp->type == 2)
2360 {
2361 struct Operand op = GetOperand(e->exp);
2362 long long value;
2363
2364 switch(op.kind)
2365 {
2366 case 1:
2367 value = op.type->isSigned ? (long long)op.__anon1.c : (long long)op.__anon1.uc;
2368 break;
2369 case 2:
2370 value = op.type->isSigned ? (long long)op.__anon1.s : (long long)op.__anon1.us;
2371 break;
2372 case 4:
2373 value = op.type->isSigned ? op.__anon1.i64 : (long long)op.__anon1.ui64;
2374 break;
2375 case 3:
2376 default:
2377 value = op.type->isSigned ? (long long)op.__anon1.i : (int)op.__anon1.ui;
2378 }
2379 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
2380 }
2381 else
2382 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2383 }
2384 else
2385 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2386 }
2387 {
2388 struct __ecereNameSpace__ecere__com__EnumClassData * baseData = regClass->data;
2389 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
2390
2391 for(deriv = regClass->derivatives.first; deriv; deriv = deriv->next)
2392 {
2393 struct __ecereNameSpace__ecere__com__Class * c = deriv->data;
2394
2395 if(c && c->type == 4)
2396 {
2397 struct __ecereNameSpace__ecere__com__EnumClassData * data = c->data;
2398
2399 data->largest = baseData->largest;
2400 }
2401 }
2402 }
2403 }
2404 if(definitions != (((void *)0)))
2405 {
2406 if(inCompiler)
2407 {
2408 for(def = definitions->first; def; def = def->next)
2409 {
2410 if(def->type == 4 && def->__anon1.propertyWatch)
2411 {
2412 struct PropertyWatch * propWatch = def->__anon1.propertyWatch;
2413 struct ClassFunction * func;
2414 char watcherName[1024];
2415 struct Identifier * propID;
2416 struct Statement * stmt = MkExpressionStmt(MkList());
2417 struct Declarator * decl;
2418 struct __ecereNameSpace__ecere__sys__OldList * specs;
2419
2420 sprintf(watcherName, "__ecerePropertySelfWatcher_%d", propWatcherID++);
2421 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2422 {
2423 strcat(watcherName, "_");
2424 strcat(watcherName, propID->string);
2425 }
2426 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifier(VOID)), (((void *)0)))));
2427 specs = MkList();
2428 ListAdd(specs, MkSpecifier(STATIC));
2429 ListAdd(specs, MkSpecifier(VOID));
2430 func = MkClassFunction(specs, (((void *)0)), decl, (((void *)0)));
2431 ProcessClassFunctionBody(func, propWatch->compound);
2432 decl->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2433 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
2434 func->dontMangle = 1;
2435 propWatch->compound = (((void *)0));
2436 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(func));
2437 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2438 {
2439 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, propID->string, privateModule);
2440
2441 if(prop)
2442 {
2443 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2444
2445 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2446 {
2447 char * s = QMkString(propID->string);
2448
2449 ListAdd(args, MkExpString(s));
2450 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2451 }
2452 ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
2453 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_SelfWatch")), args));
2454 }
2455 else
2456 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, regClass->fullName);
2457 }
2458 FreePropertyWatch(def->__anon1.propertyWatch);
2459 def->__anon1.propertyWatch = (struct PropertyWatch *)stmt;
2460 }
2461 }
2462 }
2463 for(def = definitions->first; def; def = def->next)
2464 {
2465 if(def->type == 0)
2466 {
2467 ProcessClassFunction(regClass, def->__anon1.function, defs, external->prev, declMode == 3);
2468 }
2469 }
2470 }
2471 if(inCompiler && symbol->mustRegister && regClass)
2472 {
2473 struct Statement * stmt;
2474 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2475 struct __ecereNameSpace__ecere__com__Method * method;
2476 struct Expression * exp;
2477 const char * registerFunction = (((void *)0));
2478 int inheritanceAccess = 1;
2479
2480 CreateRegisterModuleBody();
2481 curExternal = registerModuleExternal;
2482 switch(regClass->type)
2483 {
2484 case 1:
2485 ListAdd(args, MkExpIdentifier(MkIdentifier("structClass")));
2486 break;
2487 case 2:
2488 ListAdd(args, MkExpIdentifier(MkIdentifier("bitClass")));
2489 break;
2490 case 4:
2491 ListAdd(args, MkExpIdentifier(MkIdentifier("enumClass")));
2492 break;
2493 case 5:
2494 ListAdd(args, MkExpIdentifier(MkIdentifier("noHeadClass")));
2495 break;
2496 case 3:
2497 ListAdd(args, MkExpIdentifier(MkIdentifier("unitClass")));
2498 break;
2499 case 0:
2500 ListAdd(args, MkExpIdentifier(MkIdentifier("normalClass")));
2501 break;
2502 }
2503 {
2504 char nameSpace[1024] = "";
2505 char className[1024] = "";
2506 char * string;
2507
2508 GetNameSpaceString(regClass->nameSpace, nameSpace);
2509 if(declMode == 3)
2510 {
2511 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, className);
2512 __ecereNameSpace__ecere__sys__ChangeCh(className, '.', '_');
2513 strcat(className, "}");
2514 }
2515 strcat(className, nameSpace);
2516 strcat(className, regClass->name);
2517 string = QMkString(className);
2518 ListAdd(args, MkExpString(string));
2519 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2520 }
2521 if(baseSpecs != (((void *)0)))
2522 {
2523 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
2524
2525 if(baseType->kind != 9 && baseType->kind != 10)
2526 {
2527 char baseName[1024] = "";
2528 char * string;
2529
2530 if(baseType->kind == 8 && baseType->__anon1._class && baseType->__anon1._class->isStatic)
2531 {
2532 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, baseName);
2533 __ecereNameSpace__ecere__sys__ChangeCh(baseName, '.', '_');
2534 strcat(baseName, "}");
2535 strcat(baseName, baseType->__anon1._class->string);
2536 }
2537 else
2538 PrintType(baseType, baseName, 0, 1);
2539 string = QMkString(baseName);
2540 ListAdd(args, MkExpString(string));
2541 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2542 }
2543 else
2544 ListAdd(args, MkExpConstant("0"));
2545 FreeType(baseType);
2546 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->__anon1.specifier == PRIVATE)
2547 inheritanceAccess = 2;
2548 }
2549 else
2550 ListAdd(args, MkExpConstant("0"));
2551 if(regClass->type == 1 || regClass->type == 0 || regClass->type == 5)
2552 {
2553 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2554
2555 {
2556 struct __ecereNameSpace__ecere__com__Class * base;
2557
2558 for(base = regClass->base; base && base->type != 1000; base = base->next)
2559 {
2560 for(member = base->membersAndProperties.first; member; member = member->next)
2561 if(!member->isProperty)
2562 break;
2563 if(member)
2564 break;
2565 }
2566 }
2567 if(regClass->type == 1 && symbol->declaredStruct && member)
2568 {
2569 char baseStructName[1024];
2570
2571 baseStructName[0] = 0;
2572 strcpy(baseStructName, (regClass->base->templateClass ? regClass->base->templateClass : regClass->base)->fullName);
2573 ListAdd(args, MkExpOp(MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(symbol->structName), (((void *)0)))), (((void *)0)))), '-', MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(baseStructName), (((void *)0)))), (((void *)0))))));
2574 }
2575 else
2576 ListAdd(args, symbol->declaredStruct ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(symbol->structName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2577 }
2578 else
2579 {
2580 ListAdd(args, MkExpConstant("0"));
2581 }
2582 {
2583 char classDataStructName[1024];
2584
2585 strcpy(classDataStructName, "__ecereClassData_");
2586 FullClassNameCat(classDataStructName, symbol->string, 0);
2587 ListAdd(args, symbol->classData ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(classDataStructName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2588 }
2589 if(regClass->type == 0 || regClass->type == 5)
2590 {
2591 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), symbol->needConstructor ? MkExpIdentifier(MkIdentifier(symbol->constructorName)) : MkExpConstant("0")));
2592 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), symbol->needDestructor ? MkExpIdentifier(MkIdentifier(symbol->destructorName)) : MkExpConstant("0")));
2593 }
2594 else
2595 {
2596 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")));
2597 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")));
2598 }
2599 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2600 switch(declMode)
2601 {
2602 case 3:
2603 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2604 break;
2605 case 2:
2606 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2607 break;
2608 case 1:
2609 default:
2610 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2611 break;
2612 }
2613 switch(inheritanceAccess)
2614 {
2615 case 2:
2616 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2617 break;
2618 case 1:
2619 default:
2620 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2621 break;
2622 }
2623 registerFunction = "eSystem_RegisterClass";
2624 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("class")), '=', MkExpCall((exp = MkExpIdentifier(MkIdentifier(registerFunction))), args))));
2625 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2626 stmt = MkIfStmt(MkListOne(MkExpOp(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("module")), MkIdentifier("application")), EQ_OP, MkExpMember(MkExpIdentifier(MkIdentifier("__thisModule")), MkIdentifier("application"))), AND_OP, MkExpIdentifier(MkIdentifier("class")))), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(symbol->className)), '=', MkExpIdentifier(MkIdentifier("class"))))), (((void *)0)));
2627 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2628 if(external && external->type == 2 && external->__anon1._class->deleteWatchable)
2629 {
2630 args = MkListOne(MkExpIdentifier(MkIdentifier("class")));
2631 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DestructionWatchable")), args)));
2632 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2633 }
2634 if(regClass->base)
2635 {
2636 struct __ecereNameSpace__ecere__com__Class * base = regClass->base;
2637 int c;
2638
2639 for(c = 0; c < base->vTblSize; c++)
2640 {
2641 struct Symbol * method = (struct Symbol *)regClass->_vTbl[c];
2642
2643 if((void *)method != DummyMethod && base->_vTbl[c] != (void *)method && method->__anon2.__anon3.methodExternal)
2644 {
2645 struct External * external = method->__anon2.__anon3.methodExternal;
2646 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2647 struct Identifier * id = external->__anon1.function ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2648
2649 {
2650 struct External * e = method->__anon2.__anon3.methodExternal ? method->__anon2.__anon3.methodExternal : method->__anon2.__anon3.methodCodeExternal;
2651
2652 __ecereMethod_External_CreateUniqueEdge(registerModuleExternal, e, e->type == 0);
2653 }
2654 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2655 {
2656 char * string = QMkString(method->__anon1.method->name);
2657
2658 ListAdd(args, MkExpString(string));
2659 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2660 }
2661 ListAdd(args, MkExpConstant("0"));
2662 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2663 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2664 exp->expType = __extension__ ({
2665 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2666
2667 __ecereInstance1->refCount = 1, __ecereInstance1;
2668 });
2669 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2670 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2671 }
2672 }
2673 }
2674 {
2675 int c;
2676
2677 for(c = regClass->base ? regClass->base->vTblSize : 0; c < regClass->vTblSize; c++)
2678 {
2679 for(method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&regClass->methods); method; method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)method)))
2680 {
2681 if(method->type == 1 && method->_class == regClass && method->vid == c)
2682 {
2683 char name[1024];
2684 struct Expression * exp;
2685 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal : (((void *)0));
2686 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2687 struct Identifier * id = (external && external->__anon1.function) ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2688
2689 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2690 {
2691 char * string = QMkString(method->name);
2692
2693 ListAdd(args, MkExpString(string));
2694 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2695 }
2696 {
2697 char * string = QMkString(method->dataTypeString);
2698
2699 ListAdd(args, MkExpString(string));
2700 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2701 }
2702 if(id && external->__anon1.function->body)
2703 {
2704 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2705 exp->expType = __extension__ ({
2706 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2707
2708 __ecereInstance1->refCount = 1, __ecereInstance1;
2709 });
2710 }
2711 else
2712 {
2713 ListAdd(args, (exp = MkExpConstant("0")));
2714 }
2715 switch(method->memberAccess)
2716 {
2717 case 3:
2718 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2719 break;
2720 case 2:
2721 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2722 break;
2723 case 1:
2724 default:
2725 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2726 break;
2727 }
2728 strcpy(name, "__ecereVMethodID_");
2729 FullClassNameCat(name, method->_class->fullName, 0);
2730 strcat(name, "_");
2731 strcat(name, method->name);
2732 exp = MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddVirtualMethod")), args);
2733 stmt = MkExpressionStmt(MkListOne(exp));
2734 if(external)
2735 __ecereMethod_External_CreateUniqueEdge(registerModuleExternal, external, external->type == 0);
2736 DeclareMethod(curExternal, method, name);
2737 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2738 }
2739 }
2740 }
2741 }
2742 for(method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&regClass->methods); method; method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)method)))
2743 {
2744 if(method->type == 1 && method->_class == regClass)
2745 ;
2746 else if(method->memberAccess == 1 || !method->dataTypeString)
2747 {
2748 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal : (((void *)0));
2749 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2750 struct Identifier * id = (external && external->__anon1.function) ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2751
2752 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2753 {
2754 char * string = QMkString(method->name);
2755
2756 ListAdd(args, MkExpString(string));
2757 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2758 }
2759 {
2760 char * string = QMkString(method->dataTypeString);
2761
2762 ListAdd(args, MkExpString(string));
2763 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2764 }
2765 if(id && external->__anon1.function->body)
2766 {
2767 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2768 exp->expType = __extension__ ({
2769 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2770
2771 __ecereInstance1->refCount = 1, __ecereInstance1;
2772 });
2773 }
2774 else
2775 {
2776 ListAdd(args, (exp = MkExpConstant("0")));
2777 }
2778 switch(method->memberAccess)
2779 {
2780 case 3:
2781 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2782 break;
2783 case 2:
2784 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2785 break;
2786 case 1:
2787 default:
2788 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2789 break;
2790 }
2791 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2792 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2793 if(external)
2794 __ecereMethod_External_CreateUniqueEdge(registerModuleExternal, external, external->type == 0);
2795 }
2796 }
2797 RegisterMembersAndProperties(regClass, 0, "class", registerModuleBody);
2798 if(classType == 4)
2799 {
2800 struct __ecereNameSpace__ecere__sys__NamedLink64 * value;
2801 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2802 struct __ecereNameSpace__ecere__com__EnumClassData * e = (regClass ? ((void *)(((char *)regClass->data) + enumClass->offsetClass)) : (((void *)0)));
2803
2804 for(value = e->values.first; value; value = value->next)
2805 {
2806 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2807
2808 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2809 {
2810 char * string = QMkString(value->name);
2811
2812 ListAdd(args, MkExpString(string));
2813 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2814 }
2815 {
2816 char * temp;
2817
2818 if(regClass->dataTypeString && !strcmp(regClass->dataTypeString, "uint64"))
2819 temp = PrintUInt64(value->data);
2820 else
2821 temp = PrintInt64(value->data);
2822 ListAdd(args, MkExpConstant(temp));
2823 (__ecereNameSpace__ecere__com__eSystem_Delete(temp), temp = 0);
2824 }
2825 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eEnum_AddFixedValue")), args)));
2826 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2827 }
2828 }
2829 if(symbol->templateParams)
2830 {
2831 struct TemplateParameter * param;
2832
2833 for(param = (*symbol->templateParams).first; param; param = param->next)
2834 {
2835 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2836
2837 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2838 {
2839 char * string = QMkString(param->identifier->string);
2840
2841 ListAdd(args, MkExpString(string));
2842 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2843 }
2844 ListAdd(args, MkExpIdentifier(MkIdentifier((param->type == 0) ? "type" : ((param->type == 1) ? "identifier" : "expression"))));
2845 switch(param->type)
2846 {
2847 case 0:
2848 case 2:
2849 {
2850 char * typeString = param->__anon1.dataType ? StringFromSpecDecl(param->__anon1.dataType->specifiers, param->__anon1.dataType->decl) : (((void *)0));
2851 char * string = QMkString(typeString);
2852
2853 ListAdd(args, MkExpString(string));
2854 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2855 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2856 break;
2857 }
2858 case 1:
2859 {
2860 char memberTypeString[132] = "TemplateMemberType::";
2861 unsigned int needClass = 1;
2862
2863 (__extension__ ({
2864 const char *  (*  __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Class * , const void * , char *  tempString, void *  fieldData, unsigned int *  needClass);
2865
2866 __internal_VirtualMethod = ((const char *  (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, char *  tempString, void *  fieldData, unsigned int *  needClass))__ecereClass___ecereNameSpace__ecere__com__TemplateMemberType->_vTbl[__ecereVMethodID_class_OnGetString]);
2867 __internal_VirtualMethod ? __internal_VirtualMethod(__ecereClass___ecereNameSpace__ecere__com__TemplateMemberType, (void *)&param->__anon1.memberType, memberTypeString + strlen(memberTypeString), (((void *)0)), &needClass) : (const char * )1;
2868 }));
2869 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(memberTypeString))));
2870 break;
2871 }
2872 }
2873 if(param->defaultArgument)
2874 {
2875 struct __ecereNameSpace__ecere__sys__OldList * members = MkList();
2876
2877 switch(param->type)
2878 {
2879 case 0:
2880 {
2881 char * typeString = param->defaultArgument->__anon1.templateDatatype ? StringFromSpecDecl(param->defaultArgument->__anon1.templateDatatype->specifiers, param->defaultArgument->__anon1.templateDatatype->decl) : (((void *)0));
2882 char * string = QMkString(typeString);
2883
2884 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2885 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2886 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2887 break;
2888 }
2889 case 1:
2890 {
2891 char memberString[1024];
2892 char * string;
2893
2894 memberString[0] = '\0';
2895 if(param->defaultArgument->__anon1.identifier->_class)
2896 {
2897 if(param->defaultArgument->__anon1.identifier->_class->type == 8)
2898 strcpy(memberString, param->defaultArgument->__anon1.identifier->_class->__anon1.templateParameter->identifier->string);
2899 else if(param->defaultArgument->__anon1.identifier->_class->__anon1.__anon1.name)
2900 strcpy(memberString, param->defaultArgument->__anon1.identifier->_class->__anon1.__anon1.name);
2901 }
2902 if(memberString[0])
2903 strcat(memberString, "::");
2904 strcat(memberString, param->defaultArgument->__anon1.identifier->string);
2905 string = QMkString(memberString);
2906 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2907 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2908 break;
2909 }
2910 case 2:
2911 {
2912 struct Operand op =
2913 {
2914 0, 0, 0,
2915 .__anon1 = {
2916 .c = 0
2917 },
2918 {
2919 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
2920 }
2921 };
2922 struct __ecereNameSpace__ecere__sys__OldList * ids = MkList();
2923 char * ui64String;
2924 char * string = (((void *)0));
2925
2926 op = GetOperand(param->defaultArgument->__anon1.expression);
2927 ui64String = PrintUInt64(op.__anon1.ui64);
2928 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("expression"));
2929 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("ui64"));
2930 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
2931 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2932 (__ecereNameSpace__ecere__com__eSystem_Delete(ui64String), ui64String = 0);
2933 break;
2934 }
2935 }
2936 ListAdd(args, MkExpInstance(MkInstantiation(MkSpecifierName("ClassTemplateArgument"), (((void *)0)), MkListOne(MkMembersInitList(members)))));
2937 }
2938 else
2939 ListAdd(args, MkExpIdentifier(MkIdentifier("null")));
2940 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddTemplateParameter")), args)));
2941 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2942 }
2943 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DoneAddingTemplateParameters")), MkListOne(MkExpIdentifier(MkIdentifier("class"))))));
2944 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2945 }
2946 if(definitions != (((void *)0)))
2947 {
2948 for(def = definitions->first; def; def = def->next)
2949 {
2950 if(def->type == 4 && def->__anon1.propertyWatch)
2951 {
2952 ListAdd(registerModuleBody->__anon1.compound.statements, (struct Statement *)def->__anon1.propertyWatch);
2953 def->__anon1.propertyWatch = (((void *)0));
2954 }
2955 else if(def->type == 5)
2956 {
2957 {
2958 char * s = QMkString(def->__anon1.designer);
2959
2960 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("designerClass")), '=', MkExpString(s)))), (((void *)0)));
2961 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2962 }
2963 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2964 }
2965 else if(def->type == 6)
2966 {
2967 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("noExpansion")), '=', MkExpConstant("1")))), (((void *)0)));
2968 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2969 }
2970 else if(def->type == 7)
2971 {
2972 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("fixed")), '=', MkExpConstant("1")))), (((void *)0)));
2973 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2974 if(regClass)
2975 regClass->fixed = 1;
2976 }
2977 else if(def->type == 8)
2978 {
2979 char * s = QMkString(def->__anon1.defaultProperty->string);
2980
2981 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("defaultProperty")), '=', MkExpString(s)))), (((void *)0)));
2982 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2983 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2984 }
2985 else if(def->type == 11)
2986 {
2987 (__extension__ ({
2988 struct __ecereNameSpace__ecere__com__IteratorPointer * (*  __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value);
2989
2990 __internal_VirtualMethod = ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value))__extension__ ({
2991 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = classPropValues;
2992
2993 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
2994 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Add]);
2995 __internal_VirtualMethod ? __internal_VirtualMethod(classPropValues, (uint64)(uintptr_t)(__extension__ ({
2996 struct __ecereNameSpace__ecere__com__Instance * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassPropertyValue);
2997
2998 ((struct ClassPropertyValue *)(((char *)__ecereInstance1 + __ecereClass_ClassPropertyValue->offset)))->regClass = regClass, ((struct ClassPropertyValue *)(((char *)__ecereInstance1 + __ecereClass_ClassPropertyValue->offset)))->staticClass = (declMode == 3), ((struct ClassPropertyValue *)(((char *)__ecereInstance1 + __ecereClass_ClassPropertyValue->offset)))->id = def->__anon1.__anon1.id, ((struct ClassPropertyValue *)(((char *)__ecereInstance1 + __ecereClass_ClassPropertyValue->offset)))->exp = def->__anon1.__anon1.initializer->__anon1.exp, __ecereInstance1;
2999 }))) : (struct __ecereNameSpace__ecere__com__IteratorPointer *)1;
3000 }));
3001 def->__anon1.__anon1.id = (((void *)0));
3002 def->__anon1.__anon1.initializer->__anon1.exp = (((void *)0));
3003 }
3004 }
3005 }
3006 }
3007 }
3008 }
3009
3010 void ProcessClassDefinitions()
3011 {
3012 struct External * external, * next;
3013
3014 CreateRegisterModuleBody();
3015 if(ast)
3016 {
3017 for(external = (*ast).first; external; external = next)
3018 {
3019 next = external->next;
3020 curExternal = external;
3021 if(external->type == 2)
3022 {
3023 struct ClassDefinition * _class = external->__anon1._class;
3024
3025 if(_class->definitions)
3026 {
3027 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), ast, external, _class->declMode);
3028 }
3029 if(inCompiler)
3030 {
3031 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
3032 FreeExternal(external);
3033 }
3034 }
3035 else if(external->type == 0)
3036 {
3037 unsigned int setStaticMethod = 0;
3038
3039 if(external->symbol && !external->symbol->type->__anon1.__anon2.thisClass && !external->symbol->type->__anon1.__anon2.staticMethod)
3040 {
3041 external->symbol->type->__anon1.__anon2.staticMethod = 1;
3042 setStaticMethod = 1;
3043 }
3044 if(inCompiler)
3045 {
3046 struct FunctionDefinition * function = external->__anon1.function;
3047 struct Statement * stmt;
3048 struct __ecereNameSpace__ecere__sys__OldList * args;
3049
3050 if(!strcmp(function->declarator->symbol->string, "__on_register_module"))
3051 {
3052 ListAdd(registerModuleBody->__anon1.compound.statements, function->body);
3053 function->body->__anon1.compound.context->parent = registerModuleBody->__anon1.compound.context;
3054 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
3055 function->body = (((void *)0));
3056 FreeExternal(external);
3057 continue;
3058 }
3059 if(function->declMode != 2 && function->declMode != 1)
3060 continue;
3061 args = MkList();
3062 CreateRegisterModuleBody();
3063 {
3064 char * string = QMkString(function->declarator->symbol->string);
3065
3066 ListAdd(args, MkExpString(string));
3067 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3068 }
3069 {
3070 char * string;
3071 char type[1024] = "";
3072
3073 if(setStaticMethod)
3074 function->declarator->symbol->type->__anon1.__anon2.staticMethod = 0;
3075 PrintType(function->declarator->symbol->type, type, 1, 1);
3076 if(setStaticMethod)
3077 function->declarator->symbol->type->__anon1.__anon2.staticMethod = 1;
3078 string = QMkString(type);
3079 ListAdd(args, MkExpString(string));
3080 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3081 }
3082 {
3083 ListAdd(args, MkExpIdentifier(MkIdentifier(function->declarator->symbol->string)));
3084 }
3085 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
3086 switch(function->declMode)
3087 {
3088 case 3:
3089 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
3090 break;
3091 case 2:
3092 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
3093 break;
3094 case 1:
3095 default:
3096 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
3097 break;
3098 }
3099 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterFunction"))), args)));
3100 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
3101 }
3102 }
3103 else if(external->type == 1)
3104 {
3105 struct Declaration * declaration = external->__anon1.declaration;
3106
3107 if(external->symbol)
3108 {
3109 if(external->symbol->type && external->symbol->type->kind == 11 && !external->symbol->type->__anon1.__anon2.thisClass)
3110 external->symbol->type->__anon1.__anon2.staticMethod = 1;
3111 }
3112 if(external->symbol && declaration && declaration->type == 1)
3113 {
3114 if(declaration->__anon1.__anon1.specifiers)
3115 {
3116 struct Specifier * specifier;
3117 unsigned int removeExternal = 0;
3118
3119 for(specifier = (*declaration->__anon1.__anon1.specifiers).first; specifier; specifier = specifier->next)
3120 {
3121 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->__anon1.__anon2.id && specifier->__anon1.__anon2.id->string && (declaration->declMode || specifier->__anon1.__anon2.baseSpecs || (specifier->type == 2 && specifier->__anon1.__anon2.definitions)))
3122 {
3123 struct Symbol * symbol = FindClass(specifier->__anon1.__anon2.id->string);
3124
3125 if(symbol)
3126 {
3127 int classType;
3128
3129 if(specifier->type == 2)
3130 classType = 4;
3131 else
3132 classType = 1;
3133 removeExternal = 1;
3134 symbol->ctx = specifier->__anon1.__anon2.ctx;
3135 specifier->__anon1.__anon2.ctx = (((void *)0));
3136 ProcessClass(classType, specifier->__anon1.__anon2.definitions, symbol, specifier->__anon1.__anon2.baseSpecs, specifier->__anon1.__anon2.list, ast, external, declaration->declMode);
3137 }
3138 }
3139 }
3140 if(inCompiler && removeExternal)
3141 {
3142 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
3143 FreeExternal(external);
3144 }
3145 }
3146 }
3147 else if(declaration && declaration->type == 3)
3148 {
3149 if(inCompiler && declaration->declMode != 3)
3150 {
3151 struct Statement * stmt;
3152 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3153
3154 CreateRegisterModuleBody();
3155 {
3156 char * string = QMkString(declaration->__anon1.__anon2.id->string);
3157
3158 ListAdd(args, MkExpString(string));
3159 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3160 }
3161 {
3162 char * string;
3163 char type[1024] = "";
3164
3165 PrintExpression(declaration->__anon1.__anon2.exp, type);
3166 string = QMkString(type);
3167 ListAdd(args, MkExpString(string));
3168 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3169 }
3170 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
3171 switch(declaration->declMode)
3172 {
3173 case 3:
3174 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
3175 break;
3176 case 2:
3177 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
3178 break;
3179 case 1:
3180 default:
3181 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
3182 break;
3183 }
3184 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterDefine"))), args)));
3185 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
3186 }
3187 }
3188 }
3189 }
3190 {
3191 struct __ecereNameSpace__ecere__com__Iterator v =
3192 {
3193 (classPropValues), 0
3194 };
3195
3196 while(__ecereMethod___ecereNameSpace__ecere__com__Iterator_Next(&v))
3197 {
3198 struct __ecereNameSpace__ecere__sys__OldList * findClassArgs = MkList();
3199 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3200 struct Statement * compoundStmt;
3201 char * s;
3202 struct Expression * e;
3203
3204 if(__extension__ ({
3205 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3206
3207 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3208 })->exp)
3209 yylloc = __extension__ ({
3210 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3211
3212 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3213 })->exp->loc;
3214 ListAdd(findClassArgs, MkExpIdentifier(MkIdentifier("module")));
3215 {
3216 char nameSpace[1024] = "";
3217 char className[1024] = "";
3218 struct __ecereNameSpace__ecere__com__Class * regClass = __extension__ ({
3219 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3220
3221 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3222 })->regClass;
3223
3224 GetNameSpaceString(regClass->nameSpace, nameSpace);
3225 if(__extension__ ({
3226 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3227
3228 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3229 })->staticClass)
3230 {
3231 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, className);
3232 __ecereNameSpace__ecere__sys__ChangeCh(className, '.', '_');
3233 strcat(className, "}");
3234 }
3235 strcat(className, nameSpace);
3236 strcat(className, regClass->name);
3237 s = QMkString(className);
3238 }
3239 ListAdd(findClassArgs, MkExpString(s));
3240 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
3241 ListAdd(args, MkExpIdentifier(MkIdentifier("_class")));
3242 s = QMkString(__extension__ ({
3243 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3244
3245 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3246 })->id->string);
3247 ListAdd(args, MkExpString(s));
3248 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
3249 e = __extension__ ({
3250 char * __ecTemp1 = (char *)(((struct __ecereNameSpace__ecere__com__Instance *)(uintptr_t)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3251
3252 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3253 })->exp;
3254 ProcessExpressionType(e);
3255 if(__ecereProp_Type_Get_isPointerType(e->expType))
3256 e = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("intptr")), (((void *)0))), e);
3257 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(INT64)), (((void *)0))), e));
3258 compoundStmt = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifierName("ecere::com::Class")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("_class")), MkInitializerAssignment(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eSystem_FindClass")), findClassArgs)))))), MkListOne(MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eClass_SetProperty")), args)))));
3259 compoundStmt->__anon1.compound.context = __extension__ ({
3260 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
3261
3262 __ecereInstance1->parent = registerModuleBody->__anon1.compound.context, __ecereInstance1;
3263 });
3264 ListAdd(registerModuleBody->__anon1.compound.statements, compoundStmt);
3265 }
3266 }
3267 (__extension__ ({
3268 void (*  __internal_VirtualMethod)(struct __ecereNameSpace__ecere__com__Instance *);
3269
3270 __internal_VirtualMethod = ((void (*)(struct __ecereNameSpace__ecere__com__Instance *))__extension__ ({
3271 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = classPropValues;
3272
3273 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
3274 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Free]);
3275 __internal_VirtualMethod ? __internal_VirtualMethod(classPropValues) : (void)1;
3276 }));
3277 }
3278 }
3279
3280 void __ecereRegisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
3281 {
3282 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
3283
3284 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereCom", "void SetBuildingEcereCom(bool b)", SetBuildingEcereCom, module, 1);
3285 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereCom", "bool GetBuildingEcereCom(void)", GetBuildingEcereCom, module, 1);
3286 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereComModule", "void SetBuildingEcereComModule(bool b)", SetBuildingEcereComModule, module, 1);
3287 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereComModule", "bool GetBuildingEcereComModule(void)", GetBuildingEcereComModule, module, 1);
3288 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessClassFunction", "External ProcessClassFunction(ecere::com::Class owningClass, ClassFunction func, ecere::sys::OldList defs, External after, bool makeStatic)", ProcessClassFunction, module, 2);
3289 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CreateRegisterModuleBody", "void CreateRegisterModuleBody(void)", CreateRegisterModuleBody, module, 2);
3290 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("RegisterMembersAndProperties", "void RegisterMembersAndProperties(ecere::com::Class regClass, bool isMember, const char * className, Statement statement)", RegisterMembersAndProperties, module, 2);
3291 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetNameSpaceString", "void GetNameSpaceString(ecere::com::NameSpace ns, char * string)", GetNameSpaceString, module, 2);
3292 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ClassPropertyValue", 0, sizeof(struct ClassPropertyValue), 0, (void *)0, (void *)__ecereDestructor_ClassPropertyValue, module, 2, 1);
3293 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->application && class)
3294 __ecereClass_ClassPropertyValue = class;
3295 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessClassDefinitions", "void ProcessClassDefinitions(void)", ProcessClassDefinitions, module, 1);
3296 }
3297