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

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