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

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