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

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