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