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