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

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