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