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

   1 /* Code generated from eC source file: pass16.ec */
   2 #if defined(_WIN32)
   3 #define __runtimePlatform 1
   4 #elif defined(__APPLE__)
   5 #define __runtimePlatform 3
   6 #else
   7 #define __runtimePlatform 2
   8 #endif
   9 #if defined(__GNUC__)
  10 typedef long long int64;
  11 typedef unsigned long long uint64;
  12 #ifndef _WIN32
  13 #define __declspec(x)
  14 #endif
  15 #elif defined(__TINYC__)
  16 #include <stdarg.h>
  17 #define __builtin_va_list va_list
  18 #define __builtin_va_start va_start
  19 #define __builtin_va_end va_end
  20 #ifdef _WIN32
  21 #define strcasecmp stricmp
  22 #define strncasecmp strnicmp
  23 #define __declspec(x) __attribute__((x))
  24 #else
  25 #define __declspec(x)
  26 #endif
  27 typedef long long int64;
  28 typedef unsigned long long uint64;
  29 #else
  30 typedef __int64 int64;
  31 typedef unsigned __int64 uint64;
  32 #endif
  33 #ifdef __BIG_ENDIAN__
  34 #define __ENDIAN_PAD(x) (8 - (x))
  35 #else
  36 #define __ENDIAN_PAD(x) 0
  37 #endif
  38 #if defined(_WIN32)
  39 #   if defined(__GNUC__) || defined(__TINYC__)
  40 #      define ecere_stdcall __attribute__((__stdcall__))
  41 #      define ecere_gcc_struct __attribute__((gcc_struct))
  42 #   else
  43 #      define ecere_stdcall __stdcall
  44 #      define ecere_gcc_struct
  45 #   endif
  46 #else
  47 #   define ecere_stdcall
  48 #   define ecere_gcc_struct
  49 #endif
  50 #include <stdint.h>
  51 #include <sys/types.h>
  52 enum yytokentype
  53 {
  54 IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, LONG = 294, SIGNED = 295, UNSIGNED = 296, FLOAT = 297, DOUBLE = 298, CONST = 299, VOLATILE = 300, VOID = 301, VALIST = 302, STRUCT = 303, UNION = 304, ENUM = 305, ELLIPSIS = 306, CASE = 307, DEFAULT = 308, IF = 309, SWITCH = 310, WHILE = 311, DO = 312, FOR = 313, GOTO = 314, CONTINUE = 315, BREAK = 316, RETURN = 317, IFX = 318, ELSE = 319, CLASS = 320, THISCLASS = 321, CLASS_NAME = 322, PROPERTY = 323, SETPROP = 324, GETPROP = 325, NEWOP = 326, RENEW = 327, DELETE = 328, EXT_DECL = 329, EXT_STORAGE = 330, IMPORT = 331, DEFINE = 332, VIRTUAL = 333, ATTRIB = 334, PUBLIC = 335, PRIVATE = 336, TYPED_OBJECT = 337, ANY_OBJECT = 338, _INCREF = 339, EXTENSION = 340, ASM = 341, TYPEOF = 342, WATCH = 343, STOPWATCHING = 344, FIREWATCHERS = 345, WATCHABLE = 346, CLASS_DESIGNER = 347, CLASS_NO_EXPANSION = 348, CLASS_FIXED = 349, ISPROPSET = 350, CLASS_DEFAULT_PROPERTY = 351, PROPERTY_CATEGORY = 352, CLASS_DATA = 353, CLASS_PROPERTY = 354, SUBCLASS = 355, NAMESPACE = 356, NEW0OP = 357, RENEW0 = 358, VAARG = 359, DBTABLE = 360, DBFIELD = 361, DBINDEX = 362, DATABASE_OPEN = 363, ALIGNOF = 364, ATTRIB_DEP = 365, __ATTRIB = 366, BOOL = 367, _BOOL = 368, _COMPLEX = 369, _IMAGINARY = 370, RESTRICT = 371, THREAD = 372, WIDE_STRING_LITERAL = 373
  55 };
  56
  57 extern unsigned int inCompiler;
  58
  59 extern const char *  outputFile;
  60
  61 static int declTempCount;
  62
  63 struct __ecereNameSpace__ecere__sys__OldList
  64 {
  65 void *  first;
  66 void *  last;
  67 int count;
  68 unsigned int offset;
  69 unsigned int circ;
  70 } ecere_gcc_struct;
  71
  72 struct __ecereNameSpace__ecere__sys__BTNode;
  73
  74 struct __ecereNameSpace__ecere__com__DataValue
  75 {
  76 union
  77 {
  78 char c;
  79 unsigned char uc;
  80 short s;
  81 unsigned short us;
  82 int i;
  83 unsigned int ui;
  84 void *  p;
  85 float f;
  86 double d;
  87 long long i64;
  88 uint64 ui64;
  89 } ecere_gcc_struct __anon1;
  90 } ecere_gcc_struct;
  91
  92 struct __ecereNameSpace__ecere__com__SerialBuffer
  93 {
  94 unsigned char *  _buffer;
  95 unsigned int count;
  96 unsigned int _size;
  97 unsigned int pos;
  98 } ecere_gcc_struct;
  99
 100 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
 101
 102 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
 103
 104 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
 105
 106 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
 107
 108 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
 109
 110 struct Pointer;
 111
 112 struct TypeName;
 113
 114 struct Attrib;
 115
 116 struct ExtDecl;
 117
 118 struct Attribute;
 119
 120 struct TemplateParameter;
 121
 122 struct TemplateArgument;
 123
 124 struct TemplateDatatype;
 125
 126 struct DBTableEntry;
 127
 128 struct DBIndexItem;
 129
 130 struct DBTableDef;
 131
 132 struct CodePosition
 133 {
 134 int line;
 135 int charPos;
 136 int pos;
 137 int included;
 138 } ecere_gcc_struct;
 139
 140 extern char *  __ecereNameSpace__ecere__sys__GetLastDirectory(const char *  string, char *  output);
 141
 142 extern unsigned int __ecereNameSpace__ecere__sys__StripExtension(char *  string);
 143
 144 extern void FixModuleName(char *  moduleName);
 145
 146 extern int sprintf(char * , const char * , ...);
 147
 148 extern void *  memcpy(void * , const void * , size_t size);
 149
 150 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
 151
 152 extern char *  strcpy(char * , const char * );
 153
 154 extern void FullClassNameCat(char *  output, const char *  className, unsigned int includeTemplateParams);
 155
 156 struct __ecereNameSpace__ecere__com__LinkList
 157 {
 158 void * first;
 159 void * last;
 160 int count;
 161 } ecere_gcc_struct;
 162
 163 extern int strcmp(const char * , const char * );
 164
 165 extern void Compiler_Error(const char *  format, ...);
 166
 167 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
 168
 169 struct __ecereNameSpace__ecere__com__LinkElement
 170 {
 171 void * prev;
 172 void * next;
 173 } ecere_gcc_struct;
 174
 175 struct __ecereNameSpace__ecere__com__GlobalFunction;
 176
 177 struct __ecereNameSpace__ecere__com__IteratorPointer;
 178
 179 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
 180
 181 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
 182
 183 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
 184
 185 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
 186
 187 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (*  FreeFunction)(void * ));
 188
 189 extern void ListAddFront(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
 190
 191 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear(struct __ecereNameSpace__ecere__sys__OldList * this);
 192
 193 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
 194
 195 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
 196
 197 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
 198
 199 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
 200
 201 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
 202
 203 struct Location
 204 {
 205 struct CodePosition start;
 206 struct CodePosition end;
 207 } ecere_gcc_struct;
 208
 209 extern struct Location yylloc;
 210
 211 struct External;
 212
 213 extern struct External * curExternal;
 214
 215 static struct External * createInstancesExternal;
 216
 217 static struct External * destroyInstancesExternal;
 218
 219 extern struct External * DeclareStruct(struct External * neededBy, const char *  name, unsigned int skipNoHead, unsigned int needDereference);
 220
 221 struct TopoEdge
 222 {
 223 struct __ecereNameSpace__ecere__com__LinkElement in;
 224 struct __ecereNameSpace__ecere__com__LinkElement out;
 225 struct External * from;
 226 struct External * to;
 227 unsigned int breakable;
 228 } ecere_gcc_struct;
 229
 230 struct Statement;
 231
 232 static struct Statement * curCompound;
 233
 234 static struct Statement * createInstancesBody;
 235
 236 static struct Statement * destroyInstancesBody;
 237
 238 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
 239
 240 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
 241
 242 struct Context;
 243
 244 extern struct Context * globalContext;
 245
 246 extern struct Context * curContext;
 247
 248 extern struct Context * PushContext(void);
 249
 250 extern void PopContext(struct Context * ctx);
 251
 252 struct ModuleImport;
 253
 254 extern struct ModuleImport * mainModule;
 255
 256 struct ModuleImport
 257 {
 258 struct ModuleImport * prev;
 259 struct ModuleImport * next;
 260 char *  name;
 261 struct __ecereNameSpace__ecere__sys__OldList classes;
 262 struct __ecereNameSpace__ecere__sys__OldList functions;
 263 int importType;
 264 int importAccess;
 265 } ecere_gcc_struct;
 266
 267 struct Expression;
 268
 269 extern struct Expression * CopyExpression(struct Expression * exp);
 270
 271 extern struct Expression * MkExpConstant(const char *  string);
 272
 273 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
 274
 275 extern void ProcessExpressionType(struct Expression * exp);
 276
 277 extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__OldList * expressions);
 278
 279 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
 280
 281 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
 282
 283 extern void FreeExpression(struct Expression * exp);
 284
 285 extern struct Expression * QMkExpId(const char *  id);
 286
 287 extern void CheckTemplateTypes(struct Expression * exp);
 288
 289 static void ProcessExpression(struct Expression *  exp);
 290
 291 void ProcessExpressionInstPass(struct Expression * exp)
 292 {
 293 ProcessExpression(exp);
 294 }
 295
 296 struct Declaration;
 297
 298 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
 299
 300 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
 301
 302 static struct Declaration * curDecl;
 303
 304 struct __ecereNameSpace__ecere__com__Class;
 305
 306 struct __ecereNameSpace__ecere__com__Instance
 307 {
 308 void * *  _vTbl;
 309 struct __ecereNameSpace__ecere__com__Class * _class;
 310 int _refCount;
 311 } ecere_gcc_struct;
 312
 313 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 314
 315 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 316
 317 extern unsigned int __ecereNameSpace__ecere__com__eClass_IsDerived(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from);
 318
 319 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
 320
 321 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 322
 323 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 324
 325 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove;
 326
 327 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_GetNext;
 328
 329 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Add;
 330
 331 struct __ecereNameSpace__ecere__com__Property;
 332
 333 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 334
 335 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);
 336
 337 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 338
 339 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 340
 341 extern void DeclareProperty(struct External * neededBy, struct __ecereNameSpace__ecere__com__Property * prop, char *  setName, char *  getName);
 342
 343 struct Specifier;
 344
 345 extern struct Specifier * MkSpecifier(int specifier);
 346
 347 extern struct Specifier * MkSpecifierName(const char *  name);
 348
 349 extern struct Specifier * CopySpecifier(struct Specifier * spec);
 350
 351 extern struct Expression * MkExpClassSize(struct Specifier * _class);
 352
 353 struct Identifier;
 354
 355 struct Statement
 356 {
 357 struct Statement * prev;
 358 struct Statement * next;
 359 struct Location loc;
 360 int type;
 361 union
 362 {
 363 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 364 struct
 365 {
 366 struct Identifier * id;
 367 struct Statement * stmt;
 368 } ecere_gcc_struct labeled;
 369 struct
 370 {
 371 struct Expression * exp;
 372 struct Statement * stmt;
 373 } ecere_gcc_struct caseStmt;
 374 struct
 375 {
 376 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 377 struct __ecereNameSpace__ecere__sys__OldList * statements;
 378 struct Context * context;
 379 unsigned int isSwitch;
 380 } ecere_gcc_struct compound;
 381 struct
 382 {
 383 struct __ecereNameSpace__ecere__sys__OldList * exp;
 384 struct Statement * stmt;
 385 struct Statement * elseStmt;
 386 } ecere_gcc_struct ifStmt;
 387 struct
 388 {
 389 struct __ecereNameSpace__ecere__sys__OldList * exp;
 390 struct Statement * stmt;
 391 } ecere_gcc_struct switchStmt;
 392 struct
 393 {
 394 struct __ecereNameSpace__ecere__sys__OldList * exp;
 395 struct Statement * stmt;
 396 } ecere_gcc_struct whileStmt;
 397 struct
 398 {
 399 struct __ecereNameSpace__ecere__sys__OldList * exp;
 400 struct Statement * stmt;
 401 } ecere_gcc_struct doWhile;
 402 struct
 403 {
 404 struct Statement * init;
 405 struct Statement * check;
 406 struct __ecereNameSpace__ecere__sys__OldList * increment;
 407 struct Statement * stmt;
 408 } ecere_gcc_struct forStmt;
 409 struct
 410 {
 411 struct Identifier * id;
 412 } ecere_gcc_struct gotoStmt;
 413 struct
 414 {
 415 struct Specifier * spec;
 416 char * statements;
 417 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 418 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 419 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 420 } ecere_gcc_struct asmStmt;
 421 struct
 422 {
 423 struct Expression * watcher;
 424 struct Expression * object;
 425 struct __ecereNameSpace__ecere__sys__OldList * watches;
 426 } ecere_gcc_struct _watch;
 427 struct
 428 {
 429 struct Identifier * id;
 430 struct __ecereNameSpace__ecere__sys__OldList * exp;
 431 struct __ecereNameSpace__ecere__sys__OldList * filter;
 432 struct Statement * stmt;
 433 } ecere_gcc_struct forEachStmt;
 434 struct Declaration * decl;
 435 } ecere_gcc_struct __anon1;
 436 } ecere_gcc_struct;
 437
 438 extern struct Identifier * MkIdentifier(const char *  string);
 439
 440 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
 441
 442 extern struct Expression * MkExpIdentifier(struct Identifier * id);
 443
 444 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
 445
 446 extern struct Identifier * CopyIdentifier(struct Identifier * id);
 447
 448 extern void FreeIdentifier(struct Identifier * id);
 449
 450 struct Type;
 451
 452 struct __ecereNameSpace__ecere__com__Property
 453 {
 454 struct __ecereNameSpace__ecere__com__Property * prev;
 455 struct __ecereNameSpace__ecere__com__Property * next;
 456 const char *  name;
 457 unsigned int isProperty;
 458 int memberAccess;
 459 int id;
 460 struct __ecereNameSpace__ecere__com__Class * _class;
 461 const char *  dataTypeString;
 462 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 463 struct Type * dataType;
 464 void (*  Set)(void * , int);
 465 int (*  Get)(void * );
 466 unsigned int (*  IsSet)(void * );
 467 void *  data;
 468 void *  symbol;
 469 int vid;
 470 unsigned int conversion;
 471 unsigned int watcherOffset;
 472 const char *  category;
 473 unsigned int compiled;
 474 unsigned int selfWatchable;
 475 unsigned int isWatchable;
 476 } ecere_gcc_struct;
 477
 478 extern void FreeType(struct Type * type);
 479
 480 extern struct Type * MkClassType(const char *  name);
 481
 482 extern void CopyTypeInto(struct Type * type, struct Type * src);
 483
 484 extern struct Type * ProcessTypeString(const char *  string, unsigned int staticMethod);
 485
 486 struct Initializer;
 487
 488 struct Initializer
 489 {
 490 struct Initializer * prev;
 491 struct Initializer * next;
 492 struct Location loc;
 493 int type;
 494 union
 495 {
 496 struct Expression * exp;
 497 struct __ecereNameSpace__ecere__sys__OldList *  list;
 498 } ecere_gcc_struct __anon1;
 499 unsigned int isConstant;
 500 struct Identifier * id;
 501 } ecere_gcc_struct;
 502
 503 extern void FreeInitializer(struct Initializer * initializer);
 504
 505 extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
 506
 507 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
 508
 509 struct Symbol;
 510
 511 struct Specifier
 512 {
 513 struct Specifier * prev;
 514 struct Specifier * next;
 515 struct Location loc;
 516 int type;
 517 union
 518 {
 519 int specifier;
 520 struct
 521 {
 522 struct ExtDecl * extDecl;
 523 char *  name;
 524 struct Symbol * symbol;
 525 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 526 struct Specifier * nsSpec;
 527 } ecere_gcc_struct __anon1;
 528 struct
 529 {
 530 struct Identifier * id;
 531 struct __ecereNameSpace__ecere__sys__OldList *  list;
 532 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 533 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 534 unsigned int addNameSpace;
 535 struct Context * ctx;
 536 struct ExtDecl * extDeclStruct;
 537 } ecere_gcc_struct __anon2;
 538 struct Expression * expression;
 539 struct Specifier * _class;
 540 struct TemplateParameter * templateParameter;
 541 } ecere_gcc_struct __anon1;
 542 } ecere_gcc_struct;
 543
 544 struct Identifier
 545 {
 546 struct Identifier * prev;
 547 struct Identifier * next;
 548 struct Location loc;
 549 struct Symbol * classSym;
 550 struct Specifier * _class;
 551 char *  string;
 552 struct Identifier * badID;
 553 } ecere_gcc_struct;
 554
 555 extern struct Symbol * FindClass(const char *  name);
 556
 557 extern struct Specifier * _MkSpecifierName(const char *  name, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * templateArgs);
 558
 559 extern struct Type * MkClassTypeSymbol(struct Symbol * symbol);
 560
 561 extern void FreeSymbol(struct Symbol * symbol);
 562
 563 struct Instantiation;
 564
 565 struct Instantiation
 566 {
 567 struct Instantiation * prev;
 568 struct Instantiation * next;
 569 struct Location loc;
 570 struct Specifier * _class;
 571 struct Expression * exp;
 572 struct __ecereNameSpace__ecere__sys__OldList *  members;
 573 struct Symbol * symbol;
 574 unsigned int fullSet;
 575 unsigned int isConstant;
 576 unsigned char *  data;
 577 struct Location nameLoc;
 578 struct Location insideLoc;
 579 unsigned int built;
 580 } ecere_gcc_struct;
 581
 582 struct Declaration
 583 {
 584 struct Declaration * prev;
 585 struct Declaration * next;
 586 struct Location loc;
 587 int type;
 588 union
 589 {
 590 struct
 591 {
 592 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 593 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 594 } ecere_gcc_struct __anon1;
 595 struct Instantiation * inst;
 596 struct
 597 {
 598 struct Identifier * id;
 599 struct Expression * exp;
 600 } ecere_gcc_struct __anon2;
 601 } ecere_gcc_struct __anon1;
 602 struct Specifier * extStorage;
 603 struct Symbol * symbol;
 604 int declMode;
 605 } ecere_gcc_struct;
 606
 607 extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
 608
 609 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
 610
 611 extern void FreeInstance(struct Instantiation * inst);
 612
 613 extern struct Expression * MkExpInstance(struct Instantiation * inst);
 614
 615 struct __ecereNameSpace__ecere__com__Method;
 616
 617 struct __ecereNameSpace__ecere__com__Method
 618 {
 619 const char *  name;
 620 struct __ecereNameSpace__ecere__com__Method * parent;
 621 struct __ecereNameSpace__ecere__com__Method * left;
 622 struct __ecereNameSpace__ecere__com__Method * right;
 623 int depth;
 624 int (*  function)();
 625 int vid;
 626 int type;
 627 struct __ecereNameSpace__ecere__com__Class * _class;
 628 void *  symbol;
 629 const char *  dataTypeString;
 630 struct Type * dataType;
 631 int memberAccess;
 632 } ecere_gcc_struct;
 633
 634 struct Type
 635 {
 636 struct Type * prev;
 637 struct Type * next;
 638 int refCount;
 639 union
 640 {
 641 struct Symbol * _class;
 642 struct
 643 {
 644 struct __ecereNameSpace__ecere__sys__OldList members;
 645 char *  enumName;
 646 } ecere_gcc_struct __anon1;
 647 struct
 648 {
 649 struct Type * returnType;
 650 struct __ecereNameSpace__ecere__sys__OldList params;
 651 struct Symbol * thisClass;
 652 unsigned int staticMethod;
 653 struct TemplateParameter * thisClassTemplate;
 654 } ecere_gcc_struct __anon2;
 655 struct
 656 {
 657 struct __ecereNameSpace__ecere__com__Method * method;
 658 struct __ecereNameSpace__ecere__com__Class * methodClass;
 659 struct __ecereNameSpace__ecere__com__Class * usedClass;
 660 } ecere_gcc_struct __anon3;
 661 struct
 662 {
 663 struct Type * arrayType;
 664 int arraySize;
 665 struct Expression * arraySizeExp;
 666 unsigned int freeExp;
 667 struct Symbol * enumClass;
 668 } ecere_gcc_struct __anon4;
 669 struct Type * type;
 670 struct TemplateParameter * templateParameter;
 671 } ecere_gcc_struct __anon1;
 672 int kind;
 673 unsigned int size;
 674 char *  name;
 675 char *  typeName;
 676 struct __ecereNameSpace__ecere__com__Class * thisClassFrom;
 677 int promotedFrom;
 678 int classObjectType;
 679 int alignment;
 680 unsigned int offset;
 681 int bitFieldCount;
 682 int count;
 683 int bitMemberSize;
 684 unsigned int isSigned : 1;
 685 unsigned int constant : 1;
 686 unsigned int truth : 1;
 687 unsigned int byReference : 1;
 688 unsigned int extraParam : 1;
 689 unsigned int directClassAccess : 1;
 690 unsigned int computing : 1;
 691 unsigned int keepCast : 1;
 692 unsigned int passAsTemplate : 1;
 693 unsigned int dllExport : 1;
 694 unsigned int attrStdcall : 1;
 695 unsigned int declaredWithStruct : 1;
 696 unsigned int typedByReference : 1;
 697 unsigned int casted : 1;
 698 unsigned int pointerAlignment : 1;
 699 unsigned int isLong : 1;
 700 unsigned int signedBeforePromotion : 1;
 701 } ecere_gcc_struct;
 702
 703 extern void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
 704
 705 struct Declarator;
 706
 707 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
 708
 709 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
 710
 711 struct Expression
 712 {
 713 struct Expression * prev;
 714 struct Expression * next;
 715 struct Location loc;
 716 int type;
 717 union
 718 {
 719 struct
 720 {
 721 char *  constant;
 722 struct Identifier * identifier;
 723 } ecere_gcc_struct __anon1;
 724 struct Statement * compound;
 725 struct Instantiation * instance;
 726 struct
 727 {
 728 char *  string;
 729 unsigned int intlString;
 730 unsigned int wideString;
 731 } ecere_gcc_struct __anon2;
 732 struct __ecereNameSpace__ecere__sys__OldList *  list;
 733 struct
 734 {
 735 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 736 struct Declarator * decl;
 737 } ecere_gcc_struct _classExp;
 738 struct
 739 {
 740 struct Identifier * id;
 741 } ecere_gcc_struct classData;
 742 struct
 743 {
 744 struct Expression * exp;
 745 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 746 struct Location argLoc;
 747 } ecere_gcc_struct call;
 748 struct
 749 {
 750 struct Expression * exp;
 751 struct __ecereNameSpace__ecere__sys__OldList * index;
 752 } ecere_gcc_struct index;
 753 struct
 754 {
 755 struct Expression * exp;
 756 struct Identifier * member;
 757 int memberType;
 758 unsigned int thisPtr;
 759 } ecere_gcc_struct member;
 760 struct
 761 {
 762 int op;
 763 struct Expression * exp1;
 764 struct Expression * exp2;
 765 } ecere_gcc_struct op;
 766 struct TypeName * typeName;
 767 struct Specifier * _class;
 768 struct
 769 {
 770 struct TypeName * typeName;
 771 struct Expression * exp;
 772 } ecere_gcc_struct cast;
 773 struct
 774 {
 775 struct Expression * cond;
 776 struct __ecereNameSpace__ecere__sys__OldList * exp;
 777 struct Expression * elseExp;
 778 } ecere_gcc_struct cond;
 779 struct
 780 {
 781 struct TypeName * typeName;
 782 struct Expression * size;
 783 } ecere_gcc_struct _new;
 784 struct
 785 {
 786 struct TypeName * typeName;
 787 struct Expression * size;
 788 struct Expression * exp;
 789 } ecere_gcc_struct _renew;
 790 struct
 791 {
 792 char * table;
 793 struct Identifier * id;
 794 } ecere_gcc_struct db;
 795 struct
 796 {
 797 struct Expression * ds;
 798 struct Expression * name;
 799 } ecere_gcc_struct dbopen;
 800 struct
 801 {
 802 struct TypeName * typeName;
 803 struct Initializer * initializer;
 804 } ecere_gcc_struct initializer;
 805 struct
 806 {
 807 struct Expression * exp;
 808 struct TypeName * typeName;
 809 } ecere_gcc_struct vaArg;
 810 } ecere_gcc_struct __anon1;
 811 unsigned int debugValue;
 812 struct __ecereNameSpace__ecere__com__DataValue val;
 813 uint64 address;
 814 unsigned int hasAddress;
 815 struct Type * expType;
 816 struct Type * destType;
 817 unsigned int usage;
 818 int tempCount;
 819 unsigned int byReference;
 820 unsigned int isConstant;
 821 unsigned int addedThis;
 822 unsigned int needCast;
 823 unsigned int thisPtr;
 824 unsigned int opDestType;
 825 unsigned int needTemplateCast;
 826 } ecere_gcc_struct;
 827
 828 extern struct Declarator * SpecDeclFromString(const char *  string, struct __ecereNameSpace__ecere__sys__OldList *  specs, struct Declarator * baseDecl);
 829
 830 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
 831
 832 extern struct TypeName * QMkClass(const char *  spec, struct Declarator * decl);
 833
 834 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
 835
 836 struct Declarator
 837 {
 838 struct Declarator * prev;
 839 struct Declarator * next;
 840 struct Location loc;
 841 int type;
 842 struct Symbol * symbol;
 843 struct Declarator * declarator;
 844 union
 845 {
 846 struct Identifier * identifier;
 847 struct
 848 {
 849 struct Expression * exp;
 850 struct Expression * posExp;
 851 struct Attrib * attrib;
 852 } ecere_gcc_struct structDecl;
 853 struct
 854 {
 855 struct Expression * exp;
 856 struct Specifier * enumClass;
 857 } ecere_gcc_struct array;
 858 struct
 859 {
 860 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 861 } ecere_gcc_struct function;
 862 struct
 863 {
 864 struct Pointer * pointer;
 865 } ecere_gcc_struct pointer;
 866 struct
 867 {
 868 struct ExtDecl * extended;
 869 } ecere_gcc_struct extended;
 870 } ecere_gcc_struct __anon1;
 871 } ecere_gcc_struct;
 872
 873 static void ProcessInitializer(struct Initializer * init)
 874 {
 875 switch(init->type)
 876 {
 877 case 0:
 878 init->__anon1.exp->usage = (init->__anon1.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
 879 ProcessExpression(init->__anon1.exp);
 880 break;
 881 case 1:
 882 {
 883 struct Initializer * i;
 884
 885 for(i = (*init->__anon1.list).first; i; i = i->next)
 886 ProcessInitializer(i);
 887 break;
 888 }
 889 }
 890 }
 891
 892 struct ClassImport;
 893
 894 struct Symbol
 895 {
 896 char *  string;
 897 struct Symbol * parent;
 898 struct Symbol * left;
 899 struct Symbol * right;
 900 int depth;
 901 struct Type * type;
 902 union
 903 {
 904 struct __ecereNameSpace__ecere__com__Method * method;
 905 struct __ecereNameSpace__ecere__com__Property * _property;
 906 struct __ecereNameSpace__ecere__com__Class * registered;
 907 } ecere_gcc_struct __anon1;
 908 unsigned int notYetDeclared;
 909 union
 910 {
 911 struct
 912 {
 913 struct External * pointerExternal;
 914 struct External * structExternal;
 915 } ecere_gcc_struct __anon1;
 916 struct
 917 {
 918 struct External * externalGet;
 919 struct External * externalSet;
 920 struct External * externalPtr;
 921 struct External * externalIsSet;
 922 } ecere_gcc_struct __anon2;
 923 struct
 924 {
 925 struct External * methodExternal;
 926 struct External * methodCodeExternal;
 927 } ecere_gcc_struct __anon3;
 928 } ecere_gcc_struct __anon2;
 929 unsigned int imported;
 930 unsigned int declaredStructSym;
 931 struct __ecereNameSpace__ecere__com__Class * _class;
 932 unsigned int declaredStruct;
 933 unsigned int needConstructor;
 934 unsigned int needDestructor;
 935 char *  constructorName;
 936 char *  structName;
 937 char *  className;
 938 char *  destructorName;
 939 struct ModuleImport * module;
 940 struct ClassImport * _import;
 941 struct Location nameLoc;
 942 unsigned int isParam;
 943 unsigned int isRemote;
 944 unsigned int isStruct;
 945 unsigned int fireWatchersDone;
 946 int declaring;
 947 unsigned int classData;
 948 unsigned int isStatic;
 949 char *  shortName;
 950 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 951 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 952 struct Context * ctx;
 953 int isIterator;
 954 struct Expression * propCategory;
 955 unsigned int mustRegister;
 956 } ecere_gcc_struct;
 957
 958 struct ClassImport
 959 {
 960 struct ClassImport * prev;
 961 struct ClassImport * next;
 962 char *  name;
 963 struct __ecereNameSpace__ecere__sys__OldList methods;
 964 struct __ecereNameSpace__ecere__sys__OldList properties;
 965 unsigned int itself;
 966 int isRemote;
 967 } ecere_gcc_struct;
 968
 969 struct MembersInit;
 970
 971 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
 972
 973 struct __ecereNameSpace__ecere__sys__BinaryTree;
 974
 975 struct __ecereNameSpace__ecere__sys__BinaryTree
 976 {
 977 struct __ecereNameSpace__ecere__sys__BTNode * root;
 978 int count;
 979 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
 980 void (*  FreeKey)(void *  key);
 981 } ecere_gcc_struct;
 982
 983 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
 984
 985 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
 986
 987 struct FunctionDefinition;
 988
 989 extern struct FunctionDefinition * _MkFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * declarationList, unsigned int errorOnOmit);
 990
 991 extern void ProcessFunctionBody(struct FunctionDefinition * func, struct Statement * body);
 992
 993 extern struct External * MkExternalFunction(struct FunctionDefinition * function);
 994
 995 struct FunctionDefinition
 996 {
 997 struct FunctionDefinition * prev;
 998 struct FunctionDefinition * next;
 999 struct Location loc;
1000 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1001 struct Declarator * declarator;
1002 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
1003 struct Statement * body;
1004 struct __ecereNameSpace__ecere__com__Class * _class;
1005 struct __ecereNameSpace__ecere__sys__OldList attached;
1006 int declMode;
1007 struct Type * type;
1008 struct Symbol * propSet;
1009 int tempCount;
1010 unsigned int propertyNoThis;
1011 } ecere_gcc_struct;
1012
1013 struct PropertyWatch;
1014
1015 struct PropertyWatch
1016 {
1017 struct PropertyWatch * prev;
1018 struct PropertyWatch * next;
1019 struct Location loc;
1020 struct Statement * compound;
1021 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1022 unsigned int deleteWatch;
1023 } ecere_gcc_struct;
1024
1025 struct InitDeclarator;
1026
1027 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1028
1029 extern struct Declaration * QMkDeclaration(const char *  name, struct InitDeclarator * initDecl);
1030
1031 struct InitDeclarator
1032 {
1033 struct InitDeclarator * prev;
1034 struct InitDeclarator * next;
1035 struct Location loc;
1036 struct Declarator * declarator;
1037 struct Initializer * initializer;
1038 } ecere_gcc_struct;
1039
1040 struct __ecereNameSpace__ecere__com__DataMember;
1041
1042 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
1043 {
1044 union
1045 {
1046 struct
1047 {
1048 const char *  dataTypeString;
1049 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1050 } ecere_gcc_struct __anon1;
1051 struct __ecereNameSpace__ecere__com__DataValue expression;
1052 struct
1053 {
1054 const char *  memberString;
1055 union
1056 {
1057 struct __ecereNameSpace__ecere__com__DataMember * member;
1058 struct __ecereNameSpace__ecere__com__Property * prop;
1059 struct __ecereNameSpace__ecere__com__Method * method;
1060 } ecere_gcc_struct __anon1;
1061 } ecere_gcc_struct __anon2;
1062 } ecere_gcc_struct __anon1;
1063 } ecere_gcc_struct;
1064
1065 struct __ecereNameSpace__ecere__com__DataMember
1066 {
1067 struct __ecereNameSpace__ecere__com__DataMember * prev;
1068 struct __ecereNameSpace__ecere__com__DataMember * next;
1069 const char *  name;
1070 unsigned int isProperty;
1071 int memberAccess;
1072 int id;
1073 struct __ecereNameSpace__ecere__com__Class * _class;
1074 const char *  dataTypeString;
1075 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1076 struct Type * dataType;
1077 int type;
1078 int offset;
1079 int memberID;
1080 struct __ecereNameSpace__ecere__sys__OldList members;
1081 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
1082 int memberOffset;
1083 short structAlignment;
1084 short pointerAlignment;
1085 } ecere_gcc_struct;
1086
1087 extern void __ecereNameSpace__ecere__com__eClass_FindNextMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class **  curClass, struct __ecereNameSpace__ecere__com__DataMember **  curMember, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1088
1089 struct __ecereNameSpace__ecere__com__Module;
1090
1091 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);
1092
1093 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1094
1095 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1096
1097 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1098
1099 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);
1100
1101 struct Enumerator;
1102
1103 struct Enumerator
1104 {
1105 struct Enumerator * prev;
1106 struct Enumerator * next;
1107 struct Location loc;
1108 struct Identifier * id;
1109 struct Expression * exp;
1110 } ecere_gcc_struct;
1111
1112 struct AsmField;
1113
1114 struct AsmField
1115 {
1116 struct AsmField * prev;
1117 struct AsmField * next;
1118 struct Location loc;
1119 char *  command;
1120 struct Expression * expression;
1121 struct Identifier * symbolic;
1122 } ecere_gcc_struct;
1123
1124 struct __ecereNameSpace__ecere__com__BitMember;
1125
1126 struct __ecereNameSpace__ecere__com__BitMember
1127 {
1128 struct __ecereNameSpace__ecere__com__BitMember * prev;
1129 struct __ecereNameSpace__ecere__com__BitMember * next;
1130 const char *  name;
1131 unsigned int isProperty;
1132 int memberAccess;
1133 int id;
1134 struct __ecereNameSpace__ecere__com__Class * _class;
1135 const char *  dataTypeString;
1136 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1137 struct Type * dataType;
1138 int type;
1139 int size;
1140 int pos;
1141 uint64 mask;
1142 } ecere_gcc_struct;
1143
1144 struct MemberInit;
1145
1146 struct MemberInit
1147 {
1148 struct MemberInit * prev;
1149 struct MemberInit * next;
1150 struct Location loc;
1151 struct Location realLoc;
1152 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
1153 struct Initializer * initializer;
1154 unsigned int used;
1155 unsigned int variable;
1156 unsigned int takeOutExp;
1157 } ecere_gcc_struct;
1158
1159 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
1160
1161 static void ProcessMemberInitData(struct MemberInit * member)
1162 {
1163 if(member->initializer)
1164 ProcessInitializer(member->initializer);
1165 }
1166
1167 struct ClassDefinition;
1168
1169 struct Context
1170 {
1171 struct Context * parent;
1172 struct __ecereNameSpace__ecere__sys__BinaryTree types;
1173 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1174 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
1175 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
1176 int nextID;
1177 int simpleID;
1178 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
1179 struct ClassDefinition * classDef;
1180 unsigned int templateTypesOnly;
1181 unsigned int hasNameSpace;
1182 } ecere_gcc_struct;
1183
1184 struct External
1185 {
1186 struct External * prev;
1187 struct External * next;
1188 struct Location loc;
1189 int type;
1190 struct Symbol * symbol;
1191 union
1192 {
1193 struct FunctionDefinition * function;
1194 struct ClassDefinition * _class;
1195 struct Declaration * declaration;
1196 char *  importString;
1197 struct Identifier * id;
1198 struct DBTableDef * table;
1199 } ecere_gcc_struct __anon1;
1200 int importType;
1201 struct External * fwdDecl;
1202 struct __ecereNameSpace__ecere__com__Instance * outgoing;
1203 struct __ecereNameSpace__ecere__com__Instance * incoming;
1204 int nonBreakableIncoming;
1205 } ecere_gcc_struct;
1206
1207 struct ClassDefinition
1208 {
1209 struct ClassDefinition * prev;
1210 struct ClassDefinition * next;
1211 struct Location loc;
1212 struct Specifier * _class;
1213 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
1214 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
1215 struct Symbol * symbol;
1216 struct Location blockStart;
1217 struct Location nameLoc;
1218 int declMode;
1219 unsigned int deleteWatchable;
1220 } ecere_gcc_struct;
1221
1222 void __ecereMethod_External_CreateUniqueEdge(struct External * this, struct External * from, unsigned int soft);
1223
1224 void __ecereMethod_External_CreateEdge(struct External * this, struct External * from, unsigned int soft);
1225
1226 struct ClassFunction;
1227
1228 struct MembersInit
1229 {
1230 struct MembersInit * prev;
1231 struct MembersInit * next;
1232 struct Location loc;
1233 int type;
1234 union
1235 {
1236 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
1237 struct ClassFunction * function;
1238 } ecere_gcc_struct __anon1;
1239 } ecere_gcc_struct;
1240
1241 struct ClassFunction
1242 {
1243 struct ClassFunction * prev;
1244 struct ClassFunction * next;
1245 struct Location loc;
1246 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1247 struct Declarator * declarator;
1248 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
1249 struct Statement * body;
1250 struct __ecereNameSpace__ecere__com__Class * _class;
1251 struct __ecereNameSpace__ecere__sys__OldList attached;
1252 int declMode;
1253 struct Type * type;
1254 struct Symbol * propSet;
1255 unsigned int isVirtual;
1256 unsigned int isConstructor;
1257 unsigned int isDestructor;
1258 unsigned int dontMangle;
1259 int id;
1260 int idCode;
1261 } ecere_gcc_struct;
1262
1263 static unsigned int ProcessInstMembers_SimpleMemberEnsure(struct __ecereNameSpace__ecere__com__DataMember * parentMember, struct Instantiation * inst, struct Expression * instExp, struct __ecereNameSpace__ecere__sys__OldList * list, unsigned int zeroOut)
1264 {
1265 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
1266 unsigned int fullSet = 1;
1267 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1268
1269 for(dataMember = parentMember->members.first; dataMember; dataMember = dataMember->next)
1270 {
1271 if(!dataMember->isProperty)
1272 {
1273 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
1274 {
1275 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
1276 fullSet = 0;
1277 }
1278 else
1279 {
1280 unsigned int memberFilled = 0;
1281
1282 if(inst->members && (*inst->members).first)
1283 {
1284 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1285 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1286 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1287 int subMemberStackPos = 0;
1288 struct MembersInit * members;
1289
1290 for(members = (*inst->members).first; members; members = members->next)
1291 {
1292 if(members->type == 0)
1293 {
1294 struct MemberInit * member = (((void *)0));
1295
1296 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
1297 {
1298 if(member->identifiers)
1299 {
1300 struct Identifier * firstID = (*member->identifiers).first;
1301 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1302 int _subMemberStackPos = 0;
1303 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule);
1304
1305 if(!thisMember)
1306 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1307 if(thisMember)
1308 {
1309 if(thisMember && thisMember->memberAccess == 1)
1310 {
1311 curMember = thisMember;
1312 curClass = curMember->_class;
1313 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1314 subMemberStackPos = _subMemberStackPos;
1315 }
1316 if(!firstID->next && thisMember == dataMember)
1317 {
1318 memberFilled = 1;
1319 break;
1320 }
1321 }
1322 }
1323 else
1324 {
1325 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1326 if(curMember == dataMember)
1327 {
1328 memberFilled = 1;
1329 break;
1330 }
1331 }
1332 }
1333 if(memberFilled)
1334 break;
1335 }
1336 if(memberFilled)
1337 break;
1338 }
1339 }
1340 if(!memberFilled)
1341 {
1342 if(zeroOut)
1343 {
1344 struct Expression * instExpCopy = CopyExpression(instExp);
1345 struct Expression * memberExp;
1346 struct Expression * setExp;
1347 struct Expression * value = MkExpConstant("0");
1348
1349 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember->name));
1350 memberExp->__anon1.member.memberType = 3;
1351 value->usage = (value->usage & ~0x1) | (((unsigned int)(1)) << 0);
1352 setExp = MkExpOp(memberExp, '=', value);
1353 value->loc = inst->loc;
1354 setExp->loc = inst->loc;
1355 FreeType(instExpCopy->expType);
1356 instExpCopy->expType = instExp->expType;
1357 if(instExp->expType)
1358 instExp->expType->refCount++;
1359 ProcessExpressionType(setExp);
1360 ProcessExpression(setExp);
1361 ListAdd(list, setExp);
1362 }
1363 fullSet = 0;
1364 }
1365 }
1366 }
1367 }
1368 return fullSet;
1369 }
1370
1371 struct PropertyDef;
1372
1373 struct PropertyDef
1374 {
1375 struct PropertyDef * prev;
1376 struct PropertyDef * next;
1377 struct Location loc;
1378 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1379 struct Declarator * declarator;
1380 struct Identifier * id;
1381 struct Statement * getStmt;
1382 struct Statement * setStmt;
1383 struct Statement * issetStmt;
1384 struct Symbol * symbol;
1385 struct Expression * category;
1386 struct
1387 {
1388 unsigned int conversion : 1;
1389 unsigned int isWatchable : 1;
1390 unsigned int isDBProp : 1;
1391 } ecere_gcc_struct __anon1;
1392 } ecere_gcc_struct;
1393
1394 struct __ecereNameSpace__ecere__com__NameSpace;
1395
1396 struct __ecereNameSpace__ecere__com__NameSpace
1397 {
1398 const char *  name;
1399 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1400 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1401 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1402 int depth;
1403 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1404 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1405 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1406 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1407 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1408 } ecere_gcc_struct;
1409
1410 struct __ecereNameSpace__ecere__com__Class
1411 {
1412 struct __ecereNameSpace__ecere__com__Class * prev;
1413 struct __ecereNameSpace__ecere__com__Class * next;
1414 const char *  name;
1415 int offset;
1416 int structSize;
1417 void * *  _vTbl;
1418 int vTblSize;
1419 unsigned int (*  Constructor)(void * );
1420 void (*  Destructor)(void * );
1421 int offsetClass;
1422 int sizeClass;
1423 struct __ecereNameSpace__ecere__com__Class * base;
1424 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
1425 struct __ecereNameSpace__ecere__sys__BinaryTree members;
1426 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
1427 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
1428 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
1429 struct __ecereNameSpace__ecere__sys__OldList derivatives;
1430 int memberID;
1431 int startMemberID;
1432 int type;
1433 struct __ecereNameSpace__ecere__com__Instance * module;
1434 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
1435 const char *  dataTypeString;
1436 struct Type * dataType;
1437 int typeSize;
1438 int defaultAlignment;
1439 void (*  Initialize)();
1440 int memberOffset;
1441 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
1442 const char *  designerClass;
1443 unsigned int noExpansion;
1444 const char *  defaultProperty;
1445 unsigned int comRedefinition;
1446 int count;
1447 int isRemote;
1448 unsigned int internalDecl;
1449 void *  data;
1450 unsigned int computeSize;
1451 short structAlignment;
1452 short pointerAlignment;
1453 int destructionWatchOffset;
1454 unsigned int fixed;
1455 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
1456 int inheritanceAccess;
1457 const char *  fullName;
1458 void *  symbol;
1459 struct __ecereNameSpace__ecere__sys__OldList conversions;
1460 struct __ecereNameSpace__ecere__sys__OldList templateParams;
1461 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
1462 struct __ecereNameSpace__ecere__com__Class * templateClass;
1463 struct __ecereNameSpace__ecere__sys__OldList templatized;
1464 int numParams;
1465 unsigned int isInstanceClass;
1466 unsigned int byValueSystemClass;
1467 } ecere_gcc_struct;
1468
1469 struct __ecereNameSpace__ecere__com__Application
1470 {
1471 int argc;
1472 const char * *  argv;
1473 int exitCode;
1474 unsigned int isGUIApp;
1475 struct __ecereNameSpace__ecere__sys__OldList allModules;
1476 char *  parsedCommand;
1477 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1478 } ecere_gcc_struct;
1479
1480 static unsigned int ProcessInstMembers(struct Instantiation * inst, struct Expression * instExp, struct __ecereNameSpace__ecere__sys__OldList * list, unsigned int zeroOut)
1481 {
1482 struct MembersInit * members;
1483 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
1484 unsigned int fullSet = 1, convert = 0;
1485
1486 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 2)
1487 {
1488 struct Expression * exp = (((void *)0));
1489
1490 if(inst->members && (*inst->members).first)
1491 {
1492 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1493
1494 while(_class != classSym->__anon1.registered)
1495 {
1496 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (((void *)0));
1497 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
1498
1499 for(_class = classSym->__anon1.registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
1500 ;
1501 for(bitMember = _class->membersAndProperties.first; bitMember; bitMember = bitMember->next)
1502 {
1503 struct __ecereNameSpace__ecere__com__BitMember * curMember = (((void *)0));
1504 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1505 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1506 int subMemberStackPos = 0;
1507 struct MemberInit * member = (((void *)0));
1508 unsigned int found = 0;
1509
1510 for(members = (*inst->members).first; members; members = members->next)
1511 {
1512 if(members->type == 0)
1513 {
1514 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
1515 {
1516 if(member->identifiers)
1517 {
1518 struct Identifier * firstID = (*member->identifiers).first;
1519 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1520 int _subMemberStackPos = 0;
1521 struct __ecereNameSpace__ecere__com__BitMember * thisMember = (struct __ecereNameSpace__ecere__com__BitMember *)__ecereNameSpace__ecere__com__eClass_FindDataMember(_class, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1522
1523 if(!thisMember)
1524 {
1525 thisMember = (struct __ecereNameSpace__ecere__com__BitMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, firstID->string, privateModule);
1526 }
1527 if(thisMember && thisMember->memberAccess == 1)
1528 {
1529 curMember = thisMember;
1530 curClass = curMember->_class;
1531 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1532 subMemberStackPos = _subMemberStackPos;
1533 }
1534 if(thisMember == bitMember)
1535 {
1536 found = 1;
1537 break;
1538 }
1539 }
1540 else
1541 {
1542 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, (struct __ecereNameSpace__ecere__com__DataMember **)&curMember, subMemberStack, &subMemberStackPos);
1543 if(curMember == bitMember)
1544 {
1545 found = 1;
1546 break;
1547 }
1548 }
1549 }
1550 }
1551 if(found)
1552 break;
1553 }
1554 if(member)
1555 {
1556 if(!bitMember->isProperty)
1557 {
1558 struct Expression * part = (((void *)0));
1559 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1560 struct Declarator * decl;
1561
1562 decl = SpecDeclFromString(_class->dataTypeString, specs, (((void *)0)));
1563 ProcessInitializer(member->initializer);
1564 if(member->initializer && member->initializer->type == 0)
1565 {
1566 if(bitMember->pos)
1567 {
1568 char pos[10];
1569
1570 sprintf(pos, "%d", bitMember->pos);
1571 part = MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl), MkExpBrackets(MkListOne(member->initializer->__anon1.exp))))), LEFT_OP, MkExpConstant(pos))));
1572 }
1573 else
1574 part = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl), MkExpBrackets(MkListOne(member->initializer->__anon1.exp)))));
1575 member->initializer->__anon1.exp = (((void *)0));
1576 FreeInitializer(member->initializer);
1577 member->initializer = (((void *)0));
1578 }
1579 if(exp)
1580 exp = MkExpOp(exp, '|', part);
1581 else
1582 exp = part;
1583 }
1584 else
1585 {
1586 char setName[1024], getName[1024];
1587
1588 DeclareProperty(curExternal, (struct __ecereNameSpace__ecere__com__Property *)bitMember, setName, getName);
1589 if(member->initializer && member->initializer->type == 0)
1590 {
1591 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)), MkListOne(member->initializer->__anon1.exp));
1592 member->initializer->__anon1.exp = (((void *)0));
1593 FreeInitializer(member->initializer);
1594 member->initializer = (((void *)0));
1595 }
1596 }
1597 }
1598 }
1599 }
1600 }
1601 if(exp)
1602 exp = MkExpBrackets(MkListOne(exp));
1603 else
1604 exp = MkExpConstant("0");
1605 exp->expType = MkClassType(classSym->string);
1606 ProcessExpression(exp);
1607 ListAdd(list, exp);
1608 }
1609 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 3)
1610 {
1611 struct __ecereNameSpace__ecere__com__Class * _class = classSym->__anon1.registered;
1612 struct Expression * exp = (((void *)0));
1613
1614 if(inst->members && (*inst->members).first)
1615 {
1616 struct MemberInit * member = (((void *)0));
1617 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
1618 unsigned int found = 0;
1619
1620 for(members = (*inst->members).first; members; members = members->next)
1621 {
1622 if(members->type == 0)
1623 {
1624 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
1625 {
1626 if(member->identifiers)
1627 {
1628 struct Identifier * firstID = (*member->identifiers).first;
1629
1630 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, firstID->string, privateModule);
1631 if(prop)
1632 {
1633 found = 1;
1634 break;
1635 }
1636 prop = (((void *)0));
1637 }
1638 else
1639 {
1640 found = 1;
1641 break;
1642 }
1643 }
1644 }
1645 if(found)
1646 break;
1647 }
1648 if(member)
1649 {
1650 if(prop)
1651 {
1652 char setName[1024], getName[1024];
1653
1654 DeclareProperty(curExternal, prop, setName, getName);
1655 if(member->initializer && member->initializer->type == 0)
1656 {
1657 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)), MkListOne(member->initializer->__anon1.exp));
1658 member->initializer->__anon1.exp = (((void *)0));
1659 FreeInitializer(member->initializer);
1660 member->initializer = (((void *)0));
1661 }
1662 }
1663 else
1664 {
1665 ProcessInitializer(member->initializer);
1666 if(member->initializer && member->initializer->type == 0)
1667 {
1668 exp = MkExpCast(QMkClass(_class->fullName, (((void *)0))), MkExpBrackets(MkListOne(member->initializer->__anon1.exp)));
1669 member->initializer->__anon1.exp = (((void *)0));
1670 FreeInitializer(member->initializer);
1671 member->initializer = (((void *)0));
1672 }
1673 }
1674 }
1675 }
1676 if(exp)
1677 exp = MkExpBrackets(MkListOne(exp));
1678 else
1679 exp = MkExpConstant("0");
1680 ProcessExpression(exp);
1681 ListAdd(list, exp);
1682 }
1683 else if(classSym && classSym->__anon1.registered)
1684 {
1685 if(classSym->__anon1.registered->type == 1)
1686 {
1687 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1688
1689 while(_class != classSym->__anon1.registered)
1690 {
1691 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1692 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
1693
1694 for(_class = classSym->__anon1.registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
1695 ;
1696 if(_class->structSize != _class->memberOffset)
1697 fullSet = 0;
1698 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
1699 {
1700 if(!dataMember->isProperty)
1701 {
1702 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
1703 {
1704 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
1705 fullSet = 0;
1706 }
1707 else
1708 {
1709 unsigned int memberFilled = 0;
1710
1711 if(inst->members && (*inst->members).first)
1712 {
1713 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1714 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1715 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1716 int subMemberStackPos = 0;
1717
1718 for(members = (*inst->members).first; members; members = members->next)
1719 {
1720 if(members->type == 0 && members->__anon1.dataMembers)
1721 {
1722 struct MemberInit * member = (((void *)0));
1723
1724 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
1725 {
1726 if(member->identifiers)
1727 {
1728 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1729 int _subMemberStackPos = 0;
1730 struct Identifier * firstID = (*member->identifiers).first;
1731 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule);
1732
1733 if(!thisMember)
1734 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1735 if(thisMember)
1736 {
1737 if(thisMember->memberAccess == 1)
1738 {
1739 curMember = thisMember;
1740 curClass = curMember->_class;
1741 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1742 subMemberStackPos = _subMemberStackPos;
1743 }
1744 if(!firstID->next && curMember == dataMember)
1745 {
1746 memberFilled = 1;
1747 break;
1748 }
1749 }
1750 }
1751 else
1752 {
1753 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1754 if(curMember == dataMember)
1755 {
1756 memberFilled = 1;
1757 break;
1758 }
1759 }
1760 }
1761 if(memberFilled)
1762 break;
1763 }
1764 if(memberFilled)
1765 break;
1766 }
1767 }
1768 if(!memberFilled)
1769 {
1770 if(zeroOut)
1771 {
1772 struct Expression * instExpCopy = CopyExpression(instExp);
1773 struct Expression * memberExp;
1774 struct Expression * setExp;
1775 struct Expression * value = MkExpConstant("0");
1776
1777 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember->name));
1778 memberExp->__anon1.member.memberType = 3;
1779 value->usage = (value->usage & ~0x1) | (((unsigned int)(1)) << 0);
1780 setExp = MkExpOp(memberExp, '=', value);
1781 value->loc = inst->loc;
1782 setExp->loc = inst->loc;
1783 FreeType(instExpCopy->expType);
1784 instExpCopy->expType = instExp->expType;
1785 if(instExp->expType)
1786 instExp->expType->refCount++;
1787 ProcessExpressionType(setExp);
1788 ProcessExpression(setExp);
1789 ListAdd(list, setExp);
1790 }
1791 fullSet = 0;
1792 }
1793 }
1794 }
1795 }
1796 }
1797 }
1798 if(inst->members && (*inst->members).first)
1799 {
1800 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1801 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1802 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1803 int subMemberStackPos = 0;
1804
1805 for(members = (*inst->members).first; members; members = members->next)
1806 {
1807 if(members->type == 0 && members->__anon1.dataMembers)
1808 {
1809 struct MemberInit * member = (((void *)0));
1810 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
1811
1812 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
1813 {
1814 struct Identifier * ident = (((void *)0));
1815 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (((void *)0));
1816
1817 if(member->identifiers)
1818 {
1819 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1820 int _subMemberStackPos = 0;
1821 struct Identifier * firstID = (*member->identifiers).first;
1822
1823 thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule);
1824 if(!thisMember)
1825 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1826 ident = firstID;
1827 if(thisMember)
1828 {
1829 if(thisMember->memberAccess == 1)
1830 {
1831 curMember = thisMember;
1832 curClass = curMember->_class;
1833 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1834 subMemberStackPos = _subMemberStackPos;
1835 }
1836 }
1837 else if(classSym->__anon1.registered->type != 1)
1838 {
1839 method = __ecereNameSpace__ecere__com__eClass_FindMethod(classSym->__anon1.registered, ident->string, privateModule);
1840 if(!method || method->type != 1)
1841 method = (((void *)0));
1842 }
1843 }
1844 else
1845 {
1846 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1847 thisMember = curMember;
1848 }
1849 if(instExp && (thisMember || method))
1850 {
1851 struct Expression * instExpCopy = CopyExpression(instExp);
1852 struct Expression * setExp = (((void *)0));
1853
1854 instExpCopy->tempCount = instExp->tempCount;
1855 if(!ident)
1856 ident = MkIdentifier(thisMember->name);
1857 if(ident)
1858 {
1859 struct Expression * memberExp;
1860 unsigned int freeMemberExp = 0;
1861
1862 if(thisMember && thisMember->isProperty && ((struct __ecereNameSpace__ecere__com__Property *)thisMember)->conversion)
1863 convert = 1;
1864 if(member->identifiers && (*member->identifiers).count > 1)
1865 {
1866 struct Identifier * id = (*member->identifiers).first;
1867
1868 memberExp = MkExpMember(instExpCopy, id);
1869 for(id = id->next; id; id = id->next)
1870 memberExp = MkExpMember(memberExp, id);
1871 }
1872 else
1873 memberExp = MkExpMember(instExpCopy, ident);
1874 if(member->initializer && member->initializer->type == 0 && member->initializer->__anon1.exp)
1875 {
1876 member->initializer->__anon1.exp->usage = (member->initializer->__anon1.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
1877 setExp = MkExpOp(memberExp, '=', member->initializer->__anon1.exp);
1878 member->initializer->__anon1.exp = (((void *)0));
1879 FreeInitializer(member->initializer);
1880 member->initializer = (((void *)0));
1881 }
1882 else
1883 {
1884 freeMemberExp = 1;
1885 }
1886 memberExp->loc = inst->loc;
1887 if(member->identifiers)
1888 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear((&*member->identifiers));
1889 if(setExp)
1890 setExp->loc = inst->loc;
1891 FreeType(instExpCopy->expType);
1892 instExpCopy->expType = instExp->expType;
1893 if(instExp->expType)
1894 instExp->expType->refCount++;
1895 if(setExp)
1896 {
1897 ProcessExpressionType(setExp);
1898 ProcessExpression(setExp);
1899 ListAdd(list, setExp);
1900 }
1901 if(freeMemberExp)
1902 FreeExpression(memberExp);
1903 }
1904 }
1905 }
1906 }
1907 }
1908 }
1909 }
1910 return fullSet || convert;
1911 }
1912
1913 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
1914
1915 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
1916
1917 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
1918
1919 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
1920
1921 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
1922
1923 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
1924
1925 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
1926
1927 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__LinkList;
1928
1929 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TopoEdge;
1930
1931 struct __ecereNameSpace__ecere__com__Module
1932 {
1933 struct __ecereNameSpace__ecere__com__Instance * application;
1934 struct __ecereNameSpace__ecere__sys__OldList classes;
1935 struct __ecereNameSpace__ecere__sys__OldList defines;
1936 struct __ecereNameSpace__ecere__sys__OldList functions;
1937 struct __ecereNameSpace__ecere__sys__OldList modules;
1938 struct __ecereNameSpace__ecere__com__Instance * prev;
1939 struct __ecereNameSpace__ecere__com__Instance * next;
1940 const char *  name;
1941 void *  library;
1942 void *  Unload;
1943 int importType;
1944 int origImportType;
1945 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
1946 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
1947 } ecere_gcc_struct;
1948
1949 static void CreateInstancesBody()
1950 {
1951 if(inCompiler && !createInstancesBody)
1952 {
1953 char registerName[1024], moduleName[274];
1954 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1955 struct Declarator * declarator;
1956
1957 createInstancesBody = MkCompoundStmt((((void *)0)), MkList());
1958 createInstancesBody->__anon1.compound.context = __extension__ ({
1959 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1960
1961 __ecereInstance1->parent = globalContext, __ecereInstance1;
1962 });
1963 specifiers = MkList();
1964 ListAdd(specifiers, MkSpecifier(VOID));
1965 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1966 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1967 FixModuleName(moduleName);
1968 sprintf(registerName, "__ecereCreateModuleInstances_%s", moduleName);
1969 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), (((void *)0)));
1970 {
1971 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0);
1972
1973 ProcessFunctionBody(function, createInstancesBody);
1974 ListAdd(ast, createInstancesExternal = MkExternalFunction(function));
1975 }
1976 destroyInstancesBody = MkCompoundStmt((((void *)0)), MkList());
1977 destroyInstancesBody->__anon1.compound.context = __extension__ ({
1978 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1979
1980 __ecereInstance1->parent = globalContext, __ecereInstance1;
1981 });
1982 specifiers = MkList();
1983 ListAdd(specifiers, MkSpecifier(VOID));
1984 sprintf(registerName, "__ecereDestroyModuleInstances_%s", moduleName);
1985 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), (((void *)0)));
1986 {
1987 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0);
1988
1989 ProcessFunctionBody(function, destroyInstancesBody);
1990 ListAdd(ast, destroyInstancesExternal = MkExternalFunction(function));
1991 }
1992 }
1993 }
1994
1995 void DeclareClass(struct External * neededFor, struct Symbol * classSym, const char * className)
1996 {
1997 if(classSym && classSym->notYetDeclared)
1998 {
1999 if(!classSym->mustRegister)
2000 {
2001 if(!classSym->_import)
2002 {
2003 if(!classSym->module)
2004 classSym->module = mainModule;
2005 if(!classSym->module)
2006 return ;
2007 classSym->_import = __extension__ ({
2008 struct ClassImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassImport);
2009
2010 __ecereInstance1->isRemote = classSym->__anon1.registered ? classSym->__anon1.registered->isRemote : 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(classSym->string), __ecereInstance1;
2011 });
2012 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classSym->module->classes, classSym->_import);
2013 }
2014 classSym->_import->itself = 1;
2015 }
2016 classSym->notYetDeclared = 0;
2017 if(!classSym->__anon2.__anon1.pointerExternal && inCompiler)
2018 {
2019 struct Declaration * decl;
2020 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
2021 struct Declarator * d;
2022
2023 specifiers = MkList();
2024 declarators = MkList();
2025 ListAdd(specifiers, MkSpecifier(EXTERN));
2026 ListAdd(specifiers, MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0))));
2027 d = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier(className)));
2028 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
2029 decl = MkDeclaration(specifiers, declarators);
2030 classSym->__anon2.__anon1.pointerExternal = MkExternalDeclaration(decl);
2031 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ast), classSym->__anon2.__anon1.pointerExternal);
2032 DeclareStruct(classSym->__anon2.__anon1.pointerExternal, "ecere::com::Class", 0, 1);
2033 }
2034 }
2035 if(inCompiler && classSym && classSym->__anon2.__anon1.pointerExternal && neededFor)
2036 __ecereMethod_External_CreateUniqueEdge(neededFor, classSym->__anon2.__anon1.pointerExternal, 0);
2037 }
2038
2039 void __ecereUnregisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
2040 {
2041
2042 }
2043
2044 static void ProcessStatement(struct Statement *  stmt);
2045
2046 static void ProcessFunction(struct FunctionDefinition * function)
2047 {
2048 if(function->body)
2049 {
2050 yylloc = function->loc;
2051 ProcessStatement(function->body);
2052 }
2053 }
2054
2055 static void ProcessInstantiation(struct Instantiation * inst)
2056 {
2057 if(inst->members && (*inst->members).first)
2058 {
2059 struct MembersInit * members;
2060
2061 for(members = (*inst->members).first; members; members = members->next)
2062 {
2063 if(members->type == 0)
2064 {
2065 if(members->__anon1.dataMembers)
2066 {
2067 struct MemberInit * member;
2068
2069 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
2070 ProcessMemberInitData(member);
2071 }
2072 }
2073 else if(members->type == 1)
2074 {
2075 ProcessFunction((struct FunctionDefinition *)members->__anon1.function);
2076 }
2077 }
2078 }
2079 }
2080
2081 static void ProcessDeclaration(struct Declaration *  decl);
2082
2083 static void ProcessStatement(struct Statement * stmt)
2084 {
2085 yylloc = stmt->loc;
2086 switch(stmt->type)
2087 {
2088 case 0:
2089 if(stmt->__anon1.labeled.stmt)
2090 ProcessStatement(stmt->__anon1.labeled.stmt);
2091 break;
2092 case 1:
2093 if(stmt->__anon1.caseStmt.exp)
2094 ProcessExpression(stmt->__anon1.caseStmt.exp);
2095 if(stmt->__anon1.caseStmt.stmt)
2096 ProcessStatement(stmt->__anon1.caseStmt.stmt);
2097 break;
2098 case 2:
2099 {
2100 if(stmt->__anon1.compound.context)
2101 {
2102 struct Declaration * decl;
2103 struct Statement * s;
2104 struct Statement * prevCompound = curCompound;
2105 struct Context * prevContext = curContext;
2106
2107 if(!stmt->__anon1.compound.isSwitch)
2108 {
2109 curCompound = stmt;
2110 curContext = stmt->__anon1.compound.context;
2111 }
2112 if(stmt->__anon1.compound.declarations)
2113 {
2114 for(decl = (*stmt->__anon1.compound.declarations).first; decl; decl = decl->next)
2115 ProcessDeclaration(decl);
2116 }
2117 if(stmt->__anon1.compound.statements)
2118 {
2119 for(s = (*stmt->__anon1.compound.statements).first; s; s = s->next)
2120 {
2121 ProcessStatement(s);
2122 }
2123 }
2124 curCompound = prevCompound;
2125 curContext = prevContext;
2126 }
2127 break;
2128 }
2129 case 3:
2130 {
2131 struct Expression * exp;
2132
2133 if(stmt->__anon1.expressions)
2134 {
2135 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
2136 {
2137 ProcessExpression(exp);
2138 }
2139 }
2140 break;
2141 }
2142 case 4:
2143 {
2144 struct Expression * exp;
2145
2146 ((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2147 for(exp = (*stmt->__anon1.ifStmt.exp).first; exp; exp = exp->next)
2148 {
2149 ProcessExpression(exp);
2150 }
2151 if(stmt->__anon1.ifStmt.stmt)
2152 ProcessStatement(stmt->__anon1.ifStmt.stmt);
2153 if(stmt->__anon1.ifStmt.elseStmt)
2154 ProcessStatement(stmt->__anon1.ifStmt.elseStmt);
2155 break;
2156 }
2157 case 5:
2158 {
2159 struct Expression * exp;
2160
2161 ((struct Expression *)(*stmt->__anon1.switchStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.switchStmt.exp).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2162 for(exp = (*stmt->__anon1.switchStmt.exp).first; exp; exp = exp->next)
2163 ProcessExpression(exp);
2164 ProcessStatement(stmt->__anon1.switchStmt.stmt);
2165 break;
2166 }
2167 case 6:
2168 {
2169 if(stmt->__anon1.whileStmt.exp)
2170 {
2171 struct Expression * exp;
2172
2173 ((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2174 for(exp = (*stmt->__anon1.whileStmt.exp).first; exp; exp = exp->next)
2175 {
2176 ProcessExpression(exp);
2177 }
2178 }
2179 if(stmt->__anon1.whileStmt.stmt)
2180 ProcessStatement(stmt->__anon1.whileStmt.stmt);
2181 break;
2182 }
2183 case 7:
2184 {
2185 if(stmt->__anon1.doWhile.exp)
2186 {
2187 struct Expression * exp;
2188
2189 ((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2190 for(exp = (*stmt->__anon1.doWhile.exp).first; exp; exp = exp->next)
2191 {
2192 ProcessExpression(exp);
2193 }
2194 }
2195 if(stmt->__anon1.doWhile.stmt)
2196 ProcessStatement(stmt->__anon1.doWhile.stmt);
2197 break;
2198 }
2199 case 8:
2200 {
2201 struct Expression * exp;
2202
2203 if(stmt->__anon1.forStmt.init)
2204 ProcessStatement(stmt->__anon1.forStmt.init);
2205 if(stmt->__anon1.forStmt.check && stmt->__anon1.forStmt.check->__anon1.expressions)
2206 {
2207 ((struct Expression *)(*stmt->__anon1.forStmt.check->__anon1.expressions).last)->usage = (((struct Expression *)(*stmt->__anon1.forStmt.check->__anon1.expressions).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2208 }
2209 if(stmt->__anon1.forStmt.check)
2210 ProcessStatement(stmt->__anon1.forStmt.check);
2211 if(stmt->__anon1.forStmt.increment)
2212 {
2213 for(exp = (*stmt->__anon1.forStmt.increment).first; exp; exp = exp->next)
2214 ProcessExpression(exp);
2215 }
2216 if(stmt->__anon1.forStmt.stmt)
2217 ProcessStatement(stmt->__anon1.forStmt.stmt);
2218 break;
2219 }
2220 case 9:
2221 break;
2222 case 10:
2223 break;
2224 case 11:
2225 break;
2226 case 12:
2227 {
2228 struct Expression * exp;
2229
2230 if(stmt->__anon1.expressions && (*stmt->__anon1.expressions).last)
2231 {
2232 ((struct Expression *)(*stmt->__anon1.expressions).last)->usage = (((struct Expression *)(*stmt->__anon1.expressions).last)->usage & ~0x1) | (((unsigned int)(1)) << 0);
2233 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
2234 {
2235 ProcessExpression(exp);
2236 }
2237 }
2238 break;
2239 }
2240 case 14:
2241 {
2242 ProcessDeclaration(stmt->__anon1.decl);
2243 break;
2244 }
2245 case 13:
2246 {
2247 struct AsmField * field;
2248
2249 if(stmt->__anon1.asmStmt.inputFields)
2250 {
2251 for(field = (*stmt->__anon1.asmStmt.inputFields).first; field; field = field->next)
2252 if(field->expression)
2253 ProcessExpression(field->expression);
2254 }
2255 if(stmt->__anon1.asmStmt.outputFields)
2256 {
2257 for(field = (*stmt->__anon1.asmStmt.outputFields).first; field; field = field->next)
2258 if(field->expression)
2259 ProcessExpression(field->expression);
2260 }
2261 if(stmt->__anon1.asmStmt.clobberedFields)
2262 {
2263 for(field = (*stmt->__anon1.asmStmt.clobberedFields).first; field; field = field->next)
2264 if(field->expression)
2265 ProcessExpression(field->expression);
2266 }
2267 break;
2268 }
2269 }
2270 }
2271
2272 struct ClassDef;
2273
2274 typedef union YYSTYPE
2275 {
2276 int specifierType;
2277 int i;
2278 int declMode;
2279 struct Identifier * id;
2280 struct Expression * exp;
2281 struct Specifier * specifier;
2282 struct __ecereNameSpace__ecere__sys__OldList * list;
2283 struct Enumerator * enumerator;
2284 struct Declarator * declarator;
2285 struct Pointer * pointer;
2286 struct Initializer * initializer;
2287 struct InitDeclarator * initDeclarator;
2288 struct TypeName * typeName;
2289 struct Declaration * declaration;
2290 struct Statement * stmt;
2291 struct FunctionDefinition * function;
2292 struct External * external;
2293 struct Context * context;
2294 struct AsmField * asmField;
2295 struct Attrib * attrib;
2296 struct ExtDecl * extDecl;
2297 struct Attribute * attribute;
2298 struct Instantiation * instance;
2299 struct MembersInit * membersInit;
2300 struct MemberInit * memberInit;
2301 struct ClassFunction * classFunction;
2302 struct ClassDefinition * _class;
2303 struct ClassDef * classDef;
2304 struct PropertyDef * prop;
2305 char * string;
2306 struct Symbol * symbol;
2307 struct PropertyWatch * propertyWatch;
2308 struct TemplateParameter * templateParameter;
2309 struct TemplateArgument * templateArgument;
2310 struct TemplateDatatype * templateDatatype;
2311 struct DBTableEntry * dbtableEntry;
2312 struct DBIndexItem * dbindexItem;
2313 struct DBTableDef * dbtableDef;
2314 } ecere_gcc_struct YYSTYPE;
2315
2316 extern YYSTYPE yylval;
2317
2318 struct ClassDef
2319 {
2320 struct ClassDef * prev;
2321 struct ClassDef * next;
2322 struct Location loc;
2323 int type;
2324 union
2325 {
2326 struct Declaration * decl;
2327 struct ClassFunction * function;
2328 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
2329 struct PropertyDef * propertyDef;
2330 struct PropertyWatch * propertyWatch;
2331 char *  designer;
2332 struct Identifier * defaultProperty;
2333 struct
2334 {
2335 struct Identifier * id;
2336 struct Initializer * initializer;
2337 } ecere_gcc_struct __anon1;
2338 } ecere_gcc_struct __anon1;
2339 int memberAccess;
2340 void *  object;
2341 } ecere_gcc_struct;
2342
2343 static void ProcessSpecifier(struct Specifier * spec)
2344 {
2345 switch(spec->type)
2346 {
2347 case 0:
2348 break;
2349 case 1:
2350 {
2351 break;
2352 }
2353 case 2:
2354 {
2355 struct Enumerator * e;
2356
2357 if(spec->__anon1.__anon2.list)
2358 {
2359 for(e = (*spec->__anon1.__anon2.list).first; e; e = e->next)
2360 {
2361 if(e->exp)
2362 ProcessExpression(e->exp);
2363 }
2364 }
2365 break;
2366 }
2367 case 3:
2368 case 4:
2369 {
2370 if(spec->__anon1.__anon2.definitions)
2371 {
2372 struct ClassDef * def;
2373
2374 for(def = (*spec->__anon1.__anon2.definitions).first; def; def = def->next)
2375 {
2376 if(def->type == 2 && def->__anon1.decl && def->__anon1.decl->type == 0)
2377 ProcessDeclaration(def->__anon1.decl);
2378 }
2379 }
2380 break;
2381 }
2382 }
2383 }
2384
2385 void ProcessInstantiations()
2386 {
2387 struct External * external;
2388
2389 for(external = (*ast).first; external; external = external->next)
2390 {
2391 curExternal = external;
2392 if(external->type == 1)
2393 {
2394 if(external->__anon1.declaration)
2395 {
2396 unsigned int isInstance = external->__anon1.declaration->type == 2;
2397 struct Symbol * sym = isInstance ? FindClass(external->__anon1.declaration->__anon1.inst->_class->__anon1.__anon1.name) : (((void *)0));
2398
2399 ProcessDeclaration(external->__anon1.declaration);
2400 if(isInstance)
2401 {
2402 struct TopoEdge * e, * next;
2403
2404 for(e = ((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)external->incoming + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->first; e; e = next)
2405 {
2406 struct External * from = e->from;
2407
2408 next = e->in.next;
2409 if(((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)from->incoming + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->count)
2410 {
2411 unsigned int reroute = 1;
2412
2413 if(sym && sym->__anon1.registered && sym->__anon1.registered->type == 1)
2414 reroute = 0;
2415 else if(from->type == 1 && from->__anon1.declaration && (!from->__anon1.declaration->__anon1.__anon1.declarators || !(*from->__anon1.declaration->__anon1.__anon1.declarators).count) && from->__anon1.declaration->__anon1.__anon1.specifiers)
2416 {
2417 struct Specifier * spec = (((void *)0));
2418
2419 for(spec = (*from->__anon1.declaration->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
2420 {
2421 if(spec->type == 3 || spec->type == 4)
2422 break;
2423 }
2424 if(sym->__anon1.registered && spec && spec->__anon1.__anon2.id && spec->__anon1.__anon2.id->string)
2425 {
2426 char className[1024];
2427 struct __ecereNameSpace__ecere__com__Class * c = sym->__anon1.registered;
2428
2429 strcpy(className, "__ecereClass_");
2430 if(c->type == 5 && c->templateClass)
2431 FullClassNameCat(className, c->templateClass->name, 1);
2432 else
2433 FullClassNameCat(className, c->name, 1);
2434 if(!strcmp(c->name, spec->__anon1.__anon2.id->string))
2435 reroute = 0;
2436 }
2437 }
2438 if(reroute)
2439 {
2440 unsigned int skip = 0;
2441
2442 e->to = createInstancesExternal;
2443 ((void (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it))__extension__ ({
2444 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = external->incoming;
2445
2446 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl;
2447 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove])(external->incoming, (struct __ecereNameSpace__ecere__com__IteratorPointer *)e);
2448 {
2449 struct TopoEdge * i;
2450 struct __ecereNameSpace__ecere__com__Instance * __internalLinkList = createInstancesExternal->incoming;
2451
2452 for(i = ((struct __ecereNameSpace__ecere__com__LinkList *)(((char *)__internalLinkList + 0 + sizeof(struct __ecereNameSpace__ecere__com__Instance))))->first; i; i = (struct TopoEdge *)((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * pointer))__extension__ ({
2453 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = __internalLinkList;
2454
2455 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl;
2456 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_GetNext])(__internalLinkList, (struct __ecereNameSpace__ecere__com__IteratorPointer *)i))
2457 {
2458 if(i->from == from)
2459 {
2460 skip = 1;
2461 if(i->breakable && !e->breakable)
2462 {
2463 i->breakable = 1;
2464 createInstancesExternal->nonBreakableIncoming++;
2465 }
2466 break;
2467 }
2468 }
2469 }
2470 if(skip)
2471 {
2472 external->nonBreakableIncoming--;
2473 ((void (*)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__IteratorPointer * it))__extension__ ({
2474 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = e->from->outgoing;
2475
2476 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl;
2477 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Remove])(e->from->outgoing, (struct __ecereNameSpace__ecere__com__IteratorPointer *)e);
2478 ((e ? (__ecereClass_TopoEdge->Destructor ? __ecereClass_TopoEdge->Destructor((void *)e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
2479 }
2480 else
2481 {
2482 ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value))__extension__ ({
2483 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = createInstancesExternal->incoming;
2484
2485 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__LinkList->_vTbl;
2486 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Add])(createInstancesExternal->incoming, (uint64)(uintptr_t)(e));
2487 if(!e->breakable)
2488 {
2489 external->nonBreakableIncoming--;
2490 createInstancesExternal->nonBreakableIncoming++;
2491 }
2492 }
2493 }
2494 }
2495 }
2496 }
2497 }
2498 }
2499 else if(external->type == 0)
2500 {
2501 ProcessFunction(external->__anon1.function);
2502 }
2503 else if(external->type == 2)
2504 {
2505 struct ClassDefinition * _class = external->__anon1._class;
2506
2507 if(_class->definitions)
2508 {
2509 struct ClassDef * def;
2510
2511 for(def = (*_class->definitions).first; def; def = def->next)
2512 {
2513 if(def->type == 0)
2514 {
2515 curExternal = def->__anon1.function->declarator ? def->__anon1.function->declarator->symbol->__anon2.__anon1.pointerExternal : external;
2516 ProcessFunction((struct FunctionDefinition *)def->__anon1.function);
2517 }
2518 else if(def->type == 2 && def->__anon1.decl->type == 2)
2519 {
2520 ProcessInstantiation(def->__anon1.decl->__anon1.inst);
2521 }
2522 else if(def->type == 1 && def->__anon1.defProperties)
2523 {
2524 struct MemberInit * defProperty;
2525 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
2526
2527 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2528 for(defProperty = (*def->__anon1.defProperties).first; defProperty; defProperty = defProperty->next)
2529 {
2530 ProcessMemberInitData(defProperty);
2531 }
2532 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2533 FreeSymbol(thisSymbol);
2534 }
2535 else if(def->type == 3 && def->__anon1.propertyDef)
2536 {
2537 struct PropertyDef * prop = def->__anon1.propertyDef;
2538 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
2539
2540 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2541 if(prop->setStmt)
2542 {
2543 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalSet : (((void *)0));
2544 ProcessStatement(prop->setStmt);
2545 }
2546 if(prop->getStmt)
2547 {
2548 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalGet : (((void *)0));
2549 ProcessStatement(prop->getStmt);
2550 }
2551 if(prop->issetStmt)
2552 {
2553 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalIsSet : (((void *)0));
2554 ProcessStatement(prop->issetStmt);
2555 }
2556 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2557 FreeSymbol(thisSymbol);
2558 }
2559 else if(def->type == 4 && def->__anon1.propertyWatch)
2560 {
2561 struct PropertyWatch * propertyWatch = def->__anon1.propertyWatch;
2562 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
2563
2564 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2565 if(propertyWatch->compound)
2566 {
2567 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&propertyWatch->compound->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2568 curExternal = (((void *)0));
2569 ProcessStatement(propertyWatch->compound);
2570 }
2571 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2572 FreeSymbol(thisSymbol);
2573 }
2574 }
2575 }
2576 }
2577 }
2578 }
2579
2580 void __ecereRegisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
2581 {
2582 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
2583
2584 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareClass", "void DeclareClass(External neededFor, Symbol classSym, const char * className)", DeclareClass, module, 1);
2585 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessExpressionInstPass", "void ProcessExpressionInstPass(Expression exp)", ProcessExpressionInstPass, module, 2);
2586 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessInstantiations", "void ProcessInstantiations(void)", ProcessInstantiations, module, 1);
2587 }
2588
2589 static unsigned int ProcessBracketInst_DataMember(struct __ecereNameSpace__ecere__com__DataMember *  parentMember, struct Instantiation *  inst, struct __ecereNameSpace__ecere__sys__OldList *  list, struct __ecereNameSpace__ecere__com__DataMember *  namedParentMember, unsigned int parentMemberSet);
2590
2591 static unsigned int ProcessBracketInst(struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * list)
2592 {
2593 static int recursionCount = 0;
2594 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
2595 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
2596 int anonID = 1;
2597
2598 if(recursionCount > 500)
2599 return 0;
2600 recursionCount++;
2601 while(_class != classSym->__anon1.registered)
2602 {
2603 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
2604 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
2605
2606 for(_class = classSym->__anon1.registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
2607 ;
2608 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
2609 {
2610 if(!dataMember->isProperty && !dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
2611 {
2612 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2613
2614 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, 0))
2615 {
2616 if(subList)
2617 FreeList(subList, (void *)(FreeInitializer));
2618 recursionCount--;
2619 return 0;
2620 }
2621 if(dataMember->type == 2 || (subList && (*subList).count))
2622 {
2623 struct Initializer * init = MkInitializerList(subList);
2624 char id[100];
2625
2626 sprintf(id, "__anon%d", anonID);
2627 init->id = MkIdentifier(id);
2628 ListAdd(list, init);
2629 }
2630 else
2631 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
2632 anonID++;
2633 }
2634 else
2635 {
2636 struct MembersInit * members;
2637 struct MemberInit * member = (((void *)0));
2638 unsigned int found = 0;
2639
2640 if(inst->members && (*inst->members).first)
2641 {
2642 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
2643 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
2644 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
2645 int subMemberStackPos = 0;
2646
2647 for(members = (*inst->members).first; members; members = members->next)
2648 {
2649 if(members->type == 0)
2650 {
2651 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
2652 {
2653 struct Identifier * firstID = member->identifiers ? (*member->identifiers).first : (((void *)0));
2654
2655 if(firstID)
2656 {
2657 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
2658 int _subMemberStackPos = 0;
2659 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule);
2660
2661 if(!thisMember)
2662 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
2663 if(thisMember)
2664 {
2665 curMember = thisMember;
2666 curClass = curMember->_class;
2667 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
2668 subMemberStackPos = _subMemberStackPos;
2669 }
2670 if(curMember == dataMember)
2671 {
2672 if(dataMember->isProperty)
2673 {
2674 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
2675 {
2676 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
2677 continue;
2678 }
2679 recursionCount--;
2680 return 0;
2681 }
2682 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
2683 {
2684 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
2685 struct Specifier * spec;
2686 struct MembersInit * nextMembers;
2687 struct MemberInit * next = member->next;
2688 struct Symbol * symbol;
2689
2690 if(!dataMember->dataType)
2691 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
2692 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
2693 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
2694 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*member->identifiers), firstID);
2695 ListAdd(partList, MkMemberInit(member->identifiers, MkInitializerAssignment(member->initializer->__anon1.exp)));
2696 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
2697 {
2698 if(!nextMembers->__anon1.dataMembers)
2699 continue;
2700 if(members != nextMembers)
2701 next = (*nextMembers->__anon1.dataMembers).first;
2702 if(nextMembers->type == 0)
2703 {
2704 struct MemberInit * nextMember;
2705
2706 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
2707 {
2708 struct Identifier * nextID = (*nextMember->identifiers).first;
2709
2710 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
2711 {
2712 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->__anon1.dataMembers), nextMember);
2713 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
2714 ListAdd(partList, nextMember);
2715 FreeIdentifier(nextID);
2716 }
2717 }
2718 }
2719 }
2720 member->initializer->__anon1.exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
2721 FreeIdentifier(firstID);
2722 member->identifiers = (((void *)0));
2723 }
2724 found = 1;
2725 break;
2726 }
2727 }
2728 else
2729 {
2730 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2731 if(curMember == dataMember)
2732 {
2733 if(dataMember->isProperty)
2734 {
2735 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
2736 {
2737 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
2738 continue;
2739 }
2740 recursionCount--;
2741 return 0;
2742 }
2743 found = 1;
2744 break;
2745 }
2746 }
2747 }
2748 }
2749 if(found)
2750 break;
2751 }
2752 }
2753 if(dataMember->isProperty)
2754 continue;
2755 if(member && member->initializer && member->initializer->type == 0)
2756 {
2757 if(member->initializer->__anon1.exp->type == 1 && member->initializer->__anon1.exp->expType && member->initializer->__anon1.exp->expType->__anon1._class && member->initializer->__anon1.exp->expType->__anon1._class->__anon1.registered && member->initializer->__anon1.exp->expType->__anon1._class->__anon1.registered->type == 1)
2758 {
2759 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2760
2761 ProcessBracketInst(member->initializer->__anon1.exp->__anon1.instance, subList);
2762 FreeExpression(member->initializer->__anon1.exp);
2763 member->initializer->__anon1.exp = (((void *)0));
2764 ListAdd(list, MkInitializerList(subList));
2765 }
2766 else
2767 {
2768 member->initializer->__anon1.exp->usage = (member->initializer->__anon1.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
2769 ProcessExpression(member->initializer->__anon1.exp);
2770 ListAdd(list, MkInitializerAssignment(CopyExpression(member->initializer->__anon1.exp)));
2771 }
2772 member->takeOutExp = 1;
2773 }
2774 else if(member && member->initializer && member->initializer->type == 1)
2775 {
2776 ListAdd(list, member->initializer);
2777 member->initializer = (((void *)0));
2778 }
2779 else if(dataMember && dataMember->dataTypeString)
2780 {
2781 struct Symbol * classSym;
2782
2783 if(!dataMember->dataType)
2784 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
2785 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
2786 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
2787 {
2788 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2789 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
2790 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2791
2792 ProcessBracketInst(inst, subList);
2793 FreeInstance(inst);
2794 ListAdd(list, MkInitializerList(subList));
2795 }
2796 else if(dataMember->dataType->kind == 12)
2797 {
2798 struct Type * t = dataMember->dataType->__anon1.type;
2799 struct Initializer * inner = MkInitializerAssignment((((void *)0))), * i = inner;
2800
2801 while(t && t->kind == 12)
2802 {
2803 i = MkInitializerList(MkListOne(i));
2804 t = t->__anon1.type;
2805 }
2806 if(t && t->kind == 8 && t->__anon1._class && t->__anon1._class->__anon1.registered && t->__anon1._class->__anon1.registered->type == 1)
2807 {
2808 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2809 struct Specifier * spec = _MkSpecifierName(t->__anon1._class->__anon1.registered->name, classSym, (((void *)0)));
2810 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2811
2812 ProcessBracketInst(inst, subList);
2813 FreeInstance(inst);
2814 inner->type = 1;
2815 inner->__anon1.list = subList;
2816 }
2817 else
2818 inner->__anon1.exp = MkExpConstant("0");
2819 ListAdd(list, MkInitializerList(MkListOne(i)));
2820 }
2821 else
2822 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
2823 }
2824 }
2825 }
2826 }
2827 if(inst->members && (*inst->members).first)
2828 {
2829 struct MembersInit * members;
2830 struct MemberInit * member = (((void *)0));
2831
2832 for(members = (*inst->members).first; members; members = members->next)
2833 {
2834 if(members->type == 0)
2835 {
2836 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
2837 {
2838 if(member->takeOutExp)
2839 {
2840 FreeInitializer(member->initializer);
2841 member->initializer = (((void *)0));
2842 }
2843 }
2844 }
2845 }
2846 }
2847 recursionCount--;
2848 return 1;
2849 }
2850
2851 static void ProcessExpression(struct Expression * exp)
2852 {
2853 switch(exp->type)
2854 {
2855 case 0:
2856 break;
2857 case 1:
2858 {
2859 struct Instantiation * inst = exp->__anon1.instance;
2860
2861 if(inCompiler && inst->_class)
2862 {
2863 char className[1024];
2864 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
2865 struct Expression * instExp;
2866
2867 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 2)
2868 {
2869 if(inst->exp)
2870 {
2871 struct __ecereNameSpace__ecere__sys__OldList list =
2872 {
2873 0
2874 };
2875
2876 ProcessInstMembers(inst, (((void *)0)), &list, 0);
2877 ProcessExpression(inst->exp);
2878 exp->type = 4;
2879 exp->__anon1.op.op = '=';
2880 exp->__anon1.op.exp1 = inst->exp;
2881 exp->__anon1.op.exp2 = list.first;
2882 inst->exp = (((void *)0));
2883 }
2884 else
2885 {
2886 struct Type * expType = exp->expType;
2887 struct Expression * prev = exp->prev, * next = exp->next;
2888 struct __ecereNameSpace__ecere__sys__OldList list =
2889 {
2890 0, 0, 0, 0, 0
2891 };
2892
2893 ProcessInstMembers(inst, (((void *)0)), &list, 0);
2894 FreeType(exp->destType);
2895 *exp = *(struct Expression *)list.first;
2896 {
2897 struct Expression * firstExp = list.first;
2898
2899 ((firstExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)firstExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(firstExp)) : 0), firstExp = 0);
2900 }
2901 FreeType(exp->destType);
2902 exp->destType = expType;
2903 exp->prev = prev;
2904 exp->next = next;
2905 }
2906 }
2907 else if(classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 3 || classSym->__anon1.registered->type == 4))
2908 {
2909 if(inst->exp)
2910 {
2911 struct __ecereNameSpace__ecere__sys__OldList list =
2912 {
2913 0
2914 };
2915 struct Expression * e;
2916
2917 ProcessInstMembers(inst, (((void *)0)), &list, 0);
2918 ProcessExpression(inst->exp);
2919 exp->type = 4;
2920 exp->__anon1.op.op = '=';
2921 exp->__anon1.op.exp1 = inst->exp;
2922 exp->__anon1.op.exp2 = list.first;
2923 inst->exp = (((void *)0));
2924 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, list.first);
2925 while((e = list.first))
2926 {
2927 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2928 FreeExpression(e);
2929 }
2930 }
2931 else
2932 {
2933 struct Expression * prev = exp->prev, * next = exp->next;
2934 struct Type * expType = exp->expType;
2935 struct __ecereNameSpace__ecere__sys__OldList list =
2936 {
2937 0
2938 };
2939
2940 ProcessInstMembers(inst, (((void *)0)), &list, 0);
2941 if(list.first)
2942 {
2943 struct Expression * e = list.first;
2944
2945 FreeType(exp->destType);
2946 *exp = *e;
2947 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2948 ((e ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
2949 exp->expType = expType;
2950 exp->prev = prev;
2951 exp->next = next;
2952 while((e = list.first))
2953 {
2954 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2955 FreeExpression(e);
2956 }
2957 }
2958 else
2959 {
2960 exp->type = 2;
2961 exp->__anon1.__anon1.constant = __ecereNameSpace__ecere__sys__CopyString("0");
2962 }
2963 }
2964 }
2965 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
2966 {
2967 if(inst->exp)
2968 {
2969 exp->type = 5;
2970 exp->__anon1.list = MkList();
2971 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 0);
2972 ProcessExpression(inst->exp);
2973 if(!(*exp->__anon1.list).count)
2974 {
2975 exp->type = 16;
2976 (__ecereNameSpace__ecere__com__eSystem_Delete(exp->__anon1.list), exp->__anon1.list = 0);
2977 }
2978 }
2979 else
2980 {
2981 struct Declaration * decl;
2982 struct Declaration * dummyDecl;
2983
2984 {
2985 dummyDecl = MkDeclaration((((void *)0)), (((void *)0)));
2986 if(!curCompound->__anon1.compound.declarations)
2987 curCompound->__anon1.compound.declarations = MkList();
2988 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->__anon1.compound.declarations), (((void *)0)), dummyDecl);
2989 sprintf(className, "__simpleStruct%d", curContext->simpleID++);
2990 {
2991 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
2992
2993 if(inst->isConstant && ProcessBracketInst(inst, list))
2994 {
2995 decl = MkDeclaration(MkList(), MkList());
2996 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
2997 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(className)), MkInitializerList(list)));
2998 exp->type = 0;
2999 exp->__anon1.__anon1.identifier = MkIdentifier(className);
3000 }
3001 else
3002 {
3003 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free((&*list), (((void *)0)));
3004 (__ecereNameSpace__ecere__com__eSystem_Delete(list), list = 0);
3005 decl = MkDeclarationInst(MkInstantiation(CopySpecifier(inst->_class), MkExpIdentifier(MkIdentifier(className)), (((void *)0))));
3006 exp->type = 5;
3007 exp->__anon1.list = MkList();
3008 instExp = QMkExpId(className);
3009 instExp->loc = exp->loc;
3010 instExp->expType = MkClassType(inst->_class->__anon1.__anon1.name);
3011 decl->__anon1.inst->fullSet = ProcessInstMembers(inst, instExp, exp->__anon1.list, 0);
3012 ListAdd(exp->__anon1.list, instExp);
3013 }
3014 }
3015 FreeType(exp->expType);
3016 exp->expType = MkClassType(inst->_class->__anon1.__anon1.name);
3017 {
3018 void * prev = dummyDecl->prev, * next = dummyDecl->next;
3019
3020 *dummyDecl = *decl;
3021 dummyDecl->prev = prev;
3022 dummyDecl->next = next;
3023 ((decl ? (__ecereClass_Declaration->Destructor ? __ecereClass_Declaration->Destructor((void *)decl) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(decl)) : 0), decl = 0);
3024 decl = dummyDecl;
3025 }
3026 ProcessDeclaration(decl);
3027 }
3028 }
3029 }
3030 else
3031 {
3032 struct Expression * newCall;
3033
3034 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && (classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->fixed : classSym->__anon1.registered->fixed))
3035 {
3036 char size[256];
3037 struct __ecereNameSpace__ecere__com__Class * c = classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass : classSym->__anon1.registered;
3038 struct Expression * e = MkExpClassSize(MkSpecifierName(c->name));
3039
3040 ProcessExpressionType(e);
3041 sprintf(size, "%d", c->structSize);
3042 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(e));
3043 newCall->byReference = 1;
3044 }
3045 else
3046 {
3047 strcpy(className, "__ecereClass_");
3048 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && classSym->__anon1.registered->templateClass)
3049 {
3050 classSym = FindClass(classSym->__anon1.registered->templateClass->fullName);
3051 FullClassNameCat(className, classSym->string, 1);
3052 }
3053 else
3054 FullClassNameCat(className, inst->_class->__anon1.__anon1.name, 1);
3055 DeclareClass(curExternal, classSym, className);
3056 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
3057 newCall->usage = exp->usage;
3058 ProcessExpressionType(newCall);
3059 if(newCall->expType && exp->expType)
3060 newCall->expType->passAsTemplate = exp->expType->passAsTemplate;
3061 newCall->byReference = 1;
3062 }
3063 if(inst->exp)
3064 {
3065 if(inst->members && (*inst->members).first)
3066 {
3067 exp->type = 5;
3068 exp->__anon1.list = MkList();
3069 if(!inst->built)
3070 {
3071 ListAdd(exp->__anon1.list, MkExpOp(inst->exp, '=', newCall));
3072 }
3073 else
3074 FreeExpression(newCall);
3075 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 0);
3076 if(inst->built)
3077 FreeExpression(inst->exp);
3078 }
3079 else
3080 {
3081 exp->type = 4;
3082 exp->__anon1.op.op = '=';
3083 exp->__anon1.op.exp1 = inst->exp;
3084 exp->__anon1.op.exp2 = newCall;
3085 ProcessExpression(inst->exp);
3086 }
3087 inst->exp = (((void *)0));
3088 }
3089 else
3090 {
3091 if(inst->members && (*inst->members).first)
3092 {
3093 int __simpleStruct0;
3094 char ecereTemp[100];
3095 struct MembersInit * members;
3096 int tempCount = exp->tempCount;
3097 struct __ecereNameSpace__ecere__sys__OldList * expList;
3098
3099 for(members = (*inst->members).first; members; members = members->next)
3100 {
3101 if(members->type == 0 && members->__anon1.dataMembers)
3102 {
3103 struct MemberInit * member;
3104
3105 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
3106 {
3107 if(member->initializer && member->initializer->type == 0)
3108 {
3109 int __simpleStruct0;
3110
3111 ProcessMemberInitData(member);
3112 tempCount = (__simpleStruct0 = member->initializer->__anon1.exp->tempCount, (tempCount > __simpleStruct0) ? tempCount : __simpleStruct0);
3113 }
3114 }
3115 }
3116 }
3117 if(curDecl)
3118 tempCount = ((tempCount > declTempCount) ? tempCount : declTempCount);
3119 tempCount++;
3120 curExternal->__anon1.function->tempCount = (__simpleStruct0 = curExternal->__anon1.function->tempCount, (__simpleStruct0 > tempCount) ? __simpleStruct0 : tempCount);
3121 sprintf(ecereTemp, "__ecereInstance%d", tempCount);
3122 exp->type = 23;
3123 exp->__anon1.compound = MkCompoundStmt((((void *)0)), (((void *)0)));
3124 exp->__anon1.compound->__anon1.compound.context = PushContext();
3125 exp->__anon1.compound->__anon1.compound.context->simpleID = exp->__anon1.compound->__anon1.compound.context->parent->simpleID;
3126 exp->__anon1.compound->__anon1.compound.declarations = MkListOne(QMkDeclaration(inst->_class->__anon1.__anon1.name, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(ecereTemp)), MkInitializerAssignment(newCall))));
3127 exp->__anon1.compound->__anon1.compound.statements = MkListOne(MkExpressionStmt((expList = MkList())));
3128 instExp = QMkExpId(ecereTemp);
3129 instExp->tempCount = tempCount;
3130 instExp->expType = MkClassType(inst->_class->__anon1.__anon1.name);
3131 instExp->byReference = 1;
3132 ProcessInstMembers(inst, instExp, expList, 0);
3133 FreeExpression(instExp);
3134 if(exp->usage)
3135 {
3136 struct Expression * tmpExp = QMkExpId(ecereTemp);
3137
3138 tmpExp->byReference = 1;
3139 ListAdd(expList, tmpExp);
3140 }
3141 exp->tempCount = tempCount;
3142 if(curDecl)
3143 declTempCount = ((declTempCount > tempCount) ? declTempCount : tempCount);
3144 PopContext(exp->__anon1.compound->__anon1.compound.context);
3145 }
3146 else
3147 {
3148 struct Expression * prev = exp->prev, * next = exp->next;
3149
3150 FreeType(newCall->destType);
3151 FreeType(newCall->expType);
3152 newCall->destType = exp->destType;
3153 newCall->expType = exp->expType;
3154 *exp = *newCall;
3155 exp->prev = prev;
3156 exp->next = next;
3157 ((newCall ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newCall) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newCall)) : 0), newCall = 0);
3158 }
3159 }
3160 }
3161 if(exp->type != 1)
3162 FreeInstance(inst);
3163 }
3164 else
3165 ProcessInstantiation(inst);
3166 break;
3167 }
3168 case 2:
3169 break;
3170 case 3:
3171 break;
3172 case 13:
3173 case 26:
3174 ProcessExpression(exp->__anon1._new.size);
3175 break;
3176 case 14:
3177 case 27:
3178 ProcessExpression(exp->__anon1._renew.size);
3179 ProcessExpression(exp->__anon1._renew.exp);
3180 break;
3181 case 4:
3182 {
3183 switch(exp->__anon1.op.op)
3184 {
3185 case '=':
3186 if(exp->__anon1.op.exp2)
3187 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(1)) << 0);
3188 if(exp->__anon1.op.exp1)
3189 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(1)) << 1);
3190 break;
3191 case MUL_ASSIGN:
3192 case DIV_ASSIGN:
3193 case MOD_ASSIGN:
3194 case ADD_ASSIGN:
3195 case SUB_ASSIGN:
3196 case LEFT_ASSIGN:
3197 case RIGHT_ASSIGN:
3198 case AND_ASSIGN:
3199 case XOR_ASSIGN:
3200 case OR_ASSIGN:
3201 if(exp->__anon1.op.exp2)
3202 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(1)) << 0);
3203 if(exp->__anon1.op.exp1)
3204 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(1)) << 1);
3205 break;
3206 case INC_OP:
3207 case DEC_OP:
3208 if(exp->__anon1.op.exp1)
3209 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(1)) << 1);
3210 case '&':
3211 if(exp->__anon1.op.exp1 && exp->__anon1.op.exp2)
3212 {
3213 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(1)) << 0);
3214 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(1)) << 0);
3215 }
3216 break;
3217 case '*':
3218 case '+':
3219 case '-':
3220 if(exp->__anon1.op.exp1)
3221 {
3222 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(1)) << 0);
3223 }
3224 case '~':
3225 case '!':
3226 if(exp->__anon1.op.exp2)
3227 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(1)) << 0);
3228 break;
3229 case '/':
3230 case '%':
3231 case LEFT_OP:
3232 case RIGHT_OP:
3233 case '<':
3234 case '>':
3235 case LE_OP:
3236 case GE_OP:
3237 case EQ_OP:
3238 case NE_OP:
3239 case '|':
3240 case '^':
3241 case AND_OP:
3242 case OR_OP:
3243 if(exp->__anon1.op.exp1)
3244 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(1)) << 0);
3245 if(exp->__anon1.op.exp2)
3246 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(1)) << 0);
3247 break;
3248 }
3249 if(exp->__anon1.op.exp1)
3250 {
3251 if(exp->__anon1.op.exp1 && exp->__anon1.op.exp2 && exp->__anon1.op.exp1->destType && exp->__anon1.op.exp1->destType->passAsTemplate && exp->__anon1.op.exp1->expType && !exp->__anon1.op.exp1->expType->passAsTemplate && !((unsigned int)((exp->__anon1.op.exp1->usage & 0x2) >> 1)))
3252 {
3253 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
3254
3255 CopyTypeInto(type, exp->__anon1.op.exp1->destType);
3256 type->passAsTemplate = 0;
3257 FreeType(exp->__anon1.op.exp1->destType);
3258 exp->__anon1.op.exp1->destType = type;
3259 }
3260 ProcessExpression(exp->__anon1.op.exp1);
3261 }
3262 if(exp->__anon1.op.exp2)
3263 {
3264 if(exp->__anon1.op.exp1 && exp->__anon1.op.exp2 && exp->__anon1.op.exp2->destType && exp->__anon1.op.exp2->destType->passAsTemplate && exp->__anon1.op.exp2->expType && !exp->__anon1.op.exp2->expType->passAsTemplate && !((unsigned int)((exp->__anon1.op.exp1->usage & 0x2) >> 1)))
3265 {
3266 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
3267
3268 CopyTypeInto(type, exp->__anon1.op.exp2->destType);
3269 type->passAsTemplate = 0;
3270 FreeType(exp->__anon1.op.exp2->destType);
3271 exp->__anon1.op.exp2->destType = type;
3272 }
3273 if(exp->__anon1.op.exp1)
3274 exp->__anon1.op.exp2->tempCount = exp->__anon1.op.exp1->tempCount;
3275 ProcessExpression(exp->__anon1.op.exp2);
3276 }
3277 break;
3278 }
3279 case 32:
3280 case 5:
3281 {
3282 struct Expression * e;
3283
3284 for(e = (*exp->__anon1.list).first; e; e = e->next)
3285 {
3286 int __simpleStruct2, __simpleStruct3;
3287 int __simpleStruct0, __simpleStruct1;
3288
3289 e->tempCount = (__simpleStruct0 = e->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
3290 if(!e->next)
3291 {
3292 e->usage |= (exp->usage & ((((unsigned int)(1)) | (((unsigned int)(1)) << 2))));
3293 }
3294 ProcessExpression(e);
3295 exp->tempCount = (__simpleStruct2 = exp->tempCount, __simpleStruct3 = e->tempCount, (__simpleStruct2 > __simpleStruct3) ? __simpleStruct2 : __simpleStruct3);
3296 }
3297 break;
3298 }
3299 case 6:
3300 {
3301 struct Expression * e;
3302
3303 exp->__anon1.index.exp->usage = (exp->__anon1.index.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
3304 ProcessExpression(exp->__anon1.index.exp);
3305 for(e = (*exp->__anon1.index.index).first; e; e = e->next)
3306 {
3307 if(!e->next)
3308 e->usage = (e->usage & ~0x1) | (((unsigned int)(1)) << 0);
3309 ProcessExpression(e);
3310 }
3311 exp->tempCount = exp->__anon1.index.exp->tempCount;
3312 break;
3313 }
3314 case 7:
3315 {
3316 struct Expression * e;
3317
3318 ProcessExpression(exp->__anon1.call.exp);
3319 if(exp->__anon1.call.arguments)
3320 {
3321 for(e = (*exp->__anon1.call.arguments).first; e; e = e->next)
3322 {
3323 e->usage = (e->usage & ~0x1) | (((unsigned int)(1)) << 0);
3324 e->usage = (e->usage & ~0x4) | (((unsigned int)(1)) << 2);
3325 ProcessExpression(e);
3326 }
3327 }
3328 break;
3329 }
3330 case 8:
3331 {
3332 exp->__anon1.member.exp->usage = (exp->__anon1.member.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
3333 if(exp->__anon1.member.memberType == 3 && exp->__anon1.member.exp->expType && exp->__anon1.member.exp->expType->thisClassFrom && exp->__anon1.member.exp->expType->kind == 8 && exp->__anon1.member.exp->expType->__anon1._class && exp->__anon1.member.exp->expType->__anon1._class->__anon1.registered && !__ecereNameSpace__ecere__com__eClass_IsDerived(exp->__anon1.member.exp->expType->thisClassFrom, exp->__anon1.member.exp->expType->__anon1._class->__anon1.registered))
3334 exp->__anon1.member.exp->expType->passAsTemplate = 1;
3335 ProcessExpression(exp->__anon1.member.exp);
3336 if(!exp->__anon1.member.memberType)
3337 {
3338 struct Type * type = exp->__anon1.member.exp->expType;
3339
3340 if((type && type->kind == 8 && exp->__anon1.member.member))
3341 {
3342 struct __ecereNameSpace__ecere__com__Class * _class = (exp->__anon1.member.member->_class && exp->__anon1.member.member->classSym) ? exp->__anon1.member.member->classSym->__anon1.registered : (type->__anon1._class ? type->__anon1._class->__anon1.registered : (((void *)0)));
3343 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
3344 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
3345 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
3346 struct __ecereNameSpace__ecere__com__Property * revConvert = (((void *)0));
3347
3348 if(exp->__anon1.member.thisPtr)
3349 {
3350 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, privateModule, (((void *)0)), (((void *)0)));
3351 if(!member)
3352 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, privateModule);
3353 }
3354 else
3355 {
3356 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, (((void *)0)));
3357 if(!prop)
3358 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, (((void *)0)), (((void *)0)), (((void *)0)));
3359 if(!prop && !member)
3360 {
3361 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->__anon1.member.member->string, (((void *)0)));
3362 if(!method)
3363 {
3364 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, privateModule);
3365 if(!prop)
3366 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, privateModule, (((void *)0)), (((void *)0)));
3367 }
3368 }
3369 }
3370 if(!prop && !member && !method)
3371 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->__anon1.member.member->string, privateModule);
3372 if(!prop && !member && !method)
3373 {
3374 struct Symbol * classSym = FindClass(exp->__anon1.member.member->string);
3375
3376 if(classSym)
3377 {
3378 struct __ecereNameSpace__ecere__com__Class * convertClass = classSym->__anon1.registered;
3379
3380 if(convertClass)
3381 revConvert = __ecereNameSpace__ecere__com__eClass_FindProperty(convertClass, _class->fullName, privateModule);
3382 }
3383 }
3384 if(prop)
3385 {
3386 exp->__anon1.member.memberType = 1;
3387 if(!prop->dataType)
3388 prop->dataType = ProcessTypeString(prop->dataTypeString, 0);
3389 FreeType(exp->expType);
3390 exp->expType = prop->dataType;
3391 if(prop->dataType)
3392 prop->dataType->refCount++;
3393 }
3394 else if(method)
3395 {
3396 exp->__anon1.member.memberType = 2;
3397 if(!method->dataType)
3398 ProcessMethodType(method);
3399 FreeType(exp->expType);
3400 exp->expType = method->dataType;
3401 if(method->dataType)
3402 method->dataType->refCount++;
3403 }
3404 else if(member)
3405 {
3406 exp->__anon1.member.memberType = 3;
3407 DeclareStruct(curExternal, _class->fullName, 0, 1);
3408 if(!member->dataType)
3409 member->dataType = ProcessTypeString(member->dataTypeString, 0);
3410 FreeType(exp->expType);
3411 exp->expType = member->dataType;
3412 if(member->dataType)
3413 member->dataType->refCount++;
3414 }
3415 else if(revConvert)
3416 {
3417 exp->__anon1.member.memberType = 4;
3418 FreeType(exp->expType);
3419 exp->expType = MkClassType(revConvert->_class->fullName);
3420 }
3421 }
3422 }
3423 break;
3424 }
3425 case 10:
3426 break;
3427 case 11:
3428 {
3429 exp->__anon1.cast.exp->usage |= exp->usage;
3430 ProcessExpression(exp->__anon1.cast.exp);
3431 break;
3432 }
3433 case 12:
3434 {
3435 struct Expression * e;
3436
3437 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3438 exp->__anon1.cond.cond->usage = (exp->__anon1.cond.cond->usage & ~0x1) | (((unsigned int)(1)) << 0);
3439 ProcessExpression(exp->__anon1.cond.cond);
3440 for(e = (*exp->__anon1.cond.exp).first; e; e = e->next)
3441 {
3442 if(!e->next && ((unsigned int)((exp->usage & 0x1) >> 0)))
3443 e->usage = (e->usage & ~0x1) | (((unsigned int)(1)) << 0);
3444 ProcessExpression(e);
3445 }
3446 if(exp->__anon1.cond.elseExp)
3447 {
3448 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3449 exp->__anon1.cond.elseExp->usage = (exp->__anon1.cond.elseExp->usage & ~0x1) | (((unsigned int)(1)) << 0);
3450 ProcessExpression(exp->__anon1.cond.elseExp);
3451 }
3452 break;
3453 }
3454 case 23:
3455 {
3456 if(exp->__anon1.compound->__anon1.compound.statements && ((struct Statement *)(*exp->__anon1.compound->__anon1.compound.statements).last)->type == 3 && ((struct Statement *)(*exp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions && (*((struct Statement *)(*exp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last)
3457 {
3458 ((struct Expression *)(*((struct Statement *)(*exp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last)->usage = exp->usage;
3459 }
3460 ProcessStatement(exp->__anon1.compound);
3461 break;
3462 }
3463 case 34:
3464 {
3465 ProcessExpression(exp->__anon1.vaArg.exp);
3466 break;
3467 }
3468 case 33:
3469 {
3470 ProcessInitializer(exp->__anon1.initializer.initializer);
3471 break;
3472 }
3473 }
3474 CheckTemplateTypes(exp);
3475 }
3476
3477 static unsigned int ProcessBracketInst_DataMember(struct __ecereNameSpace__ecere__com__DataMember * parentMember, struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * list, struct __ecereNameSpace__ecere__com__DataMember * namedParentMember, unsigned int parentMemberSet)
3478 {
3479 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
3480 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3481 unsigned int someMemberSet = 0;
3482 int anonID = 1;
3483
3484 for(dataMember = parentMember->members.first; dataMember; dataMember = dataMember->next)
3485 {
3486 struct MembersInit * members;
3487 struct MemberInit * member = (((void *)0));
3488
3489 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
3490 {
3491 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3492
3493 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember->name ? dataMember : namedParentMember, someMemberSet || parentMemberSet || dataMember->prev))
3494 {
3495 if(subList)
3496 FreeList(subList, (void *)(FreeInitializer));
3497 return 0;
3498 }
3499 if(subList && (*subList).count)
3500 {
3501 struct Initializer * init = MkInitializerList(subList);
3502 char id[100];
3503
3504 sprintf(id, "__anon%d", anonID);
3505 init->id = MkIdentifier(id);
3506 ListAdd(list, init);
3507 someMemberSet = 1;
3508 }
3509 else
3510 {
3511 if(list->count)
3512 someMemberSet = 1;
3513 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
3514 }
3515 anonID++;
3516 }
3517 else
3518 {
3519 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
3520 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
3521 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
3522 int subMemberStackPos = 0;
3523 unsigned int found = 0;
3524
3525 if(inst->members && (*inst->members).first)
3526 {
3527 for(members = (*inst->members).first; members; members = members->next)
3528 {
3529 if(members->type == 0)
3530 {
3531 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
3532 {
3533 if(member->identifiers)
3534 {
3535 struct Identifier * firstID = (*member->identifiers).first;
3536 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
3537 int _subMemberStackPos = 0;
3538 struct __ecereNameSpace__ecere__com__DataMember * thisMember;
3539
3540 thisMember = firstID ? (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule) : (((void *)0));
3541 if(!thisMember && firstID)
3542 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
3543 if(thisMember && thisMember->memberAccess == 1)
3544 {
3545 curMember = thisMember;
3546 curClass = curMember->_class;
3547 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
3548 subMemberStackPos = _subMemberStackPos;
3549 }
3550 if(dataMember == thisMember)
3551 {
3552 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
3553 {
3554 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
3555 struct Symbol * symbol;
3556 struct Specifier * spec;
3557 struct MembersInit * nextMembers;
3558 struct MemberInit * next = member->next;
3559
3560 if(!dataMember->dataType)
3561 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
3562 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
3563 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
3564 {
3565 struct __ecereNameSpace__ecere__sys__OldList * identifiers = MkList();
3566 struct Identifier * id;
3567
3568 for(id = ((struct Identifier *)(*member->identifiers).first)->next; id; id = id->next)
3569 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*identifiers), CopyIdentifier(id));
3570 ListAdd(partList, MkMemberInit(identifiers, MkInitializerAssignment(member->initializer->__anon1.exp)));
3571 }
3572 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
3573 {
3574 if(!nextMembers->__anon1.dataMembers)
3575 continue;
3576 if(members != nextMembers)
3577 next = (*nextMembers->__anon1.dataMembers).first;
3578 if(nextMembers->type == 0)
3579 {
3580 struct MemberInit * nextMember;
3581
3582 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
3583 {
3584 struct Identifier * nextID = (*nextMember->identifiers).first;
3585
3586 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
3587 {
3588 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->__anon1.dataMembers), nextMember);
3589 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
3590 ListAdd(partList, nextMember);
3591 FreeIdentifier(nextID);
3592 }
3593 }
3594 }
3595 }
3596 member->initializer->__anon1.exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
3597 }
3598 found = 1;
3599 break;
3600 }
3601 }
3602 else
3603 {
3604 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
3605 if(curMember == dataMember)
3606 {
3607 found = 1;
3608 break;
3609 }
3610 }
3611 }
3612 }
3613 if(found)
3614 break;
3615 }
3616 }
3617 if(member && member->initializer && member->initializer->type == 0)
3618 {
3619 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
3620
3621 if(namedParentMember->type == 1 && dataMember->name)
3622 init->id = MkIdentifier(dataMember->name);
3623 if(member->initializer->__anon1.exp->type == 1 && member->initializer->__anon1.exp->expType && member->initializer->__anon1.exp->expType->__anon1._class->__anon1.registered->type == 1)
3624 {
3625 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3626
3627 ProcessBracketInst(member->initializer->__anon1.exp->__anon1.instance, subList);
3628 FreeExpression(member->initializer->__anon1.exp);
3629 if((*subList).count)
3630 {
3631 init->type = 1;
3632 init->__anon1.list = subList;
3633 }
3634 else
3635 {
3636 FreeInitializer(init);
3637 init = (((void *)0));
3638 }
3639 }
3640 else
3641 {
3642 member->initializer->__anon1.exp->usage = (member->initializer->__anon1.exp->usage & ~0x1) | (((unsigned int)(1)) << 0);
3643 ProcessExpression(member->initializer->__anon1.exp);
3644 init->type = 0;
3645 init->__anon1.exp = member->initializer->__anon1.exp;
3646 }
3647 if(init)
3648 ListAdd(list, init);
3649 member->initializer->__anon1.exp = (((void *)0));
3650 FreeInitializer(member->initializer);
3651 member->initializer = (((void *)0));
3652 someMemberSet = 1;
3653 }
3654 else if(member && member->initializer && member->initializer->type == 1)
3655 {
3656 if(namedParentMember->type == 1 && dataMember->name)
3657 member->initializer->id = MkIdentifier(dataMember->name);
3658 ListAdd(list, member->initializer);
3659 member->initializer = (((void *)0));
3660 someMemberSet = 1;
3661 }
3662 else if(dataMember && dataMember->dataTypeString && parentMember->type != 1 && namedParentMember->type != 1)
3663 {
3664 struct Symbol * classSym;
3665 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
3666
3667 if(namedParentMember->type == 1 && dataMember->name)
3668 init->id = MkIdentifier(dataMember->name);
3669 if(!dataMember->dataType)
3670 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
3671 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
3672 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3673 {
3674 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3675 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
3676 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
3677
3678 ProcessBracketInst(inst, subList);
3679 FreeInstance(inst);
3680 if((*subList).count)
3681 {
3682 init->type = 1;
3683 init->__anon1.list = subList;
3684 }
3685 else
3686 {
3687 FreeInitializer(init);
3688 init = (((void *)0));
3689 }
3690 }
3691 else
3692 {
3693 init->type = 0;
3694 init->__anon1.exp = MkExpConstant("0");
3695 }
3696 someMemberSet = 1;
3697 if(init)
3698 ListAdd(list, init);
3699 }
3700 }
3701 }
3702 if(!someMemberSet && !parentMemberSet)
3703 {
3704 struct Symbol * classSym;
3705 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
3706
3707 dataMember = parentMember->members.first;
3708 if(namedParentMember->type == 1 && dataMember->name)
3709 init->id = MkIdentifier(dataMember->name);
3710 if(!dataMember->dataType && dataMember->dataTypeString)
3711 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
3712 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
3713 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3714 {
3715 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3716 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
3717 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
3718
3719 ProcessBracketInst(inst, subList);
3720 FreeInstance(inst);
3721 init->type = 1;
3722 init->__anon1.list = subList;
3723 }
3724 else if(dataMember->dataType && (dataMember->dataType->kind == 12 || dataMember->dataType->kind == 9))
3725 {
3726 struct Type * t = dataMember->dataType->kind == 12 ? dataMember->dataType->__anon1.type : dataMember->dataType->__anon1.__anon1.members.first;
3727 struct Initializer * i = MkInitializerAssignment(MkExpConstant("0"));
3728
3729 while(t && (t->kind == 12 || t->kind == 9))
3730 {
3731 i = MkInitializerList(MkListOne(i));
3732 if(t->kind == 12)
3733 t = t->__anon1.type;
3734 else if(t->kind == 9)
3735 t = t->__anon1.__anon1.members.first;
3736 }
3737 init->type = 1;
3738 init->__anon1.list = MkListOne(i);
3739 }
3740 else
3741 {
3742 init->type = 0;
3743 init->__anon1.exp = MkExpConstant("0");
3744 }
3745 ListAdd(list, init);
3746 }
3747 return 1;
3748 }
3749
3750 static void ProcessDeclaration(struct Declaration * decl)
3751 {
3752 yylloc = decl->loc;
3753 switch(decl->type)
3754 {
3755 case 1:
3756 {
3757 if(!curDecl)
3758 {
3759 curDecl = decl;
3760 declTempCount = 0;
3761 }
3762 if(decl->__anon1.__anon1.specifiers)
3763 {
3764 struct Specifier * s;
3765
3766 for(s = (*decl->__anon1.__anon1.specifiers).first; s; s = s->next)
3767 {
3768 ProcessSpecifier(s);
3769 }
3770 }
3771 if(decl->__anon1.__anon1.declarators)
3772 {
3773 struct InitDeclarator * d;
3774
3775 for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
3776 {
3777 if(d->initializer)
3778 ProcessInitializer(d->initializer);
3779 }
3780 }
3781 if(curDecl == decl)
3782 {
3783 curDecl = (((void *)0));
3784 declTempCount = 0;
3785 }
3786 break;
3787 }
3788 case 2:
3789 {
3790 struct Instantiation * inst = decl->__anon1.inst;
3791
3792 if(inCompiler)
3793 {
3794 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
3795
3796 if(!curCompound)
3797 {
3798 struct Statement * stmt;
3799
3800 if(!inst->isConstant || (classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 0 || classSym->__anon1.registered->type == 5)))
3801 {
3802 decl->type = 1;
3803 decl->__anon1.__anon1.specifiers = MkListOne(MkSpecifierName(inst->_class->__anon1.__anon1.name));
3804 if(decl->declMode == 3)
3805 {
3806 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->__anon1.__anon1.specifiers), (((void *)0)), MkSpecifier(STATIC));
3807 }
3808 decl->__anon1.__anon1.declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst->exp->__anon1.__anon1.identifier->string)), (((void *)0))));
3809 ProcessDeclaration(decl);
3810 CreateInstancesBody();
3811 {
3812 struct Expression * exp = MkExpInstance(inst);
3813
3814 stmt = MkExpressionStmt(MkListOne(exp));
3815 ListAdd(createInstancesBody->__anon1.compound.statements, stmt);
3816 ProcessExpressionType(exp);
3817 }
3818 if(classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 0))
3819 {
3820 ListAdd(createInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")), MkListOne(CopyExpression(inst->exp))))));
3821 {
3822 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3823
3824 ListAddFront(destroyInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(exp)));
3825 ProcessExpressionType(exp);
3826 }
3827 }
3828 else if(classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 5))
3829 {
3830 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3831
3832 ListAddFront(destroyInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(exp)));
3833 ProcessExpressionType(exp);
3834 }
3835 __ecereMethod_External_CreateEdge(createInstancesExternal, curExternal, 0);
3836 __ecereMethod_External_CreateEdge(destroyInstancesExternal, curExternal, 0);
3837 break;
3838 }
3839 else
3840 {
3841 CreateInstancesBody();
3842 }
3843 }
3844 {
3845 char className[1024];
3846
3847 className[0] = 0;
3848 decl->type = 1;
3849 decl->__anon1.__anon1.specifiers = MkList();
3850 decl->__anon1.__anon1.declarators = MkList();
3851 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 2)
3852 {
3853 struct __ecereNameSpace__ecere__sys__OldList list =
3854 {
3855 0
3856 };
3857
3858 ProcessInstMembers(inst, inst->exp, &list, 0);
3859 ProcessExpression(inst->exp);
3860 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3861 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(list.first)));
3862 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3863 }
3864 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 3)
3865 {
3866 struct __ecereNameSpace__ecere__sys__OldList list =
3867 {
3868 0
3869 };
3870
3871 ProcessInstMembers(inst, inst->exp, &list, 0);
3872 ProcessExpression(inst->exp);
3873 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3874 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(list.first)));
3875 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3876 }
3877 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3878 {
3879 struct Expression * exp;
3880
3881 DeclareStruct(curExternal, inst->_class->__anon1.__anon1.name, 0, 1);
3882 ProcessExpression(inst->exp);
3883 {
3884 if(inst->fullSet)
3885 {
3886 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3887 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), (((void *)0))));
3888 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3889 }
3890 else
3891 {
3892 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3893
3894 if(ProcessBracketInst(inst, list))
3895 {
3896 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3897 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerList(list)));
3898 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3899 }
3900 else
3901 {
3902 FreeList(list, (void *)(FreeInitializer));
3903 exp = MkExpBrackets(MkList());
3904 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 1);
3905 ListAdd(exp->__anon1.list, CopyExpression(inst->exp));
3906 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3907 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(exp)));
3908 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3909 }
3910 }
3911 }
3912 }
3913 else
3914 {
3915 struct Expression * newCall;
3916
3917 strcpy(className, "__ecereClass_");
3918 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && classSym->__anon1.registered->templateClass)
3919 {
3920 classSym = FindClass(classSym->__anon1.registered->templateClass->fullName);
3921 FullClassNameCat(className, classSym->string, 1);
3922 }
3923 else
3924 FullClassNameCat(className, inst->_class->__anon1.__anon1.name, 1);
3925 if(classSym)
3926 DeclareClass(curExternal, classSym, className);
3927 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && (classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->fixed : classSym->__anon1.registered->fixed))
3928 {
3929 char size[256];
3930 struct __ecereNameSpace__ecere__com__Class * c = classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass : classSym->__anon1.registered;
3931 struct Expression * e = MkExpClassSize(MkSpecifierName(c->name));
3932
3933 ProcessExpressionType(e);
3934 sprintf(size, "%d", c->structSize);
3935 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(e));
3936 }
3937 else
3938 {
3939 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
3940 ProcessExpressionType(newCall);
3941 newCall->byReference = 1;
3942 }
3943 if(inst->exp)
3944 {
3945 struct Expression * exp, * newExp;
3946 struct Identifier * id = CopyIdentifier(inst->exp->__anon1.__anon1.identifier);
3947
3948 if(inst->members && (*inst->members).first)
3949 {
3950 newExp = MkExpOp(CopyExpression(inst->exp), '=', newCall);
3951 exp = MkExpBrackets(MkList());
3952 ListAdd(exp->__anon1.list, newExp);
3953 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 0);
3954 ListAdd(exp->__anon1.list, inst->exp);
3955 ProcessExpression(inst->exp);
3956 inst->exp = (((void *)0));
3957 }
3958 else
3959 exp = newCall;
3960 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3961 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(id), MkInitializerAssignment(exp)));
3962 }
3963 else
3964 FreeExpression(newCall);
3965 }
3966 }
3967 FreeInstance(inst);
3968 }
3969 else
3970 ProcessInstantiation(inst);
3971 break;
3972 }
3973 case 0:
3974 {
3975 if(decl->__anon1.__anon1.specifiers)
3976 {
3977 struct Specifier * spec;
3978
3979 for(spec = (*decl->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
3980 ProcessSpecifier(spec);
3981 }
3982 break;
3983 }
3984 }
3985 }
3986