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