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