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 = 0;
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 = 0;
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)), 0);
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, 0);
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 = 1;
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 = 1;
1262 }
1263 }
1264 yylloc = func->loc;
1265 if(!MatchTypes(type, methodDataType, (((void *)0)), owningClass, method->_class, 1, 1, 1, 0, 1))
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)), 0);
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)), 0);
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 = 0;
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, 0);
1603 strcat(name, "_Set_");
1604 FullClassNameCat(name, prop->name, 1);
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, 0);
1613 strcat(name, "_Get_");
1614 FullClassNameCat(name, prop->name, 1);
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, 0);
1634 strcat(name, "_");
1635 FullClassNameCat(name, prop->name, 1);
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, 0);
1663 strcat(name, "_Set_");
1664 FullClassNameCat(name, prop->name, 1);
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, 0);
1673 strcat(name, "_Get_");
1674 FullClassNameCat(name, prop->name, 1);
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, 0);
1694 strcat(name, "_");
1695 FullClassNameCat(name, prop->name, 1);
1696 strcpy(nameM, "__ecerePropM_");
1697 FullClassNameCat(nameM, regClass->fullName, 0);
1698 strcat(nameM, "_");
1699 FullClassNameCat(nameM, prop->name, 1);
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, 1);
1715 strcat(name, "_IsSet_");
1716 FullClassNameCat(name, prop->name, 0);
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 = 0;
1817 }
1818 if(member->type == 0)
1819 {
1820 if(!member->dataType)
1821 member->dataType = ProcessTypeString(member->dataTypeString, 0);
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, 1, 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 = 1;
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, 1);
1924 strcat(name, "_");
1925 FullClassNameCat(name, prop->name, 0);
1926 strcpy(nameM, "__ecerePropM_");
1927 FullClassNameCat(nameM, regClass->fullName, 1);
1928 strcat(nameM, "_");
1929 FullClassNameCat(nameM, prop->name, 0);
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, 1);
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, 1);
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__NamedLink64;
2010
2011 struct __ecereNameSpace__ecere__sys__NamedLink64
2012 {
2013 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
2014 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
2015 char *  name;
2016 long long 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 *  PrintInt64(long long 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, long long value);
2094
2095 extern long long __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 long long 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 *  PrintUInt64(uint64 result);
2149
2150 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2151
2152 extern size_t strlen(const char * );
2153
2154 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
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 = 4, destType->refCount = 1, destType);
2198
2199 e->exp->destType = destType;
2200 parsingType = 1;
2201 ProcessExpressionType(e->exp);
2202 parsingType = 0;
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__NamedLink64 * 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 = PrintInt64(l->data);
2223 FreeType(e->exp->expType);
2224 e->exp->expType = ProcessTypeString("int64", 0);
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 long long value;
2236
2237 switch(op.kind)
2238 {
2239 case 1:
2240 value = op.type->isSigned ? (long long)op.__anon1.c : (long long)op.__anon1.uc;
2241 break;
2242 case 2:
2243 value = op.type->isSigned ? (long long)op.__anon1.s : (long long)op.__anon1.us;
2244 break;
2245 case 4:
2246 value = op.type->isSigned ? op.__anon1.i64 : (long long)op.__anon1.ui64;
2247 break;
2248 case 3:
2249 default:
2250 value = op.type->isSigned ? (long long)op.__anon1.i : (int)op.__anon1.ui;
2251 }
2252 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
2253 }
2254 else
2255 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2256 }
2257 else
2258 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2259 }
2260 {
2261 struct __ecereNameSpace__ecere__com__EnumClassData * baseData = regClass->data;
2262 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
2263
2264 for(deriv = regClass->derivatives.first; deriv; deriv = deriv->next)
2265 {
2266 struct __ecereNameSpace__ecere__com__Class * c = deriv->data;
2267
2268 if(c && c->type == 4)
2269 {
2270 struct __ecereNameSpace__ecere__com__EnumClassData * data = c->data;
2271
2272 data->largest = baseData->largest;
2273 }
2274 }
2275 }
2276 }
2277 if(definitions != (((void *)0)))
2278 {
2279 if(inCompiler)
2280 {
2281 for(def = definitions->first; def; def = def->next)
2282 {
2283 if(def->type == 4 && def->__anon1.propertyWatch)
2284 {
2285 struct PropertyWatch * propWatch = def->__anon1.propertyWatch;
2286 struct ClassFunction * func;
2287 char watcherName[1024];
2288 struct Identifier * propID;
2289 struct Statement * stmt = MkExpressionStmt(MkList());
2290 struct Declarator * decl;
2291
2292 sprintf(watcherName, "__ecerePropertySelfWatcher_%d", propWatcherID++);
2293 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2294 {
2295 strcat(watcherName, "_");
2296 strcat(watcherName, propID->string);
2297 }
2298 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifier(VOID)), (((void *)0)))));
2299 func = MkClassFunction(MkListOne(MkSpecifier(VOID)), (((void *)0)), decl, (((void *)0)));
2300 ProcessClassFunctionBody(func, propWatch->compound);
2301 decl->symbol = __extension__ ({
2302 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2303
2304 __ecereInstance1->id = symbol->id, __ecereInstance1->idCode = symbol->idCode, __ecereInstance1;
2305 });
2306 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
2307 func->id = symbol->id;
2308 func->idCode = symbol->idCode;
2309 func->dontMangle = 1;
2310 {
2311 struct External * externalDecl = MkExternalDeclaration((((void *)0)));
2312 struct Declaration * decl;
2313 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2314
2315 ListAdd(specifiers, MkSpecifier(STATIC));
2316 ListAdd(specifiers, MkSpecifier(VOID));
2317 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, externalDecl);
2318 decl = MkDeclaration(specifiers, MkListOne(MkInitDeclarator(MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifierName(regClass->fullName)), (((void *)0))))), (((void *)0)))));
2319 externalDecl->__anon1.declaration = decl;
2320 if(decl->symbol && !decl->symbol->__anon2.__anon3.methodExternal)
2321 {
2322 decl->symbol->__anon2.__anon3.methodExternal = externalDecl;
2323 decl->symbol->id = symbol->id;
2324 decl->symbol->idCode = symbol->idCode;
2325 }
2326 }
2327 propWatch->compound = (((void *)0));
2328 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(func));
2329 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2330 {
2331 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, propID->string, privateModule);
2332
2333 if(prop)
2334 {
2335 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2336
2337 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2338 {
2339 char * s = QMkString(propID->string);
2340
2341 ListAdd(args, MkExpString(s));
2342 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2343 }
2344 ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
2345 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_SelfWatch")), args));
2346 }
2347 else
2348 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, regClass->fullName);
2349 }
2350 FreePropertyWatch(def->__anon1.propertyWatch);
2351 def->__anon1.propertyWatch = (struct PropertyWatch *)stmt;
2352 }
2353 }
2354 }
2355 for(def = definitions->first; def; def = def->next)
2356 {
2357 if(def->type == 0)
2358 {
2359 ProcessClassFunction(regClass, def->__anon1.function, defs, external->prev, declMode == 3);
2360 }
2361 }
2362 }
2363 if(inCompiler && symbol->id != (((int)0x7fffffff)) && regClass)
2364 {
2365 struct Statement * stmt;
2366 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2367 struct __ecereNameSpace__ecere__com__Method * method;
2368 struct Expression * exp;
2369 const char * registerFunction = (((void *)0));
2370 int inheritanceAccess = 1;
2371
2372 CreateRegisterModuleBody();
2373 curExternal = registerModuleExternal;
2374 switch(regClass->type)
2375 {
2376 case 1:
2377 ListAdd(args, MkExpIdentifier(MkIdentifier("structClass")));
2378 break;
2379 case 2:
2380 ListAdd(args, MkExpIdentifier(MkIdentifier("bitClass")));
2381 break;
2382 case 4:
2383 ListAdd(args, MkExpIdentifier(MkIdentifier("enumClass")));
2384 break;
2385 case 5:
2386 ListAdd(args, MkExpIdentifier(MkIdentifier("noHeadClass")));
2387 break;
2388 case 3:
2389 ListAdd(args, MkExpIdentifier(MkIdentifier("unitClass")));
2390 break;
2391 case 0:
2392 ListAdd(args, MkExpIdentifier(MkIdentifier("normalClass")));
2393 break;
2394 }
2395 {
2396 char nameSpace[1024] = "";
2397 char className[1024] = "";
2398 char * string;
2399
2400 GetNameSpaceString(regClass->nameSpace, nameSpace);
2401 if(declMode == 3)
2402 {
2403 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, className);
2404 __ecereNameSpace__ecere__sys__ChangeCh(className, '.', '_');
2405 strcat(className, "}");
2406 }
2407 strcat(className, nameSpace);
2408 strcat(className, regClass->name);
2409 string = QMkString(className);
2410 ListAdd(args, MkExpString(string));
2411 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2412 }
2413 if(baseSpecs != (((void *)0)))
2414 {
2415 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
2416
2417 if(baseType->kind != 9 && baseType->kind != 10)
2418 {
2419 char baseName[1024] = "";
2420 char * string;
2421
2422 if(baseType->kind == 8 && baseType->__anon1._class && baseType->__anon1._class->isStatic)
2423 {
2424 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, baseName);
2425 __ecereNameSpace__ecere__sys__ChangeCh(baseName, '.', '_');
2426 strcat(baseName, "}");
2427 strcat(baseName, baseType->__anon1._class->string);
2428 }
2429 else
2430 PrintType(baseType, baseName, 0, 1);
2431 string = QMkString(baseName);
2432 ListAdd(args, MkExpString(string));
2433 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2434 }
2435 else
2436 ListAdd(args, MkExpConstant("0"));
2437 FreeType(baseType);
2438 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->__anon1.specifier == PRIVATE)
2439 inheritanceAccess = 2;
2440 }
2441 else
2442 ListAdd(args, MkExpConstant("0"));
2443 if(regClass->type == 1 || regClass->type == 0 || regClass->type == 5)
2444 {
2445 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2446
2447 {
2448 struct __ecereNameSpace__ecere__com__Class * base;
2449
2450 for(base = regClass->base; base && base->type != 1000; base = base->next)
2451 {
2452 for(member = base->membersAndProperties.first; member; member = member->next)
2453 if(!member->isProperty)
2454 break;
2455 if(member)
2456 break;
2457 }
2458 }
2459 if(regClass->type == 1 && symbol->declaredStruct && member)
2460 {
2461 char baseStructName[1024];
2462
2463 baseStructName[0] = (char)0;
2464 strcpy(baseStructName, (regClass->base->templateClass ? regClass->base->templateClass : regClass->base)->fullName);
2465 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))))));
2466 }
2467 else
2468 ListAdd(args, symbol->declaredStruct ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(symbol->structName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2469 }
2470 else
2471 {
2472 ListAdd(args, MkExpConstant("0"));
2473 }
2474 {
2475 char classDataStructName[1024];
2476
2477 strcpy(classDataStructName, "__ecereClassData_");
2478 FullClassNameCat(classDataStructName, symbol->string, 0);
2479 ListAdd(args, symbol->classData ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(classDataStructName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2480 }
2481 if(regClass->type == 0 || regClass->type == 5)
2482 {
2483 ListAdd(args, symbol->needConstructor ? MkExpIdentifier(MkIdentifier(symbol->constructorName)) : MkExpConstant("0"));
2484 ListAdd(args, symbol->needDestructor ? MkExpIdentifier(MkIdentifier(symbol->destructorName)) : MkExpConstant("0"));
2485 }
2486 else
2487 {
2488 ListAdd(args, MkExpConstant("0"));
2489 ListAdd(args, MkExpConstant("0"));
2490 }
2491 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2492 switch(declMode)
2493 {
2494 case 3:
2495 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2496 break;
2497 case 2:
2498 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2499 break;
2500 case 1:
2501 default:
2502 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2503 break;
2504 }
2505 switch(inheritanceAccess)
2506 {
2507 case 2:
2508 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2509 break;
2510 case 1:
2511 default:
2512 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2513 break;
2514 }
2515 registerFunction = "eSystem_RegisterClass";
2516 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("class")), '=', MkExpCall((exp = MkExpIdentifier(MkIdentifier(registerFunction))), args))));
2517 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2518 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)));
2519 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2520 if(external && external->type == 2 && external->__anon1._class->deleteWatchable)
2521 {
2522 args = MkListOne(MkExpIdentifier(MkIdentifier("class")));
2523 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DestructionWatchable")), args)));
2524 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2525 }
2526 if(regClass->base)
2527 {
2528 struct __ecereNameSpace__ecere__com__Class * base = regClass->base;
2529 int c;
2530
2531 for(c = 0; c < base->vTblSize; c++)
2532 {
2533 struct Symbol * method = (struct Symbol *)regClass->_vTbl[c];
2534
2535 if((void *)method != DummyMethod && base->_vTbl[c] != (void *)method && method->__anon2.__anon3.methodExternal)
2536 {
2537 struct External * external = method->__anon2.__anon3.methodExternal;
2538 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2539 struct Identifier * id = external->__anon1.function ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2540
2541 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2542 {
2543 char * string = QMkString(method->__anon1.method->name);
2544
2545 ListAdd(args, MkExpString(string));
2546 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2547 }
2548 ListAdd(args, MkExpConstant("0"));
2549 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2550 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2551 exp->expType = __extension__ ({
2552 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2553
2554 __ecereInstance1->refCount = 1, __ecereInstance1;
2555 });
2556 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2557 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2558 }
2559 }
2560 }
2561 {
2562 int c;
2563
2564 for(c = regClass->base ? regClass->base->vTblSize : 0; c < regClass->vTblSize; c++)
2565 {
2566 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)))
2567 {
2568 if(method->type == 1 && method->_class == regClass && method->vid == c)
2569 {
2570 char name[1024];
2571 struct Expression * exp;
2572 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal : (((void *)0));
2573 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2574 struct Identifier * id = (external && external->__anon1.function) ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2575
2576 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2577 {
2578 char * string = QMkString(method->name);
2579
2580 ListAdd(args, MkExpString(string));
2581 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2582 }
2583 {
2584 char * string = QMkString(method->dataTypeString);
2585
2586 ListAdd(args, MkExpString(string));
2587 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2588 }
2589 if(id && external->__anon1.function->body)
2590 {
2591 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2592 exp->expType = __extension__ ({
2593 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2594
2595 __ecereInstance1->refCount = 1, __ecereInstance1;
2596 });
2597 }
2598 else
2599 {
2600 ListAdd(args, (exp = MkExpConstant("0")));
2601 }
2602 switch(method->memberAccess)
2603 {
2604 case 3:
2605 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2606 break;
2607 case 2:
2608 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2609 break;
2610 case 1:
2611 default:
2612 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2613 break;
2614 }
2615 strcpy(name, "__ecereVMethodID_");
2616 FullClassNameCat(name, method->_class->fullName, 0);
2617 strcat(name, "_");
2618 strcat(name, method->name);
2619 exp = MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddVirtualMethod")), args);
2620 stmt = MkExpressionStmt(MkListOne(exp));
2621 DeclareMethod(method, name);
2622 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2623 }
2624 }
2625 }
2626 }
2627 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)))
2628 {
2629 if(method->type == 1 && method->_class == regClass)
2630 ;
2631 else if(method->memberAccess == 1 || !method->dataTypeString)
2632 {
2633 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->__anon2.__anon3.methodCodeExternal : (((void *)0));
2634 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2635 struct Identifier * id = (external && external->__anon1.function) ? GetDeclId(external->__anon1.function->declarator) : (((void *)0));
2636
2637 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2638 {
2639 char * string = QMkString(method->name);
2640
2641 ListAdd(args, MkExpString(string));
2642 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2643 }
2644 {
2645 char * string = QMkString(method->dataTypeString);
2646
2647 ListAdd(args, MkExpString(string));
2648 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2649 }
2650 if(id && external->__anon1.function->body)
2651 {
2652 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2653 exp->expType = __extension__ ({
2654 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2655
2656 __ecereInstance1->refCount = 1, __ecereInstance1;
2657 });
2658 }
2659 else
2660 {
2661 ListAdd(args, (exp = MkExpConstant("0")));
2662 }
2663 switch(method->memberAccess)
2664 {
2665 case 3:
2666 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2667 break;
2668 case 2:
2669 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2670 break;
2671 case 1:
2672 default:
2673 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2674 break;
2675 }
2676 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2677 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2678 }
2679 }
2680 RegisterMembersAndProperties(regClass, 0, "class", registerModuleBody);
2681 if(classType == 4)
2682 {
2683 struct __ecereNameSpace__ecere__sys__NamedLink64 * value;
2684 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2685 struct __ecereNameSpace__ecere__com__EnumClassData * e = (regClass ? ((void *)(((char *)regClass->data) + enumClass->offsetClass)) : (((void *)0)));
2686
2687 for(value = e->values.first; value; value = value->next)
2688 {
2689 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2690
2691 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2692 {
2693 char * string = QMkString(value->name);
2694
2695 ListAdd(args, MkExpString(string));
2696 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2697 }
2698 {
2699 char * temp;
2700
2701 if(!strcmp(regClass->dataTypeString, "uint64"))
2702 temp = PrintUInt64(value->data);
2703 else
2704 temp = PrintInt64(value->data);
2705 ListAdd(args, MkExpConstant(temp));
2706 (__ecereNameSpace__ecere__com__eSystem_Delete(temp), temp = 0);
2707 }
2708 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eEnum_AddFixedValue")), args)));
2709 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2710 }
2711 }
2712 if(symbol->templateParams)
2713 {
2714 struct TemplateParameter * param;
2715
2716 for(param = (*symbol->templateParams).first; param; param = param->next)
2717 {
2718 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2719
2720 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2721 {
2722 char * string = QMkString(param->identifier->string);
2723
2724 ListAdd(args, MkExpString(string));
2725 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2726 }
2727 ListAdd(args, MkExpIdentifier(MkIdentifier((param->type == 0) ? "type" : ((param->type == 1) ? "identifier" : "expression"))));
2728 switch(param->type)
2729 {
2730 case 0:
2731 case 2:
2732 {
2733 char * typeString = param->__anon1.dataType ? StringFromSpecDecl(param->__anon1.dataType->specifiers, param->__anon1.dataType->decl) : (((void *)0));
2734 char * string = QMkString(typeString);
2735
2736 ListAdd(args, MkExpString(string));
2737 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2738 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2739 break;
2740 }
2741 case 1:
2742 {
2743 char memberTypeString[132] = "TemplateMemberType::";
2744 unsigned int needClass = 1;
2745
2746 ((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);
2747 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(memberTypeString))));
2748 break;
2749 }
2750 }
2751 if(param->defaultArgument)
2752 {
2753 struct __ecereNameSpace__ecere__sys__OldList * members = MkList();
2754
2755 switch(param->type)
2756 {
2757 case 0:
2758 {
2759 char * typeString = param->defaultArgument->__anon1.templateDatatype ? StringFromSpecDecl(param->defaultArgument->__anon1.templateDatatype->specifiers, param->defaultArgument->__anon1.templateDatatype->decl) : (((void *)0));
2760 char * string = QMkString(typeString);
2761
2762 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2763 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2764 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2765 break;
2766 }
2767 case 1:
2768 {
2769 char memberString[1024];
2770 char * string;
2771
2772 memberString[0] = '\0';
2773 if(param->defaultArgument->__anon1.identifier->_class)
2774 {
2775 if(param->defaultArgument->__anon1.identifier->_class->type == 8)
2776 strcpy(memberString, param->defaultArgument->__anon1.identifier->_class->__anon1.templateParameter->identifier->string);
2777 else if(param->defaultArgument->__anon1.identifier->_class->__anon1.__anon1.name)
2778 strcpy(memberString, param->defaultArgument->__anon1.identifier->_class->__anon1.__anon1.name);
2779 }
2780 if(memberString[0])
2781 strcat(memberString, "::");
2782 strcat(memberString, param->defaultArgument->__anon1.identifier->string);
2783 string = QMkString(memberString);
2784 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2785 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2786 break;
2787 }
2788 case 2:
2789 {
2790 struct Operand op =
2791 {
2792 0, 0, 0,
2793 .__anon1 = {
2794 .c = 0
2795 },
2796 {
2797 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
2798 }
2799 };
2800 struct __ecereNameSpace__ecere__sys__OldList * ids = MkList();
2801 char * ui64String;
2802 char * string = (((void *)0));
2803
2804 op = GetOperand(param->defaultArgument->__anon1.expression);
2805 ui64String = PrintUInt64(op.__anon1.ui64);
2806 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("expression"));
2807 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("ui64"));
2808 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
2809 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2810 (__ecereNameSpace__ecere__com__eSystem_Delete(ui64String), ui64String = 0);
2811 break;
2812 }
2813 }
2814 ListAdd(args, MkExpInstance(MkInstantiation(MkSpecifierName("ClassTemplateArgument"), (((void *)0)), MkListOne(MkMembersInitList(members)))));
2815 }
2816 else
2817 ListAdd(args, MkExpIdentifier(MkIdentifier("null")));
2818 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddTemplateParameter")), args)));
2819 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2820 }
2821 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DoneAddingTemplateParameters")), MkListOne(MkExpIdentifier(MkIdentifier("class"))))));
2822 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2823 }
2824 if(definitions != (((void *)0)))
2825 {
2826 for(def = definitions->first; def; def = def->next)
2827 {
2828 if(def->type == 4 && def->__anon1.propertyWatch)
2829 {
2830 ListAdd(registerModuleBody->__anon1.compound.statements, (struct Statement *)def->__anon1.propertyWatch);
2831 def->__anon1.propertyWatch = (((void *)0));
2832 }
2833 else if(def->type == 5)
2834 {
2835 {
2836 char * s = QMkString(def->__anon1.designer);
2837
2838 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("designerClass")), '=', MkExpString(s)))), (((void *)0)));
2839 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2840 }
2841 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2842 }
2843 else if(def->type == 6)
2844 {
2845 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("noExpansion")), '=', MkExpConstant("1")))), (((void *)0)));
2846 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2847 }
2848 else if(def->type == 7)
2849 {
2850 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("fixed")), '=', MkExpConstant("1")))), (((void *)0)));
2851 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2852 if(regClass)
2853 regClass->fixed = 1;
2854 }
2855 else if(def->type == 8)
2856 {
2857 char * s = QMkString(def->__anon1.defaultProperty->string);
2858
2859 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("defaultProperty")), '=', MkExpString(s)))), (((void *)0)));
2860 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
2861 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
2862 }
2863 else if(def->type == 11)
2864 {
2865 ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value))__extension__ ({
2866 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = classPropValues;
2867
2868 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
2869 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Add])(classPropValues, (uint64)(__extension__ ({
2870 struct __ecereNameSpace__ecere__com__Instance * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassPropertyValue);
2871
2872 ((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;
2873 })));
2874 def->__anon1.__anon1.id = (((void *)0));
2875 def->__anon1.__anon1.initializer->__anon1.exp = (((void *)0));
2876 }
2877 }
2878 }
2879 }
2880 }
2881 }
2882
2883 extern void FreeIdentifier(struct Identifier * id);
2884
2885 void __ecereDestructor_ClassPropertyValue(struct __ecereNameSpace__ecere__com__Instance * this)
2886 {
2887 struct ClassPropertyValue * __ecerePointer_ClassPropertyValue = (struct ClassPropertyValue *)(this ? (((char *)this) + __ecereClass_ClassPropertyValue->offset) : 0);
2888
2889 {
2890 FreeIdentifier(__ecerePointer_ClassPropertyValue->id);
2891 }
2892 }
2893
2894 extern void PrintExpression(struct Expression * exp, char *  string);
2895
2896 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__IteratorPointer;
2897
2898 struct __ecereNameSpace__ecere__com__IteratorPointer;
2899
2900 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Iterator;
2901
2902 struct __ecereNameSpace__ecere__com__Iterator
2903 {
2904 struct __ecereNameSpace__ecere__com__Instance * container;
2905 struct __ecereNameSpace__ecere__com__IteratorPointer * pointer;
2906 } __attribute__ ((gcc_struct));
2907
2908 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
2909
2910 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Iterator_Next();
2911
2912 uint64 __ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(struct __ecereNameSpace__ecere__com__Iterator * this);
2913
2914 void __ecereProp___ecereNameSpace__ecere__com__Iterator_Set_data(struct __ecereNameSpace__ecere__com__Iterator * this, uint64 value);
2915
2916 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__com__Iterator_data;
2917
2918 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Free;
2919
2920 void ProcessClassDefinitions()
2921 {
2922 struct External * external, * next;
2923
2924 CreateRegisterModuleBody();
2925 if(ast)
2926 {
2927 for(external = (*ast).first; external; external = next)
2928 {
2929 next = external->next;
2930 curExternal = external;
2931 if(external->type == 2)
2932 {
2933 struct ClassDefinition * _class = external->__anon1._class;
2934
2935 if(_class->definitions)
2936 {
2937 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), ast, external, _class->declMode);
2938 }
2939 if(inCompiler)
2940 {
2941 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2942 FreeExternal(external);
2943 }
2944 }
2945 else if(external->type == 0)
2946 {
2947 unsigned int setStaticMethod = 0;
2948
2949 if(external->symbol && !external->symbol->type->__anon1.__anon2.thisClass && !external->symbol->type->__anon1.__anon2.staticMethod)
2950 {
2951 external->symbol->type->__anon1.__anon2.staticMethod = 1;
2952 setStaticMethod = 1;
2953 }
2954 if(inCompiler)
2955 {
2956 struct FunctionDefinition * function = external->__anon1.function;
2957 struct Statement * stmt;
2958 struct __ecereNameSpace__ecere__sys__OldList * args;
2959
2960 if(!strcmp(function->declarator->symbol->string, "__on_register_module"))
2961 {
2962 ListAdd(registerModuleBody->__anon1.compound.statements, function->body);
2963 function->body->__anon1.compound.context->parent = registerModuleBody->__anon1.compound.context;
2964 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2965 function->body = (((void *)0));
2966 FreeExternal(external);
2967 continue;
2968 }
2969 if(function->declMode != 2 && function->declMode != 1)
2970 continue;
2971 args = MkList();
2972 CreateRegisterModuleBody();
2973 {
2974 char * string = QMkString(function->declarator->symbol->string);
2975
2976 ListAdd(args, MkExpString(string));
2977 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2978 }
2979 {
2980 char * string;
2981 char type[1024] = "";
2982
2983 if(setStaticMethod)
2984 function->declarator->symbol->type->__anon1.__anon2.staticMethod = 0;
2985 PrintType(function->declarator->symbol->type, type, 1, 1);
2986 if(setStaticMethod)
2987 function->declarator->symbol->type->__anon1.__anon2.staticMethod = 1;
2988 string = QMkString(type);
2989 ListAdd(args, MkExpString(string));
2990 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2991 }
2992 {
2993 ListAdd(args, MkExpIdentifier(MkIdentifier(function->declarator->symbol->string)));
2994 }
2995 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2996 switch(function->declMode)
2997 {
2998 case 3:
2999 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
3000 break;
3001 case 2:
3002 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
3003 break;
3004 case 1:
3005 default:
3006 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
3007 break;
3008 }
3009 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterFunction"))), args)));
3010 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
3011 }
3012 }
3013 else if(external->type == 1)
3014 {
3015 struct Declaration * declaration = external->__anon1.declaration;
3016
3017 if(external->symbol)
3018 {
3019 if(external->symbol->type && external->symbol->type->kind == 11 && !external->symbol->type->__anon1.__anon2.thisClass)
3020 external->symbol->type->__anon1.__anon2.staticMethod = 1;
3021 }
3022 if(external->symbol && declaration->type == 1)
3023 {
3024 if(declaration->__anon1.__anon1.specifiers)
3025 {
3026 struct Specifier * specifier;
3027 unsigned int removeExternal = 0;
3028
3029 for(specifier = (*declaration->__anon1.__anon1.specifiers).first; specifier; specifier = specifier->next)
3030 {
3031 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)))
3032 {
3033 struct Symbol * symbol = FindClass(specifier->__anon1.__anon2.id->string);
3034
3035 if(symbol)
3036 {
3037 int classType;
3038
3039 if(specifier->type == 2)
3040 classType = 4;
3041 else
3042 classType = 1;
3043 removeExternal = 1;
3044 symbol->ctx = specifier->__anon1.__anon2.ctx;
3045 specifier->__anon1.__anon2.ctx = (((void *)0));
3046 ProcessClass(classType, specifier->__anon1.__anon2.definitions, symbol, specifier->__anon1.__anon2.baseSpecs, specifier->__anon1.__anon2.list, ast, external, declaration->declMode);
3047 }
3048 }
3049 }
3050 if(inCompiler && removeExternal)
3051 {
3052 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
3053 FreeExternal(external);
3054 }
3055 }
3056 }
3057 else if(declaration->type == 3)
3058 {
3059 if(inCompiler && declaration->declMode != 3)
3060 {
3061 struct Statement * stmt;
3062 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3063
3064 CreateRegisterModuleBody();
3065 {
3066 char * string = QMkString(declaration->__anon1.__anon2.id->string);
3067
3068 ListAdd(args, MkExpString(string));
3069 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3070 }
3071 {
3072 char * string;
3073 char type[1024] = "";
3074
3075 PrintExpression(declaration->__anon1.__anon2.exp, type);
3076 string = QMkString(type);
3077 ListAdd(args, MkExpString(string));
3078 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3079 }
3080 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
3081 switch(declaration->declMode)
3082 {
3083 case 3:
3084 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
3085 break;
3086 case 2:
3087 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
3088 break;
3089 case 1:
3090 default:
3091 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
3092 break;
3093 }
3094 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterDefine"))), args)));
3095 ListAdd(registerModuleBody->__anon1.compound.statements, stmt);
3096 }
3097 }
3098 }
3099 }
3100 {
3101 struct __ecereNameSpace__ecere__com__Iterator v =
3102 {
3103 (classPropValues), 0
3104 };
3105
3106 while(__ecereMethod___ecereNameSpace__ecere__com__Iterator_Next(&v))
3107 {
3108 struct __ecereNameSpace__ecere__sys__OldList * findClassArgs = MkList();
3109 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3110 struct Statement * compoundStmt;
3111 char * s;
3112
3113 if(__extension__ ({
3114 char * __ecTemp1 = (((struct __ecereNameSpace__ecere__com__Instance *)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3115
3116 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3117 })->exp)
3118 yylloc = __extension__ ({
3119 char * __ecTemp1 = (((struct __ecereNameSpace__ecere__com__Instance *)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3120
3121 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3122 })->exp->loc;
3123 ListAdd(findClassArgs, MkExpIdentifier(MkIdentifier("module")));
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 })->regClass->name);
3129 ListAdd(findClassArgs, MkExpString(s));
3130 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
3131 ListAdd(args, MkExpIdentifier(MkIdentifier("_class")));
3132 s = QMkString(__extension__ ({
3133 char * __ecTemp1 = (((struct __ecereNameSpace__ecere__com__Instance *)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3134
3135 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3136 })->id->string);
3137 ListAdd(args, MkExpString(s));
3138 (__ecereNameSpace__ecere__com__eSystem_Delete(s), s = 0);
3139 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(INT64)), (((void *)0))), __extension__ ({
3140 char * __ecTemp1 = (((struct __ecereNameSpace__ecere__com__Instance *)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&v)));
3141
3142 ((struct ClassPropertyValue *)(__ecTemp1 + __ecereClass_ClassPropertyValue->offset));
3143 })->exp));
3144 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)))));
3145 compoundStmt->__anon1.compound.context = __extension__ ({
3146 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
3147
3148 __ecereInstance1->parent = registerModuleBody->__anon1.compound.context, __ecereInstance1;
3149 });
3150 ListAdd(registerModuleBody->__anon1.compound.statements, compoundStmt);
3151 }
3152 }
3153 ((void (*)(struct __ecereNameSpace__ecere__com__Instance *))__extension__ ({
3154 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = classPropValues;
3155
3156 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
3157 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Free])(classPropValues);
3158 }
3159 }
3160
3161 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
3162
3163 struct __ecereNameSpace__ecere__com__GlobalFunction;
3164
3165 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);
3166
3167 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);
3168
3169 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
3170
3171 struct __ecereNameSpace__ecere__com__Module
3172 {
3173 struct __ecereNameSpace__ecere__com__Instance * application;
3174 struct __ecereNameSpace__ecere__sys__OldList classes;
3175 struct __ecereNameSpace__ecere__sys__OldList defines;
3176 struct __ecereNameSpace__ecere__sys__OldList functions;
3177 struct __ecereNameSpace__ecere__sys__OldList modules;
3178 struct __ecereNameSpace__ecere__com__Instance * prev;
3179 struct __ecereNameSpace__ecere__com__Instance * next;
3180 const char *  name;
3181 void *  library;
3182 void *  Unload;
3183 int importType;
3184 int origImportType;
3185 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
3186 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
3187 } __attribute__ ((gcc_struct));
3188
3189 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
3190
3191 void __ecereRegisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
3192 {
3193 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
3194
3195 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereCom", "void SetBuildingEcereCom(bool b)", SetBuildingEcereCom, module, 1);
3196 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereCom", "bool GetBuildingEcereCom(void)", GetBuildingEcereCom, module, 1);
3197 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereComModule", "void SetBuildingEcereComModule(bool b)", SetBuildingEcereComModule, module, 1);
3198 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereComModule", "bool GetBuildingEcereComModule(void)", GetBuildingEcereComModule, module, 1);
3199 __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);
3200 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CreateRegisterModuleBody", "void CreateRegisterModuleBody(void)", CreateRegisterModuleBody, module, 2);
3201 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("RegisterMembersAndProperties", "void RegisterMembersAndProperties(ecere::com::Class regClass, bool isMember, const char * className, Statement statement)", RegisterMembersAndProperties, module, 2);
3202 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetNameSpaceString", "void GetNameSpaceString(ecere::com::NameSpace ns, char * string)", GetNameSpaceString, module, 2);
3203 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ClassPropertyValue", 0, sizeof(struct ClassPropertyValue), 0, 0, __ecereDestructor_ClassPropertyValue, module, 2, 1);
3204 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3205 __ecereClass_ClassPropertyValue = class;
3206 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessClassDefinitions", "void ProcessClassDefinitions(void)", ProcessClassDefinitions, module, 1);
3207 }
3208
3209 void __ecereUnregisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
3210 {
3211
3212 }
3213
3214 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List_TPL_ClassPropertyValue_;
3215
3216 void __ecereCreateModuleInstances_pass1()
3217 {
3218 classPropValues = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__List_TPL_ClassPropertyValue_);
3219 __ecereNameSpace__ecere__com__eInstance_IncRef(classPropValues);
3220 }
3221
3222 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
3223
3224 void __ecereDestroyModuleInstances_pass1()
3225 {
3226 (__ecereNameSpace__ecere__com__eInstance_DecRef(classPropValues), classPropValues = 0);
3227 }
3228