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

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