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 if(!registerModuleBody && inCompiler)
1369 {
1370 char registerName[1024], moduleName[274];
1371 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1372 struct Declarator * declarator;
1373 struct TypeName * moduleParam;
1374
1375 registerModuleBody = MkCompoundStmt(MkList(), MkList());
1376 registerModuleBody->compound.context = __extension__ ({
1377 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1378
1379 __ecereInstance1->parent = globalContext, __ecereInstance1;
1380 });
1381 ListAdd(registerModuleBody->compound.declarations, MkDeclaration(MkListOne(MkSpecifierName("ecere::com::Class")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("class")), (((void *)0))))));
1382 specifiers = MkList();
1383 ListAdd(specifiers, MkSpecifier(VOID));
1384 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
1385 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1386 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1387 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '.', '_');
1388 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, ' ', '_');
1389 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '-', '_');
1390 sprintf(registerName, "__ecereRegisterModule_%s", moduleName);
1391 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
1392 {
1393 struct FunctionDefinition * function = MkFunction(specifiers, declarator, (((void *)0)));
1394
1395 ProcessFunctionBody(function, registerModuleBody);
1396 function->declMode = 0;
1397 if(!ast)
1398 ast = MkList();
1399 ListAdd(ast, (registerModuleExternal = MkExternalFunction(function)));
1400 }
1401 }
1402 if(!unregisterModuleBody && inCompiler)
1403 {
1404 char registerName[1024], moduleName[274];
1405 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1406 struct Declarator * declarator;
1407 struct TypeName * moduleParam;
1408
1409 unregisterModuleBody = MkCompoundStmt(MkList(), MkList());
1410 unregisterModuleBody->compound.context = __extension__ ({
1411 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1412
1413 __ecereInstance1->parent = globalContext, __ecereInstance1;
1414 });
1415 specifiers = MkList();
1416 ListAdd(specifiers, MkSpecifier(VOID));
1417 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
1418 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1419 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1420 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '.', '_');
1421 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, ' ', '_');
1422 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '-', '_');
1423 sprintf(registerName, "__ecereUnregisterModule_%s", moduleName);
1424 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
1425 {
1426 struct FunctionDefinition * function = MkFunction(specifiers, declarator, (((void *)0)));
1427
1428 ProcessFunctionBody(function, unregisterModuleBody);
1429 function->declMode = 0;
1430 if(!ast)
1431 ast = MkList();
1432 ListAdd(ast, (unregisterModuleExternal = MkExternalFunction(function)));
1433 }
1434 }
1435 }
1436
1437 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1438
1439 extern struct Expression * MkExpConstant(char *  string);
1440
1441 extern char *  QMkString(char *  source);
1442
1443 extern struct Expression * MkExpString(char *  string);
1444
1445 extern char *  strcpy(char * , const char * );
1446
1447 extern void FullClassNameCat(char *  output, char *  className, unsigned int includeTemplateParams);
1448
1449 extern char *  strcat(char * , const char * );
1450
1451 extern void MangleClassName(char *  className);
1452
1453 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1454
1455 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1456
1457 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1458
1459 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1460
1461 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1462
1463 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1464
1465 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1466
1467 extern struct Expression * CopyExpression(struct Expression * exp);
1468
1469 extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
1470
1471 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1472
1473 struct __ecereNameSpace__ecere__com__BitMember
1474 {
1475 struct __ecereNameSpace__ecere__com__BitMember * prev;
1476 struct __ecereNameSpace__ecere__com__BitMember * next;
1477 char *  name;
1478 unsigned int isProperty;
1479 int memberAccess;
1480 int id;
1481 struct __ecereNameSpace__ecere__com__Class * _class;
1482 char *  dataTypeString;
1483 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1484 struct Type * dataType;
1485 int type;
1486 int size;
1487 int pos;
1488 uint64 mask;
1489 } __attribute__ ((gcc_struct));
1490
1491 extern int ComputeTypeSize(struct Type * type);
1492
1493 extern struct Context * curContext;
1494
1495 extern struct Context * PushContext(void);
1496
1497 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
1498
1499 extern void PopContext(struct Context * ctx);
1500
1501 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
1502
1503 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1504
1505 struct __ecereNameSpace__ecere__com__ClassProperty
1506 {
1507 char *  name;
1508 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1509 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1510 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1511 int depth;
1512 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1513 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1514 char *  dataTypeString;
1515 struct Type * dataType;
1516 unsigned int constant;
1517 } __attribute__ ((gcc_struct));
1518
1519 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(struct __ecereNameSpace__ecere__sys__BinaryTree * this);
1520
1521 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_first;
1522
1523 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(struct __ecereNameSpace__ecere__sys__BTNode * this);
1524
1525 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BTNode_next;
1526
1527 void RegisterMembersAndProperties(struct __ecereNameSpace__ecere__com__Class * regClass, unsigned int isMember, char * className, struct Statement * statement)
1528 {
1529 struct __ecereNameSpace__ecere__com__DataMember * dataMember = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)regClass : (((void *)0));
1530 struct __ecereNameSpace__ecere__com__DataMember * member;
1531 struct __ecereNameSpace__ecere__com__Property * prop;
1532 struct Expression * exp;
1533 struct Statement * stmt;
1534 char dataMemberSize[16];
1535 unsigned int lastOffset = 0;
1536 int privateID = 0;
1537 unsigned int privateMembers = 0x0;
1538
1539 sprintf(dataMemberSize, "%d", (int)sizeof(struct __ecereNameSpace__ecere__com__DataMember *));
1540 if(!isMember)
1541 {
1542 for(prop = regClass->conversions.first; prop; prop = prop->next)
1543 {
1544 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1545 char name[1024];
1546
1547 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1548 ListAdd(args, MkExpConstant("0"));
1549 {
1550 char * string = QMkString(prop->dataTypeString);
1551
1552 ListAdd(args, MkExpString(string));
1553 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1554 }
1555 if(prop->Set)
1556 {
1557 strcpy(name, "__ecereProp_");
1558 FullClassNameCat(name, regClass->fullName, 0x0);
1559 strcat(name, "_Set_");
1560 FullClassNameCat(name, prop->name, 0x1);
1561 MangleClassName(name);
1562 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1563 }
1564 else
1565 ListAdd(args, MkExpConstant("0"));
1566 if(prop->Get)
1567 {
1568 strcpy(name, "__ecereProp_");
1569 FullClassNameCat(name, regClass->fullName, 0x0);
1570 strcat(name, "_Get_");
1571 FullClassNameCat(name, prop->name, 0x1);
1572 MangleClassName(name);
1573 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1574 }
1575 else
1576 ListAdd(args, MkExpConstant("0"));
1577 switch(prop->memberAccess)
1578 {
1579 case 3:
1580 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1581 break;
1582 case 2:
1583 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1584 break;
1585 case 1:
1586 default:
1587 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1588 break;
1589 }
1590 strcpy(name, "__ecereProp_");
1591 FullClassNameCat(name, regClass->fullName, 0x0);
1592 strcat(name, "_");
1593 FullClassNameCat(name, prop->name, 0x1);
1594 MangleClassName(name);
1595 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1596 ListAdd(registerModuleBody->compound.statements, stmt);
1597 }
1598 }
1599 for(member = isMember ? dataMember->members.first : regClass->membersAndProperties.first; member; member = member->next)
1600 {
1601 if(member->isProperty)
1602 {
1603 prop = (struct __ecereNameSpace__ecere__com__Property *)member;
1604 {
1605 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1606 char name[1024], nameM[1024];
1607 char * string = QMkString(prop->name);
1608
1609 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1610 ListAdd(args, MkExpString(string));
1611 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1612 {
1613 char * string = QMkString(prop->dataTypeString);
1614
1615 ListAdd(args, MkExpString(string));
1616 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1617 }
1618 if(prop->Set)
1619 {
1620 strcpy(name, "__ecereProp_");
1621 FullClassNameCat(name, regClass->fullName, 0x0);
1622 strcat(name, "_Set_");
1623 FullClassNameCat(name, prop->name, 0x1);
1624 MangleClassName(name);
1625 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1626 }
1627 else
1628 ListAdd(args, MkExpConstant("0"));
1629 if(prop->Get)
1630 {
1631 strcpy(name, "__ecereProp_");
1632 FullClassNameCat(name, regClass->fullName, 0x0);
1633 strcat(name, "_Get_");
1634 FullClassNameCat(name, prop->name, 0x1);
1635 MangleClassName(name);
1636 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1637 }
1638 else
1639 ListAdd(args, MkExpConstant("0"));
1640 switch(prop->memberAccess)
1641 {
1642 case 3:
1643 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1644 break;
1645 case 2:
1646 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1647 break;
1648 case 1:
1649 default:
1650 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1651 break;
1652 }
1653 strcpy(name, "__ecereProp_");
1654 FullClassNameCat(name, regClass->fullName, 0x0);
1655 strcat(name, "_");
1656 FullClassNameCat(name, prop->name, 0x1);
1657 MangleClassName(name);
1658 strcpy(nameM, "__ecerePropM_");
1659 FullClassNameCat(nameM, regClass->fullName, 0x0);
1660 strcat(nameM, "_");
1661 FullClassNameCat(nameM, prop->name, 0x1);
1662 MangleClassName(nameM);
1663 if(prop->dataTypeString)
1664 {
1665 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1666 }
1667 else
1668 {
1669 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args)));
1670 }
1671 ListAdd(registerModuleBody->compound.statements, stmt);
1672 if(prop->IsSet)
1673 {
1674 char name[1024];
1675
1676 strcpy(name, "__ecereProp_");
1677 FullClassNameCat(name, regClass->fullName, 0x1);
1678 strcat(name, "_IsSet_");
1679 FullClassNameCat(name, prop->name, 0x0);
1680 MangleClassName(name);
1681 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))))));
1682 ListAdd(registerModuleBody->compound.statements, stmt);
1683 }
1684 if(((struct Symbol *)prop->symbol)->propCategory)
1685 {
1686 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier(nameM)), MkIdentifier("category")), '=', CopyExpression(((struct Symbol *)prop->symbol)->propCategory))));
1687 ListAdd(registerModuleBody->compound.statements, stmt);
1688 }
1689 if(prop->dataTypeString)
1690 {
1691 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1692
1693 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpIdentifier(MkIdentifier(nameM))));
1694 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0"))));
1695 stmt = MkIfStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("module")), MkIdentifier("application")), EQ_OP, MkExpMember(MkExpIdentifier(MkIdentifier("__thisModule")), MkIdentifier("application")))), MkExpressionStmt(list), (((void *)0)));
1696 ListAdd(registerModuleBody->compound.statements, stmt);
1697 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")))));
1698 ListAdd(unregisterModuleBody->compound.statements, stmt);
1699 }
1700 }
1701 }
1702 else if(member->type == 0 && !isMember && regClass->type == 2)
1703 {
1704 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)member;
1705 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1706
1707 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1708 {
1709 char * string = QMkString(bitMember->name);
1710
1711 ListAdd(args, MkExpString(string));
1712 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1713 }
1714 {
1715 char * string = QMkString(bitMember->dataTypeString);
1716
1717 ListAdd(args, MkExpString(string));
1718 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1719 }
1720 {
1721 char string[256];
1722
1723 sprintf(string, "%d", bitMember->size);
1724 ListAdd(args, (exp = MkExpConstant(string)));
1725 }
1726 {
1727 char string[256];
1728
1729 sprintf(string, "%d", bitMember->pos);
1730 ListAdd(args, (exp = MkExpConstant(string)));
1731 }
1732 switch(member->memberAccess)
1733 {
1734 case 3:
1735 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1736 break;
1737 case 2:
1738 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1739 break;
1740 case 1:
1741 default:
1742 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1743 break;
1744 }
1745 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddBitMember")), args)));
1746 ListAdd(statement->compound.statements, stmt);
1747 }
1748 else if(member->memberAccess == 1 || (member->type == 0 && !member->dataTypeString))
1749 {
1750 struct __ecereNameSpace__ecere__sys__OldList * args;
1751
1752 if(privateMembers)
1753 {
1754 unsigned int offset = member->offset - lastOffset;
1755
1756 args = MkList();
1757 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1758 {
1759 char string[200];
1760
1761 sprintf(string, "\"__ecerePrivateData%d\"", privateID++);
1762 ListAdd(args, MkExpString(string));
1763 }
1764 {
1765 char string[200];
1766
1767 sprintf(string, "\"byte[%d]\"", offset);
1768 ListAdd(args, MkExpString(string));
1769 }
1770 {
1771 char string[256];
1772
1773 sprintf(string, "%d", offset);
1774 ListAdd(args, (exp = MkExpConstant(string)));
1775 }
1776 ListAdd(args, (exp = MkExpConstant("1")));
1777 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1778 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
1779 ListAdd(statement->compound.statements, stmt);
1780 privateMembers = 0x0;
1781 }
1782 if(member->type == 0)
1783 {
1784 if(!member->dataType)
1785 member->dataType = ProcessTypeString(member->dataTypeString, 0x0);
1786 ComputeTypeSize(member->dataType);
1787 args = MkList();
1788 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1789 {
1790 char * string = QMkString(member->name);
1791
1792 ListAdd(args, MkExpString(string));
1793 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1794 }
1795 {
1796 char * string = QMkString(member->dataTypeString);
1797
1798 ListAdd(args, MkExpString(string));
1799 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1800 }
1801 {
1802 char string[256];
1803
1804 sprintf(string, "%d", member->dataType->size);
1805 ListAdd(args, (exp = MkExpConstant(string)));
1806 }
1807 {
1808 char string[256];
1809
1810 sprintf(string, "%d", member->dataType->alignment);
1811 ListAdd(args, (exp = MkExpConstant(string)));
1812 }
1813 switch(member->memberAccess)
1814 {
1815 case 3:
1816 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1817 break;
1818 case 2:
1819 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1820 break;
1821 case 1:
1822 default:
1823 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1824 break;
1825 }
1826 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
1827 ListAdd(statement->compound.statements, stmt);
1828 lastOffset = member->offset + member->dataType->size;
1829 }
1830 else
1831 {
1832 static int memberCount = 0;
1833 struct Context * context;
1834 struct Statement * compound;
1835 char memberName[256];
1836
1837 sprintf(memberName, "dataMember%d", memberCount);
1838 memberCount++;
1839 curContext = statement->compound.context;
1840 context = PushContext();
1841 args = MkListOne(MkExpIdentifier(MkIdentifier((member->type == 1) ? "unionMember" : "structMember")));
1842 switch(member->memberAccess)
1843 {
1844 case 3:
1845 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1846 break;
1847 case 2:
1848 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1849 break;
1850 case 1:
1851 default:
1852 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1853 break;
1854 }
1855 compound = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifierName("DataMember")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(memberName)), MkInitializerAssignment(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_New")), args)))))), MkList());
1856 compound->compound.context = context;
1857 args = MkList();
1858 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1859 ListAdd(args, MkExpIdentifier(MkIdentifier(memberName)));
1860 RegisterMembersAndProperties((struct __ecereNameSpace__ecere__com__Class *)member, 0x1, memberName, compound);
1861 if(isMember)
1862 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_AddMember")), args)));
1863 else
1864 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMember")), args)));
1865 ListAdd(compound->compound.statements, stmt);
1866 PopContext(context);
1867 ListAdd(statement->compound.statements, compound);
1868 memberCount--;
1869 lastOffset = member->offset + member->memberOffset;
1870 }
1871 }
1872 else
1873 privateMembers = 0x1;
1874 }
1875 if(!isMember)
1876 {
1877 struct __ecereNameSpace__ecere__com__ClassProperty * classProperty;
1878
1879 for(prop = regClass->membersAndProperties.first; prop; prop = prop->next)
1880 {
1881 if(prop->isProperty && prop->isWatchable)
1882 {
1883 struct __ecereNameSpace__ecere__sys__OldList * args;
1884 char name[1024], nameM[1024];
1885
1886 strcpy(name, "__ecereProp_");
1887 FullClassNameCat(name, regClass->fullName, 0x1);
1888 strcat(name, "_");
1889 FullClassNameCat(name, prop->name, 0x0);
1890 MangleClassName(name);
1891 strcpy(nameM, "__ecerePropM_");
1892 FullClassNameCat(nameM, regClass->fullName, 0x1);
1893 strcat(nameM, "_");
1894 FullClassNameCat(nameM, prop->name, 0x0);
1895 MangleClassName(nameM);
1896 args = MkListOne(MkExpCondition(MkExpIdentifier(MkIdentifier(nameM)), MkListOne(MkExpIdentifier(MkIdentifier(nameM))), MkExpIdentifier(MkIdentifier(name))));
1897 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_Watchable")), args)));
1898 ListAdd(registerModuleBody->compound.statements, stmt);
1899 }
1900 }
1901 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)))
1902 {
1903 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1904 char name[1024];
1905 char * string = QMkString(classProperty->name);
1906
1907 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1908 ListAdd(args, MkExpString(string));
1909 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1910 {
1911 char * string = QMkString(classProperty->dataTypeString);
1912
1913 ListAdd(args, MkExpString(string));
1914 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1915 }
1916 if(classProperty->Set)
1917 {
1918 strcpy(name, "__ecereClassProp_");
1919 FullClassNameCat(name, regClass->fullName, 0x1);
1920 strcat(name, "_Set_");
1921 strcat(name, classProperty->name);
1922 MangleClassName(name);
1923 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1924 }
1925 else
1926 ListAdd(args, MkExpConstant("0"));
1927 if(classProperty->Get)
1928 {
1929 strcpy(name, "__ecereClassProp_");
1930 FullClassNameCat(name, regClass->fullName, 0x1);
1931 strcat(name, "_Get_");
1932 strcat(name, classProperty->name);
1933 MangleClassName(name);
1934 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1935 }
1936 else
1937 ListAdd(args, MkExpConstant("0"));
1938 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddClassProperty")), args)));
1939 ListAdd(registerModuleBody->compound.statements, stmt);
1940 }
1941 }
1942 }
1943
1944 extern struct External * curExternal;
1945
1946 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
1947
1948 struct __ecereNameSpace__ecere__com__NameSpace
1949 {
1950 char *  name;
1951 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1952 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1953 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1954 int depth;
1955 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1956 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1957 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1958 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1959 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1960 } __attribute__ ((gcc_struct));
1961
1962 void GetNameSpaceString(struct __ecereNameSpace__ecere__com__NameSpace * ns, char * string)
1963 {
1964 if(ns->parent)
1965 GetNameSpaceString(ns->parent, string);
1966 if(ns->name)
1967 {
1968 strcat(string, ns->name);
1969 strcat(string, "::");
1970 }
1971 }
1972
1973 extern unsigned int parsingType;
1974
1975 extern void ProcessExpressionType(struct Expression * exp);
1976
1977 extern void ComputeExpression(struct Expression * exp);
1978
1979 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
1980
1981 struct OpTable
1982 {
1983 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1984 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1985 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1986 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1987 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1988 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1989 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1990 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1991 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1992 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1993 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1994 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1995 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1996 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1997 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
1998 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
1999 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
2000 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
2001 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
2002 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
2003 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
2004 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
2005 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
2006 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
2007 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
2008 unsigned int (*  Not)(struct Expression *, struct Operand *);
2009 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
2010 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
2011 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
2012 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
2013 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
2014 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
2015 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
2016 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
2017 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
2018 } __attribute__ ((gcc_struct));
2019
2020 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
2021
2022 struct Operand
2023 {
2024 int kind;
2025 struct Type * type;
2026 unsigned int ptrSize;
2027 union
2028 {
2029 char c;
2030 unsigned char uc;
2031 short s;
2032 unsigned short us;
2033 int i;
2034 unsigned int ui;
2035 float f;
2036 double d;
2037 long long i64;
2038 uint64 ui64;
2039 } __attribute__ ((gcc_struct));
2040 struct OpTable ops;
2041 } __attribute__ ((gcc_struct));
2042
2043 extern struct Operand GetOperand(struct Expression * exp);
2044
2045 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string, int value);
2046
2047 extern int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string);
2048
2049 extern struct ClassFunction * MkClassFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Specifier * _class, struct Declarator * decl, struct __ecereNameSpace__ecere__sys__OldList * declList);
2050
2051 extern void ProcessClassFunctionBody(struct ClassFunction * func, struct Statement * body);
2052
2053 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
2054
2055 extern struct ClassDef * MkClassDefFunction(struct ClassFunction * function);
2056
2057 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);
2058
2059 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
2060
2061 extern void FreePropertyWatch(struct PropertyWatch * watcher);
2062
2063 extern char *  sourceFile;
2064
2065 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2066
2067 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
2068
2069 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
2070
2071 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
2072
2073 extern unsigned int DummyMethod(void);
2074
2075 extern void DeclareMethod(struct __ecereNameSpace__ecere__com__Method * method, char *  name);
2076
2077 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
2078
2079 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
2080
2081 struct __ecereNameSpace__ecere__com__EnumClassData
2082 {
2083 struct __ecereNameSpace__ecere__sys__OldList values;
2084 int largest;
2085 } __attribute__ ((gcc_struct));
2086
2087 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink;
2088
2089 struct __ecereNameSpace__ecere__sys__NamedLink
2090 {
2091 struct __ecereNameSpace__ecere__sys__NamedLink * prev;
2092 struct __ecereNameSpace__ecere__sys__NamedLink * next;
2093 char *  name;
2094 void *  data;
2095 } __attribute__ ((gcc_struct));
2096
2097 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2098
2099 extern size_t strlen(const char * );
2100
2101 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
2102
2103 extern char *  PrintUInt64(uint64 result);
2104
2105 extern struct Expression * MkExpInstance(struct Instantiation * inst);
2106
2107 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
2108
2109 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
2110
2111 int __ecereVMethodID_class_OnGetString;
2112
2113 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType;
2114
2115 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)
2116 {
2117 struct ClassDef * def;
2118 struct __ecereNameSpace__ecere__com__Class * regClass = symbol->registered;
2119
2120 if(regClass)
2121 {
2122 classType = regClass->type;
2123 if(classType == 4 && enumValues && (inCompiler || !buildingECERECOMModule))
2124 {
2125 struct Enumerator * e;
2126
2127 for(e = enumValues->first; e; e = e->next)
2128 {
2129 if(e->exp)
2130 {
2131 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->kind = 3, destType->refCount = 1, destType);
2132
2133 e->exp->destType = destType;
2134 parsingType = 0x1;
2135 ProcessExpressionType(e->exp);
2136 parsingType = 0x0;
2137 if(!e->exp->expType)
2138 {
2139 destType->kind = 8;
2140 destType->_class = symbol;
2141 ProcessExpressionType(e->exp);
2142 }
2143 ComputeExpression(e->exp);
2144 if(e->exp->isConstant && e->exp->type == 2)
2145 {
2146 struct Operand op = GetOperand(e->exp);
2147 int value;
2148
2149 switch(op.kind)
2150 {
2151 case 1:
2152 value = op.c;
2153 break;
2154 case 2:
2155 value = op.s;
2156 break;
2157 default:
2158 value = op.i;
2159 }
2160 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
2161 }
2162 else
2163 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2164 }
2165 else
2166 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2167 }
2168 }
2169 if(definitions != (((void *)0)))
2170 {
2171 if(inCompiler)
2172 {
2173 for(def = definitions->first; def; def = def->next)
2174 {
2175 if(def->type == 4 && def->propertyWatch)
2176 {
2177 struct PropertyWatch * propWatch = def->propertyWatch;
2178 struct ClassFunction * func;
2179 char watcherName[1024];
2180 struct Identifier * propID;
2181 struct Statement * stmt = MkExpressionStmt(MkList());
2182 struct Declarator * decl;
2183
2184 sprintf(watcherName, "__ecerePropertySelfWatcher_%d", propWatcherID++);
2185 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2186 {
2187 strcat(watcherName, "_");
2188 strcat(watcherName, propID->string);
2189 }
2190 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifier(VOID)), (((void *)0)))));
2191 func = MkClassFunction(MkListOne(MkSpecifier(VOID)), (((void *)0)), decl, (((void *)0)));
2192 ProcessClassFunctionBody(func, propWatch->compound);
2193 decl->symbol = __extension__ ({
2194 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2195
2196 __ecereInstance1->id = symbol->id, __ecereInstance1->idCode = symbol->idCode, __ecereInstance1;
2197 });
2198 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
2199 func->id = symbol->id;
2200 func->idCode = symbol->idCode;
2201 func->dontMangle = 0x1;
2202 {
2203 struct External * externalDecl = MkExternalDeclaration((((void *)0)));
2204 struct Declaration * decl;
2205 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2206
2207 ListAdd(specifiers, MkSpecifier(STATIC));
2208 ListAdd(specifiers, MkSpecifier(VOID));
2209 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, externalDecl);
2210 decl = MkDeclaration(specifiers, MkListOne(MkInitDeclarator(MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifierName(regClass->fullName)), (((void *)0))))), (((void *)0)))));
2211 externalDecl->declaration = decl;
2212 if(decl->symbol && !decl->symbol->methodExternal)
2213 {
2214 decl->symbol->methodExternal = externalDecl;
2215 decl->symbol->id = symbol->id;
2216 decl->symbol->idCode = symbol->idCode;
2217 }
2218 }
2219 propWatch->compound = (((void *)0));
2220 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(func));
2221 stmt->type = 3;
2222 stmt->expressions = MkList();
2223 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2224 {
2225 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, propID->string, privateModule);
2226
2227 if(prop)
2228 {
2229 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2230
2231 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2232 ListAdd(args, MkExpString(QMkString(propID->string)));
2233 ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
2234 ListAdd(stmt->expressions, MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_SelfWatch")), args));
2235 }
2236 else
2237 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Property %s not found in class %s\n", (((void *)0))), propID->string, regClass->fullName);
2238 }
2239 FreePropertyWatch(def->propertyWatch);
2240 def->propertyWatch = (struct PropertyWatch *)stmt;
2241 }
2242 }
2243 }
2244 for(def = definitions->first; def; def = def->next)
2245 {
2246 if(def->type == 0)
2247 {
2248 ProcessClassFunction(regClass, def->function, defs, external->prev, declMode == 3);
2249 }
2250 }
2251 }
2252 if(inCompiler && symbol->id != (((int)0x7fffffff)) && regClass)
2253 {
2254 struct Statement * stmt;
2255 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2256 struct __ecereNameSpace__ecere__com__Method * method;
2257 struct Expression * exp;
2258 char * registerFunction = (((void *)0));
2259 int inheritanceAccess = 1;
2260
2261 CreateRegisterModuleBody();
2262 curExternal = registerModuleExternal;
2263 switch(regClass->type)
2264 {
2265 case 1:
2266 ListAdd(args, MkExpIdentifier(MkIdentifier("structClass")));
2267 break;
2268 case 2:
2269 ListAdd(args, MkExpIdentifier(MkIdentifier("bitClass")));
2270 break;
2271 case 4:
2272 ListAdd(args, MkExpIdentifier(MkIdentifier("enumClass")));
2273 break;
2274 case 5:
2275 ListAdd(args, MkExpIdentifier(MkIdentifier("noHeadClass")));
2276 break;
2277 case 3:
2278 ListAdd(args, MkExpIdentifier(MkIdentifier("unitClass")));
2279 break;
2280 case 0:
2281 ListAdd(args, MkExpIdentifier(MkIdentifier("normalClass")));
2282 break;
2283 }
2284 {
2285 char nameSpace[1024] = "";
2286 char className[1024] = "";
2287 char * string;
2288
2289 GetNameSpaceString(regClass->nameSpace, nameSpace);
2290 if(declMode == 3)
2291 {
2292 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, className);
2293 __ecereNameSpace__ecere__sys__ChangeCh(className, '.', '_');
2294 strcat(className, "}");
2295 }
2296 strcat(className, nameSpace);
2297 strcat(className, regClass->name);
2298 string = QMkString(className);
2299 ListAdd(args, MkExpString(string));
2300 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2301 }
2302 if(baseSpecs != (((void *)0)))
2303 {
2304 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
2305
2306 if(baseType->kind != 9 && baseType->kind != 10)
2307 {
2308 char baseName[1024] = "";
2309 char * string;
2310
2311 if(baseType->kind == 8 && baseType->_class && baseType->_class->isStatic)
2312 {
2313 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, baseName);
2314 __ecereNameSpace__ecere__sys__ChangeCh(baseName, '.', '_');
2315 strcat(baseName, "}");
2316 strcat(baseName, baseType->_class->string);
2317 }
2318 else
2319 PrintType(baseType, baseName, 0x0, 0x1);
2320 string = QMkString(baseName);
2321 ListAdd(args, MkExpString(string));
2322 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2323 }
2324 else
2325 ListAdd(args, MkExpConstant("0"));
2326 FreeType(baseType);
2327 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->specifier == PRIVATE)
2328 inheritanceAccess = 2;
2329 }
2330 else
2331 ListAdd(args, MkExpConstant("0"));
2332 if(regClass->type == 1 || regClass->type == 0 || regClass->type == 5)
2333 {
2334 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2335
2336 {
2337 struct __ecereNameSpace__ecere__com__Class * base;
2338
2339 for(base = regClass->base; base && base->type != 1000; base = base->next)
2340 {
2341 for(member = base->membersAndProperties.first; member; member = member->next)
2342 if(!member->isProperty)
2343 break;
2344 if(member)
2345 break;
2346 }
2347 }
2348 if(regClass->type == 1 && symbol->declaredStruct && member)
2349 {
2350 char baseStructName[1024];
2351
2352 baseStructName[0] = (char)0;
2353 strcpy(baseStructName, (regClass->base->templateClass ? regClass->base->templateClass : regClass->base)->fullName);
2354 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))))));
2355 }
2356 else
2357 ListAdd(args, symbol->declaredStruct ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(symbol->structName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2358 }
2359 else
2360 {
2361 ListAdd(args, MkExpConstant("0"));
2362 }
2363 {
2364 char classDataStructName[1024];
2365
2366 strcpy(classDataStructName, "__ecereClassData_");
2367 FullClassNameCat(classDataStructName, symbol->string, 0x0);
2368 ListAdd(args, symbol->classData ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(classDataStructName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2369 }
2370 if(regClass->type == 0 || regClass->type == 5)
2371 {
2372 ListAdd(args, symbol->needConstructor ? MkExpIdentifier(MkIdentifier(symbol->constructorName)) : MkExpConstant("0"));
2373 ListAdd(args, symbol->needDestructor ? MkExpIdentifier(MkIdentifier(symbol->destructorName)) : MkExpConstant("0"));
2374 }
2375 else
2376 {
2377 ListAdd(args, MkExpConstant("0"));
2378 ListAdd(args, MkExpConstant("0"));
2379 }
2380 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2381 switch(declMode)
2382 {
2383 case 3:
2384 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2385 break;
2386 case 2:
2387 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2388 break;
2389 case 1:
2390 default:
2391 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2392 break;
2393 }
2394 switch(inheritanceAccess)
2395 {
2396 case 2:
2397 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2398 break;
2399 case 1:
2400 default:
2401 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2402 break;
2403 }
2404 registerFunction = "eSystem_RegisterClass";
2405 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("class")), '=', MkExpCall((exp = MkExpIdentifier(MkIdentifier(registerFunction))), args))));
2406 ListAdd(registerModuleBody->compound.statements, stmt);
2407 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)));
2408 ListAdd(registerModuleBody->compound.statements, stmt);
2409 if(external && external->type == 2 && external->_class->deleteWatchable)
2410 {
2411 args = MkListOne(MkExpIdentifier(MkIdentifier("class")));
2412 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DestructionWatchable")), args)));
2413 ListAdd(registerModuleBody->compound.statements, stmt);
2414 }
2415 if(regClass->base)
2416 {
2417 struct __ecereNameSpace__ecere__com__Class * base = regClass->base;
2418 int c;
2419
2420 for(c = 0; c < base->vTblSize; c++)
2421 {
2422 struct Symbol * method = (struct Symbol *)regClass->_vTbl[c];
2423
2424 if((void *)method != DummyMethod && base->_vTbl[c] != (void *)method)
2425 {
2426 struct External * external = method->methodExternal;
2427 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2428 struct Identifier * id = external->function ? GetDeclId(external->function->declarator) : (((void *)0));
2429
2430 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2431 {
2432 char * string = QMkString(method->method->name);
2433
2434 ListAdd(args, MkExpString(string));
2435 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2436 }
2437 ListAdd(args, MkExpConstant("0"));
2438 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2439 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2440 exp->expType = __extension__ ({
2441 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2442
2443 __ecereInstance1->refCount = 1, __ecereInstance1;
2444 });
2445 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2446 ListAdd(registerModuleBody->compound.statements, stmt);
2447 }
2448 }
2449 }
2450 {
2451 int c;
2452
2453 for(c = regClass->base ? regClass->base->vTblSize : 0; c < regClass->vTblSize; c++)
2454 {
2455 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)))
2456 {
2457 if(method->type == 1 && method->_class == regClass && method->vid == c)
2458 {
2459 char name[1024];
2460 struct Expression * exp;
2461 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->methodCodeExternal : (((void *)0));
2462 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2463 struct Identifier * id = (external && external->function) ? GetDeclId(external->function->declarator) : (((void *)0));
2464
2465 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2466 {
2467 char * string = QMkString(method->name);
2468
2469 ListAdd(args, MkExpString(string));
2470 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2471 }
2472 {
2473 char * string = QMkString(method->dataTypeString);
2474
2475 ListAdd(args, MkExpString(string));
2476 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2477 }
2478 if(id && external->function->body)
2479 {
2480 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2481 exp->expType = __extension__ ({
2482 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2483
2484 __ecereInstance1->refCount = 1, __ecereInstance1;
2485 });
2486 }
2487 else
2488 {
2489 ListAdd(args, (exp = MkExpConstant("0")));
2490 }
2491 switch(method->memberAccess)
2492 {
2493 case 3:
2494 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2495 break;
2496 case 2:
2497 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2498 break;
2499 case 1:
2500 default:
2501 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2502 break;
2503 }
2504 strcpy(name, "__ecereVMethodID_");
2505 FullClassNameCat(name, method->_class->fullName, 0x0);
2506 strcat(name, "_");
2507 strcat(name, method->name);
2508 exp = MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddVirtualMethod")), args);
2509 stmt = MkExpressionStmt(MkListOne(exp));
2510 DeclareMethod(method, name);
2511 ListAdd(registerModuleBody->compound.statements, stmt);
2512 }
2513 }
2514 }
2515 }
2516 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)))
2517 {
2518 if(method->type == 1 && method->_class == regClass)
2519 ;
2520 else if(method->memberAccess == 1 || !method->dataTypeString)
2521 {
2522 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->methodCodeExternal : (((void *)0));
2523 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2524 struct Identifier * id = (external && external->function) ? GetDeclId(external->function->declarator) : (((void *)0));
2525
2526 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2527 {
2528 char * string = QMkString(method->name);
2529
2530 ListAdd(args, MkExpString(string));
2531 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2532 }
2533 {
2534 char * string = QMkString(method->dataTypeString);
2535
2536 ListAdd(args, MkExpString(string));
2537 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2538 }
2539 if(id && external->function->body)
2540 {
2541 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2542 exp->expType = __extension__ ({
2543 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2544
2545 __ecereInstance1->refCount = 1, __ecereInstance1;
2546 });
2547 }
2548 else
2549 {
2550 ListAdd(args, (exp = MkExpConstant("0")));
2551 }
2552 switch(method->memberAccess)
2553 {
2554 case 3:
2555 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2556 break;
2557 case 2:
2558 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2559 break;
2560 case 1:
2561 default:
2562 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2563 break;
2564 }
2565 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2566 ListAdd(registerModuleBody->compound.statements, stmt);
2567 }
2568 }
2569 RegisterMembersAndProperties(regClass, 0x0, "class", registerModuleBody);
2570 if(classType == 4)
2571 {
2572 struct __ecereNameSpace__ecere__sys__NamedLink * value;
2573 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2574 struct __ecereNameSpace__ecere__com__EnumClassData * e = (regClass ? ((void *)(((char *)regClass->data) + enumClass->offsetClass)) : (((void *)0)));
2575
2576 for(value = e->values.first; value; value = value->next)
2577 {
2578 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2579
2580 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2581 {
2582 char * string = QMkString(value->name);
2583
2584 ListAdd(args, MkExpString(string));
2585 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2586 }
2587 {
2588 char temp[1024];
2589
2590 sprintf(temp, "%d", (int)value->data);
2591 ListAdd(args, MkExpConstant(temp));
2592 }
2593 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eEnum_AddFixedValue")), args)));
2594 ListAdd(registerModuleBody->compound.statements, stmt);
2595 }
2596 }
2597 if(symbol->templateParams)
2598 {
2599 struct TemplateParameter * param;
2600
2601 for(param = (*symbol->templateParams).first; param; param = param->next)
2602 {
2603 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2604
2605 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2606 {
2607 char * string = QMkString(param->identifier->string);
2608
2609 ListAdd(args, MkExpString(string));
2610 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2611 }
2612 ListAdd(args, MkExpIdentifier(MkIdentifier((param->type == 0) ? "type" : ((param->type == 1) ? "identifier" : "expression"))));
2613 switch(param->type)
2614 {
2615 case 0:
2616 case 2:
2617 {
2618 char * typeString = param->dataType ? StringFromSpecDecl(param->dataType->specifiers, param->dataType->decl) : (((void *)0));
2619 char * string = QMkString(typeString);
2620
2621 ListAdd(args, MkExpString(string));
2622 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2623 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2624 break;
2625 }
2626 case 1:
2627 {
2628 char memberTypeString[132] = "TemplateMemberType::";
2629 unsigned int needClass = 0x1;
2630
2631 ((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);
2632 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(memberTypeString))));
2633 break;
2634 }
2635 }
2636 if(param->defaultArgument)
2637 {
2638 struct __ecereNameSpace__ecere__sys__OldList * members = MkList();
2639
2640 switch(param->type)
2641 {
2642 case 0:
2643 {
2644 char * typeString = param->defaultArgument->templateDatatype ? StringFromSpecDecl(param->defaultArgument->templateDatatype->specifiers, param->defaultArgument->templateDatatype->decl) : (((void *)0));
2645 char * string = QMkString(typeString);
2646
2647 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2648 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2649 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2650 break;
2651 }
2652 case 1:
2653 {
2654 char memberString[1024];
2655 char * string;
2656
2657 memberString[0] = '\0';
2658 if(param->defaultArgument->identifier->_class)
2659 {
2660 if(param->defaultArgument->identifier->_class->type == 8)
2661 strcpy(memberString, param->defaultArgument->identifier->_class->templateParameter->identifier->string);
2662 else if(param->defaultArgument->identifier->_class->name)
2663 strcpy(memberString, param->defaultArgument->identifier->_class->name);
2664 }
2665 if(memberString[0])
2666 strcat(memberString, "::");
2667 strcat(memberString, param->defaultArgument->identifier->string);
2668 string = QMkString(memberString);
2669 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2670 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2671 break;
2672 }
2673 case 2:
2674 {
2675 struct Operand op =
2676 {
2677 0, 0, 0, 0,
2678 {
2679 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
2680 }
2681 };
2682 struct __ecereNameSpace__ecere__sys__OldList * ids = MkList();
2683 char * ui64String;
2684 char * string = (((void *)0));
2685
2686 op = GetOperand(param->defaultArgument->expression);
2687 ui64String = PrintUInt64(op.ui64);
2688 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("expression"));
2689 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("ui64"));
2690 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
2691 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2692 (__ecereNameSpace__ecere__com__eSystem_Delete(ui64String), ui64String = 0);
2693 break;
2694 }
2695 }
2696 ListAdd(args, MkExpInstance(MkInstantiation(MkSpecifierName("ClassTemplateArgument"), (((void *)0)), MkListOne(MkMembersInitList(members)))));
2697 }
2698 else
2699 ListAdd(args, MkExpIdentifier(MkIdentifier("null")));
2700 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddTemplateParameter")), args)));
2701 ListAdd(registerModuleBody->compound.statements, stmt);
2702 }
2703 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DoneAddingTemplateParameters")), MkListOne(MkExpIdentifier(MkIdentifier("class"))))));
2704 ListAdd(registerModuleBody->compound.statements, stmt);
2705 }
2706 if(definitions != (((void *)0)))
2707 {
2708 for(def = definitions->first; def; def = def->next)
2709 {
2710 if(def->type == 4 && def->propertyWatch)
2711 {
2712 ListAdd(registerModuleBody->compound.statements, (struct Statement *)def->propertyWatch);
2713 def->propertyWatch = (((void *)0));
2714 }
2715 else if(def->type == 5)
2716 {
2717 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("designerClass")), '=', MkExpString(QMkString(def->designer))))), (((void *)0)));
2718 ListAdd(registerModuleBody->compound.statements, stmt);
2719 }
2720 else if(def->type == 6)
2721 {
2722 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("noExpansion")), '=', MkExpConstant("1")))), (((void *)0)));
2723 ListAdd(registerModuleBody->compound.statements, stmt);
2724 }
2725 else if(def->type == 7)
2726 {
2727 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("fixed")), '=', MkExpConstant("1")))), (((void *)0)));
2728 ListAdd(registerModuleBody->compound.statements, stmt);
2729 if(regClass)
2730 regClass->fixed = 0x1;
2731 }
2732 else if(def->type == 8)
2733 {
2734 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("defaultProperty")), '=', MkExpString(QMkString(def->defaultProperty->string))))), (((void *)0)));
2735 ListAdd(registerModuleBody->compound.statements, stmt);
2736 }
2737 else if(def->type == 11)
2738 {
2739 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2740
2741 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2742 ListAdd(args, MkExpString(QMkString(def->id->string)));
2743 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(INT64)), (((void *)0))), def->initializer->exp));
2744 def->initializer->exp = (((void *)0));
2745 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eClass_SetProperty")), args)));
2746 ListAdd(registerModuleBody->compound.statements, stmt);
2747 }
2748 }
2749 }
2750 }
2751 }
2752 }
2753
2754 extern int strcmp(const char * , const char * );
2755
2756 extern void PrintExpression(struct Expression * exp, char *  string);
2757
2758 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
2759
2760 void ProcessClassDefinitions()
2761 {
2762 struct External * external, * next;
2763
2764 CreateRegisterModuleBody();
2765 if(ast)
2766 {
2767 for(external = (*ast).first; external; external = next)
2768 {
2769 next = external->next;
2770 curExternal = external;
2771 if(external->type == 2)
2772 {
2773 struct ClassDefinition * _class = external->_class;
2774
2775 if(_class->definitions)
2776 {
2777 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), ast, external, _class->declMode);
2778 }
2779 if(inCompiler)
2780 {
2781 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2782 FreeExternal(external);
2783 }
2784 }
2785 else if(external->type == 0)
2786 {
2787 if(external->symbol && !external->symbol->type->thisClass)
2788 external->symbol->type->staticMethod = 0x1;
2789 if(inCompiler)
2790 {
2791 struct FunctionDefinition * function = external->function;
2792 struct Statement * stmt;
2793 struct __ecereNameSpace__ecere__sys__OldList * args;
2794
2795 if(!strcmp(function->declarator->symbol->string, "__on_register_module"))
2796 {
2797 ListAdd(registerModuleBody->compound.statements, function->body);
2798 function->body->compound.context->parent = registerModuleBody->compound.context;
2799 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2800 function->body = (((void *)0));
2801 FreeExternal(external);
2802 continue;
2803 }
2804 if(function->declMode != 2 && function->declMode != 1)
2805 continue;
2806 args = MkList();
2807 CreateRegisterModuleBody();
2808 {
2809 char * string = QMkString(function->declarator->symbol->string);
2810
2811 ListAdd(args, MkExpString(string));
2812 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2813 }
2814 {
2815 char * string;
2816 char type[1024] = "";
2817
2818 PrintType(function->declarator->symbol->type, type, 0x1, 0x1);
2819 string = QMkString(type);
2820 ListAdd(args, MkExpString(string));
2821 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2822 }
2823 {
2824 ListAdd(args, MkExpIdentifier(MkIdentifier(function->declarator->symbol->string)));
2825 }
2826 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2827 switch(function->declMode)
2828 {
2829 case 3:
2830 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2831 break;
2832 case 2:
2833 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2834 break;
2835 case 1:
2836 default:
2837 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2838 break;
2839 }
2840 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterFunction"))), args)));
2841 ListAdd(registerModuleBody->compound.statements, stmt);
2842 }
2843 }
2844 else if(external->type == 1)
2845 {
2846 struct Declaration * declaration = external->declaration;
2847
2848 if(external->symbol)
2849 {
2850 if(external->symbol->type && external->symbol->type->kind == 11 && !external->symbol->type->thisClass)
2851 external->symbol->type->staticMethod = 0x1;
2852 }
2853 if(external->symbol && declaration->type == 1)
2854 {
2855 if(declaration->specifiers)
2856 {
2857 struct Specifier * specifier;
2858 unsigned int removeExternal = 0x0;
2859
2860 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2861 {
2862 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2863 {
2864 struct Symbol * symbol = FindClass(specifier->id->string);
2865
2866 if(symbol)
2867 {
2868 int classType;
2869
2870 if(specifier->type == 2)
2871 classType = 4;
2872 else
2873 classType = 1;
2874 removeExternal = 0x1;
2875 symbol->ctx = specifier->ctx;
2876 specifier->ctx = (((void *)0));
2877 ProcessClass(classType, specifier->definitions, symbol, specifier->baseSpecs, specifier->list, ast, external, declaration->declMode);
2878 }
2879 }
2880 }
2881 if(inCompiler && removeExternal)
2882 {
2883 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2884 FreeExternal(external);
2885 }
2886 }
2887 }
2888 else if(declaration->type == 3)
2889 {
2890 if(inCompiler && declaration->declMode != 3)
2891 {
2892 struct Statement * stmt;
2893 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2894
2895 CreateRegisterModuleBody();
2896 {
2897 char * string = QMkString(declaration->id->string);
2898
2899 ListAdd(args, MkExpString(string));
2900 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2901 }
2902 {
2903 char * string;
2904 char type[1024] = "";
2905
2906 PrintExpression(declaration->exp, type);
2907 string = QMkString(type);
2908 ListAdd(args, MkExpString(string));
2909 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2910 }
2911 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2912 switch(declaration->declMode)
2913 {
2914 case 3:
2915 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2916 break;
2917 case 2:
2918 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2919 break;
2920 case 1:
2921 default:
2922 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2923 break;
2924 }
2925 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterDefine"))), args)));
2926 ListAdd(registerModuleBody->compound.statements, stmt);
2927 }
2928 }
2929 }
2930 }
2931 }
2932 }
2933
2934 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2935
2936 struct __ecereNameSpace__ecere__com__GlobalFunction;
2937
2938 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);
2939
2940 void __ecereRegisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
2941 {
2942 struct __ecereNameSpace__ecere__com__Class * class;
2943
2944 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereCom", "void SetBuildingEcereCom(bool b)", SetBuildingEcereCom, module, 1);
2945 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereCom", "bool GetBuildingEcereCom(void)", GetBuildingEcereCom, module, 1);
2946 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereComModule", "void SetBuildingEcereComModule(bool b)", SetBuildingEcereComModule, module, 1);
2947 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereComModule", "bool GetBuildingEcereComModule(void)", GetBuildingEcereComModule, module, 1);
2948 __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);
2949 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CreateRegisterModuleBody", "void CreateRegisterModuleBody(void)", CreateRegisterModuleBody, module, 2);
2950 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("RegisterMembersAndProperties", "void RegisterMembersAndProperties(ecere::com::Class regClass, bool isMember, char * className, Statement statement)", RegisterMembersAndProperties, module, 2);
2951 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetNameSpaceString", "void GetNameSpaceString(ecere::com::NameSpace ns, char * string)", GetNameSpaceString, module, 2);
2952 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessClassDefinitions", "void ProcessClassDefinitions(void)", ProcessClassDefinitions, module, 1);
2953 }
2954
2955 void __ecereUnregisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
2956 {
2957
2958 }
2959