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