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