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 int kind;
 744 unsigned int size;
 745 char *  name;
 746 char *  typeName;
 747 int classObjectType;
 748 int alignment;
 749 unsigned int offset;
 750 int bitFieldCount;
 751 int count;
 752 unsigned int isSigned : 1;
 753 unsigned int constant : 1;
 754 unsigned int truth : 1;
 755 unsigned int byReference : 1;
 756 unsigned int extraParam : 1;
 757 unsigned int directClassAccess : 1;
 758 unsigned int computing : 1;
 759 unsigned int keepCast : 1;
 760 unsigned int passAsTemplate : 1;
 761 unsigned int dllExport : 1;
 762 unsigned int attrStdcall : 1;
 763 } __attribute__ ((gcc_struct));
 764
 765 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 766
 767 struct __ecereNameSpace__ecere__com__Class
 768 {
 769 struct __ecereNameSpace__ecere__com__Class * prev;
 770 struct __ecereNameSpace__ecere__com__Class * next;
 771 char *  name;
 772 int offset;
 773 int structSize;
 774 int (* *  _vTbl)();
 775 int vTblSize;
 776 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 777 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 778 int offsetClass;
 779 int sizeClass;
 780 struct __ecereNameSpace__ecere__com__Class * base;
 781 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 782 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 783 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 784 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 785 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 786 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 787 int memberID;
 788 int startMemberID;
 789 int type;
 790 struct __ecereNameSpace__ecere__com__Instance * module;
 791 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 792 char *  dataTypeString;
 793 struct Type * dataType;
 794 int typeSize;
 795 int defaultAlignment;
 796 void (*  Initialize)();
 797 int memberOffset;
 798 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 799 char *  designerClass;
 800 unsigned int noExpansion;
 801 char *  defaultProperty;
 802 unsigned int comRedefinition;
 803 int count;
 804 unsigned int isRemote;
 805 unsigned int internalDecl;
 806 void *  data;
 807 unsigned int computeSize;
 808 int structAlignment;
 809 int destructionWatchOffset;
 810 unsigned int fixed;
 811 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 812 int inheritanceAccess;
 813 char *  fullName;
 814 void *  symbol;
 815 struct __ecereNameSpace__ecere__sys__OldList conversions;
 816 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 817 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 818 struct __ecereNameSpace__ecere__com__Class * templateClass;
 819 struct __ecereNameSpace__ecere__sys__OldList templatized;
 820 int numParams;
 821 unsigned int isInstanceClass;
 822 } __attribute__ ((gcc_struct));
 823
 824 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
 825
 826 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 827
 828 struct __ecereNameSpace__ecere__com__Instance
 829 {
 830 int (* *  _vTbl)();
 831 struct __ecereNameSpace__ecere__com__Class * _class;
 832 int _refCount;
 833 } __attribute__ ((gcc_struct));
 834
 835 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 836
 837 struct __ecereNameSpace__ecere__com__DataMember
 838 {
 839 struct __ecereNameSpace__ecere__com__DataMember * prev;
 840 struct __ecereNameSpace__ecere__com__DataMember * next;
 841 char *  name;
 842 unsigned int isProperty;
 843 int memberAccess;
 844 int id;
 845 struct __ecereNameSpace__ecere__com__Class * _class;
 846 char *  dataTypeString;
 847 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 848 struct Type * dataType;
 849 int type;
 850 int offset;
 851 int memberID;
 852 struct __ecereNameSpace__ecere__sys__OldList members;
 853 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 854 int memberOffset;
 855 int structAlignment;
 856 } __attribute__ ((gcc_struct));
 857
 858 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 859
 860 struct __ecereNameSpace__ecere__com__SerialBuffer
 861 {
 862 unsigned char *  _buffer;
 863 unsigned int count;
 864 unsigned int _size;
 865 unsigned int pos;
 866 } __attribute__ ((gcc_struct));
 867
 868 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 869
 870 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 871 {
 872 union
 873 {
 874 struct
 875 {
 876 char *  dataTypeString;
 877 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 878 } __attribute__ ((gcc_struct));
 879 struct __ecereNameSpace__ecere__com__DataValue expression;
 880 struct
 881 {
 882 char *  memberString;
 883 union
 884 {
 885 struct __ecereNameSpace__ecere__com__DataMember * member;
 886 struct __ecereNameSpace__ecere__com__Property * prop;
 887 struct __ecereNameSpace__ecere__com__Method * method;
 888 } __attribute__ ((gcc_struct));
 889 } __attribute__ ((gcc_struct));
 890 } __attribute__ ((gcc_struct));
 891 } __attribute__ ((gcc_struct));
 892
 893 enum yytokentype
 894 {
 895 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
 896 };
 897
 898 typedef union YYSTYPE
 899 {
 900 int specifierType;
 901 int i;
 902 int declMode;
 903 struct Identifier * id;
 904 struct Expression * exp;
 905 struct Specifier * specifier;
 906 struct __ecereNameSpace__ecere__sys__OldList * list;
 907 struct Enumerator * enumerator;
 908 struct Declarator * declarator;
 909 struct Pointer * pointer;
 910 struct Initializer * initializer;
 911 struct InitDeclarator * initDeclarator;
 912 struct TypeName * typeName;
 913 struct Declaration * declaration;
 914 struct Statement * stmt;
 915 struct FunctionDefinition * function;
 916 struct External * external;
 917 struct Context * context;
 918 struct AsmField * asmField;
 919 struct Attrib * attrib;
 920 struct ExtDecl * extDecl;
 921 struct Attribute * attribute;
 922 struct Instantiation * instance;
 923 struct MembersInit * membersInit;
 924 struct MemberInit * memberInit;
 925 struct ClassFunction * classFunction;
 926 struct ClassDefinition * _class;
 927 struct ClassDef * classDef;
 928 struct PropertyDef * prop;
 929 char * string;
 930 struct Symbol * symbol;
 931 struct PropertyWatch * propertyWatch;
 932 struct TemplateParameter * templateParameter;
 933 struct TemplateArgument * templateArgument;
 934 struct TemplateDatatype * templateDatatype;
 935 struct DBTableEntry * dbtableEntry;
 936 struct DBIndexItem * dbindexItem;
 937 struct DBTableDef * dbtableDef;
 938 } __attribute__ ((gcc_struct)) YYSTYPE;
 939
 940 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 941
 942 struct Enumerator
 943 {
 944 struct Enumerator * prev;
 945 struct Enumerator * next;
 946 struct Location loc;
 947 struct Identifier * id;
 948 struct Expression * exp;
 949 } __attribute__ ((gcc_struct));
 950
 951 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 952
 953 struct InitDeclarator;
 954
 955 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 956
 957 struct AsmField;
 958
 959 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 960
 961 struct Attribute;
 962
 963 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 964
 965 struct ClassFunction
 966 {
 967 struct ClassFunction * prev;
 968 struct ClassFunction * next;
 969 struct Location loc;
 970 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 971 struct Declarator * declarator;
 972 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 973 struct Statement * body;
 974 struct __ecereNameSpace__ecere__com__Class * _class;
 975 struct __ecereNameSpace__ecere__sys__OldList attached;
 976 int declMode;
 977 struct Type * type;
 978 struct Symbol * propSet;
 979 unsigned int isVirtual;
 980 unsigned int isConstructor;
 981 unsigned int isDestructor;
 982 unsigned int dontMangle;
 983 int id;
 984 int idCode;
 985 } __attribute__ ((gcc_struct));
 986
 987 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 988
 989 struct MembersInit;
 990
 991 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 992
 993 struct MemberInit;
 994
 995 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 996
 997 struct PropertyDef;
 998
 999 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1000
1001 struct PropertyWatch
1002 {
1003 struct PropertyWatch * prev;
1004 struct PropertyWatch * next;
1005 struct Location loc;
1006 struct Statement * compound;
1007 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1008 unsigned int deleteWatch;
1009 } __attribute__ ((gcc_struct));
1010
1011 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1012
1013 struct ClassDef
1014 {
1015 struct ClassDef * prev;
1016 struct ClassDef * next;
1017 struct Location loc;
1018 int type;
1019 union
1020 {
1021 struct Declaration * decl;
1022 struct ClassFunction * function;
1023 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1024 struct PropertyDef * propertyDef;
1025 struct PropertyWatch * propertyWatch;
1026 char *  designer;
1027 struct Identifier * defaultProperty;
1028 struct
1029 {
1030 struct Identifier * id;
1031 struct Initializer * initializer;
1032 } __attribute__ ((gcc_struct));
1033 } __attribute__ ((gcc_struct));
1034 int memberAccess;
1035 void *  object;
1036 } __attribute__ ((gcc_struct));
1037
1038 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1039
1040 struct DBTableEntry;
1041
1042 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1043
1044 struct DBIndexItem;
1045
1046 extern YYSTYPE yylval;
1047
1048 extern struct Location yylloc;
1049
1050 static struct Statement * registerModuleBody;
1051
1052 static struct External * registerModuleExternal;
1053
1054 static struct Statement * unregisterModuleBody;
1055
1056 static struct External * unregisterModuleExternal;
1057
1058 extern int propWatcherID;
1059
1060 unsigned int buildingECERECOM = 0x0;
1061
1062 void SetBuildingEcereCom(unsigned int b)
1063 {
1064 buildingECERECOM = b;
1065 }
1066
1067 unsigned int GetBuildingEcereCom()
1068 {
1069 return buildingECERECOM;
1070 }
1071
1072 unsigned int buildingECERECOMModule = 0x0;
1073
1074 void SetBuildingEcereComModule(unsigned int b)
1075 {
1076 buildingECERECOMModule = b;
1077 }
1078
1079 unsigned int GetBuildingEcereComModule()
1080 {
1081 return buildingECERECOMModule;
1082 }
1083
1084 extern struct Identifier * GetDeclId(struct Declarator * decl);
1085
1086 extern unsigned int inCompiler;
1087
1088 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1089
1090 extern struct Specifier * MkSpecifier(int specifier);
1091
1092 extern void ReplaceThisClassSpecifiers(struct __ecereNameSpace__ecere__sys__OldList * specs, struct __ecereNameSpace__ecere__com__Class * _class);
1093
1094 extern struct FunctionDefinition * _MkFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * declarationList, unsigned int errorOnOmit);
1095
1096 extern void ProcessFunctionBody(struct FunctionDefinition * func, struct Statement * body);
1097
1098 extern struct External * MkExternalFunction(struct FunctionDefinition * function);
1099
1100 extern void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
1101
1102 extern struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  FindTemplateArg(struct __ecereNameSpace__ecere__com__Class * _class, struct TemplateParameter * param);
1103
1104 extern struct Type * ProcessTypeString(char *  string, unsigned int staticMethod);
1105
1106 extern struct Symbol * FindClass(char *  name);
1107
1108 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);
1109
1110 extern void Compiler_Error(char *  format, ...);
1111
1112 extern char *  __ecereNameSpace__ecere__GetTranslatedString(struct __ecereNameSpace__ecere__com__Instance * module, char *  string, char *  stringAndContext);
1113
1114 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1115
1116 extern struct Declarator * GetFuncDecl(struct Declarator * decl);
1117
1118 extern void FreeType(struct Type * type);
1119
1120 extern void FreeExternal(struct External * external);
1121
1122 extern struct Context * globalContext;
1123
1124 extern struct __ecereNameSpace__ecere__sys__OldList *  excludedSymbols;
1125
1126 extern struct Declarator * CopyDeclarator(struct Declarator * declarator);
1127
1128 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
1129
1130 extern struct Specifier * CopySpecifier(struct Specifier * spec);
1131
1132 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1133
1134 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1135
1136 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1137
1138 struct External * ProcessClassFunction(struct __ecereNameSpace__ecere__com__Class * owningClass, struct ClassFunction * func, struct __ecereNameSpace__ecere__sys__OldList * defs, struct External * after, unsigned int makeStatic)
1139 {
1140 struct Identifier * id = GetDeclId(func->declarator);
1141 struct Type * type = (((void *)0));
1142 struct Symbol * symbol;
1143 struct External * external = (((void *)0));
1144
1145 if(defs && func->declarator)
1146 {
1147 struct FunctionDefinition * function = (((void *)0));
1148 struct Symbol * propSymbol;
1149 int symid = func->declarator->symbol->id;
1150 int symidCode = func->declarator->symbol->idCode;
1151
1152 if(inCompiler)
1153 {
1154 if(!func->specifiers)
1155 func->specifiers = MkList();
1156 if(makeStatic)
1157 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*func->specifiers), (((void *)0)), MkSpecifier(STATIC));
1158 }
1159 propSymbol = func->declarator->symbol;
1160 ReplaceThisClassSpecifiers(func->specifiers, owningClass);
1161 if(propSymbol->externalGet == (struct External *)func)
1162 func->declarator->symbol = (((void *)0));
1163 else if(propSymbol->externalSet == (struct External *)func)
1164 {
1165 func->declarator->symbol = (((void *)0));
1166 symid++;
1167 }
1168 else if(propSymbol->externalIsSet == (struct External *)func)
1169 {
1170 func->declarator->symbol = (((void *)0));
1171 symid += 2;
1172 }
1173 {
1174 function = _MkFunction(func->specifiers, func->declarator, (((void *)0)), 0x0);
1175 function->propSet = func->propSet;
1176 function->type = func->type;
1177 if(func->type)
1178 func->type->refCount++;
1179 ProcessFunctionBody(function, func->body);
1180 external = MkExternalFunction(function);
1181 external->symbol = func->declarator->symbol;
1182 external->function->_class = func->_class;
1183 }
1184 symbol = func->declarator->symbol;
1185 symbol->id = symid;
1186 symbol->idCode = symidCode;
1187 if(!func->dontMangle)
1188 {
1189 struct __ecereNameSpace__ecere__com__Method * method = func->declarator->symbol->method;
1190
1191 func->declarator->symbol->methodExternal = external;
1192 if(method && method->symbol)
1193 ((struct Symbol *)method->symbol)->methodCodeExternal = external;
1194 if(method && method->type == 1)
1195 {
1196 struct Type * methodDataType;
1197
1198 ProcessMethodType(method);
1199 methodDataType = method->dataType;
1200 type = symbol->type;
1201 if(!type->staticMethod && !type->thisClass && !type->thisClassTemplate)
1202 {
1203 if(method->dataType->thisClassTemplate)
1204 {
1205 if(owningClass->templateArgs)
1206 {
1207 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = FindTemplateArg(owningClass, method->dataType->thisClassTemplate);
1208
1209 type->byReference = method->dataType->byReference;
1210 methodDataType = ProcessTypeString(method->dataTypeString, 0x0);
1211 type->thisClass = methodDataType->thisClass = arg ? FindClass((*arg).dataTypeString) : (((void *)0));
1212 }
1213 }
1214 else if(method->dataType->staticMethod)
1215 type->staticMethod = 0x1;
1216 else if(method->dataType->thisClass)
1217 {
1218 type->thisClass = method->dataType->thisClass;
1219 type->byReference = method->dataType->byReference;
1220 }
1221 else
1222 {
1223 if(!owningClass->symbol)
1224 owningClass->symbol = FindClass(owningClass->fullName);
1225 type->thisClass = owningClass->symbol;
1226 type->extraParam = 0x1;
1227 }
1228 }
1229 yylloc = func->loc;
1230 if(!MatchTypes(type, methodDataType, (((void *)0)), owningClass, method->_class, 0x1, 0x1, 0x1, 0x0))
1231 {
1232 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Incompatible virtual function %s\n", (((void *)0))), method->name);
1233 }
1234 else
1235 {
1236 struct Type * typeParam;
1237 struct Declarator * funcDecl = GetFuncDecl(func->declarator);
1238
1239 if(funcDecl->function.parameters)
1240 {
1241 struct TypeName * param = (*funcDecl->function.parameters).first;
1242
1243 for(typeParam = methodDataType->params.first; typeParam; typeParam = typeParam->next)
1244 {
1245 if(typeParam->classObjectType)
1246 {
1247 param->classObjectType = typeParam->classObjectType;
1248 if(param->declarator && param->declarator->symbol)
1249 param->declarator->symbol->type->classObjectType = typeParam->classObjectType;
1250 }
1251 param = param->next;
1252 }
1253 }
1254 }
1255 if(methodDataType != method->dataType)
1256 FreeType(methodDataType);
1257 }
1258 else
1259 {
1260 type = symbol->type;
1261 if(!type->staticMethod && !type->thisClass)
1262 {
1263 if(owningClass && !owningClass->symbol)
1264 owningClass->symbol = FindClass(owningClass->fullName);
1265 type->thisClass = owningClass ? FindClass(owningClass->fullName) : (((void *)0));
1266 }
1267 }
1268 }
1269 else
1270 {
1271 if(symbol->type && !symbol->type->staticMethod && !symbol->type->thisClass)
1272 {
1273 if(!owningClass->symbol)
1274 owningClass->symbol = FindClass(owningClass->fullName);
1275 symbol->type->thisClass = owningClass->symbol;
1276 }
1277 if(propSymbol->externalSet == (struct External *)func && propSymbol->_property && propSymbol->_property->conversion)
1278 {
1279 if(symbol->type->thisClass && symbol->type->classObjectType != 1)
1280 {
1281 if(owningClass->type != 1)
1282 symbol->type->thisClass = (((void *)0));
1283 }
1284 }
1285 if(propSymbol->externalGet == (struct External *)func)
1286 {
1287 propSymbol->externalGet = external;
1288 }
1289 else if(propSymbol->externalSet == (struct External *)func)
1290 {
1291 propSymbol->externalSet = external;
1292 }
1293 else if(propSymbol->externalIsSet == (struct External *)func)
1294 {
1295 propSymbol->externalIsSet = external;
1296 }
1297 else
1298 {
1299 }
1300 }
1301 if(inCompiler)
1302 {
1303 if(func->body)
1304 {
1305 func->declarator = (((void *)0));
1306 func->specifiers = (((void *)0));
1307 func->body = (((void *)0));
1308 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1309 }
1310 else
1311 {
1312 struct __ecereNameSpace__ecere__com__Method * method = func->declarator->symbol->method;
1313
1314 if(method && method->symbol)
1315 ((struct Symbol *)method->symbol)->methodCodeExternal = (((void *)0));
1316 func->declarator = (((void *)0));
1317 func->specifiers = (((void *)0));
1318 FreeExternal(external);
1319 }
1320 }
1321 else
1322 {
1323 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)symbol);
1324 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), symbol);
1325 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1326 external->function->declarator = CopyDeclarator(external->function->declarator);
1327 external->function->specifiers = CopyList(external->function->specifiers, CopySpecifier);
1328 external->function->body = (((void *)0));
1329 }
1330 }
1331 return external;
1332 }
1333
1334 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1335
1336 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
1337
1338 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1339
1340 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1341
1342 extern struct Specifier * MkSpecifierName(char *  name);
1343
1344 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1345
1346 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1347
1348 extern struct Identifier * MkIdentifier(char *  string);
1349
1350 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1351
1352 extern char *  __ecereNameSpace__ecere__sys__GetLastDirectory(char *  string, char *  output);
1353
1354 extern char *  outputFile;
1355
1356 extern unsigned int __ecereNameSpace__ecere__sys__StripExtension(char *  string);
1357
1358 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
1359
1360 extern int sprintf(char * , char * , ...);
1361
1362 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
1363
1364 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
1365
1366 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1367
1368 void CreateRegisterModuleBody()
1369 {
1370 if(!registerModuleBody && inCompiler)
1371 {
1372 char registerName[1024], moduleName[274];
1373 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1374 struct Declarator * declarator;
1375 struct TypeName * moduleParam;
1376
1377 registerModuleBody = MkCompoundStmt(MkList(), MkList());
1378 registerModuleBody->compound.context = __extension__ ({
1379 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1380
1381 __ecereInstance1->parent = globalContext, __ecereInstance1;
1382 });
1383 ListAdd(registerModuleBody->compound.declarations, MkDeclaration(MkListOne(MkSpecifierName("ecere::com::Class")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("class")), (((void *)0))))));
1384 specifiers = MkList();
1385 ListAdd(specifiers, MkSpecifier(VOID));
1386 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
1387 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1388 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1389 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '.', '_');
1390 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, ' ', '_');
1391 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '-', '_');
1392 sprintf(registerName, "__ecereRegisterModule_%s", moduleName);
1393 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
1394 {
1395 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0x0);
1396
1397 ProcessFunctionBody(function, registerModuleBody);
1398 function->declMode = 0;
1399 if(!ast)
1400 ast = MkList();
1401 ListAdd(ast, (registerModuleExternal = MkExternalFunction(function)));
1402 }
1403 }
1404 if(!unregisterModuleBody && inCompiler)
1405 {
1406 char registerName[1024], moduleName[274];
1407 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1408 struct Declarator * declarator;
1409 struct TypeName * moduleParam;
1410
1411 unregisterModuleBody = MkCompoundStmt(MkList(), MkList());
1412 unregisterModuleBody->compound.context = __extension__ ({
1413 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1414
1415 __ecereInstance1->parent = globalContext, __ecereInstance1;
1416 });
1417 specifiers = MkList();
1418 ListAdd(specifiers, MkSpecifier(VOID));
1419 moduleParam = MkTypeName(MkListOne(MkSpecifierName("Module")), MkDeclaratorIdentifier(MkIdentifier("module")));
1420 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1421 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1422 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '.', '_');
1423 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, ' ', '_');
1424 __ecereNameSpace__ecere__sys__ChangeCh(moduleName, '-', '_');
1425 sprintf(registerName, "__ecereUnregisterModule_%s", moduleName);
1426 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), MkListOne(moduleParam));
1427 {
1428 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0x0);
1429
1430 ProcessFunctionBody(function, unregisterModuleBody);
1431 function->declMode = 0;
1432 if(!ast)
1433 ast = MkList();
1434 ListAdd(ast, (unregisterModuleExternal = MkExternalFunction(function)));
1435 }
1436 }
1437 }
1438
1439 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1440
1441 extern struct Expression * MkExpConstant(char *  string);
1442
1443 extern char *  QMkString(char *  source);
1444
1445 extern struct Expression * MkExpString(char *  string);
1446
1447 extern char *  strcpy(char * , const char * );
1448
1449 extern void FullClassNameCat(char *  output, char *  className, unsigned int includeTemplateParams);
1450
1451 extern char *  strcat(char * , const char * );
1452
1453 extern void MangleClassName(char *  className);
1454
1455 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1456
1457 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1458
1459 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1460
1461 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1462
1463 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1464
1465 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1466
1467 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1468
1469 extern struct Expression * CopyExpression(struct Expression * exp);
1470
1471 extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
1472
1473 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1474
1475 struct __ecereNameSpace__ecere__com__BitMember
1476 {
1477 struct __ecereNameSpace__ecere__com__BitMember * prev;
1478 struct __ecereNameSpace__ecere__com__BitMember * next;
1479 char *  name;
1480 unsigned int isProperty;
1481 int memberAccess;
1482 int id;
1483 struct __ecereNameSpace__ecere__com__Class * _class;
1484 char *  dataTypeString;
1485 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1486 struct Type * dataType;
1487 int type;
1488 int size;
1489 int pos;
1490 uint64 mask;
1491 } __attribute__ ((gcc_struct));
1492
1493 extern int ComputeTypeSize(struct Type * type);
1494
1495 extern struct Context * curContext;
1496
1497 extern struct Context * PushContext(void);
1498
1499 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
1500
1501 extern void PopContext(struct Context * ctx);
1502
1503 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
1504
1505 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1506
1507 struct __ecereNameSpace__ecere__com__ClassProperty
1508 {
1509 char *  name;
1510 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1511 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1512 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1513 int depth;
1514 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1515 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1516 char *  dataTypeString;
1517 struct Type * dataType;
1518 unsigned int constant;
1519 } __attribute__ ((gcc_struct));
1520
1521 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(struct __ecereNameSpace__ecere__sys__BinaryTree * this);
1522
1523 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_first;
1524
1525 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(struct __ecereNameSpace__ecere__sys__BTNode * this);
1526
1527 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BTNode_next;
1528
1529 void RegisterMembersAndProperties(struct __ecereNameSpace__ecere__com__Class * regClass, unsigned int isMember, char * className, struct Statement * statement)
1530 {
1531 struct __ecereNameSpace__ecere__com__DataMember * dataMember = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)regClass : (((void *)0));
1532 struct __ecereNameSpace__ecere__com__DataMember * member;
1533 struct __ecereNameSpace__ecere__com__Property * prop;
1534 struct Expression * exp;
1535 struct Statement * stmt;
1536 char dataMemberSize[16];
1537 unsigned int lastOffset = 0;
1538 int privateID = 0;
1539 unsigned int privateMembers = 0x0;
1540
1541 sprintf(dataMemberSize, "%d", (int)sizeof(struct __ecereNameSpace__ecere__com__DataMember *));
1542 if(!isMember)
1543 {
1544 for(prop = regClass->conversions.first; prop; prop = prop->next)
1545 {
1546 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1547 char name[1024];
1548
1549 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1550 ListAdd(args, MkExpConstant("0"));
1551 {
1552 char * string = QMkString(prop->dataTypeString);
1553
1554 ListAdd(args, MkExpString(string));
1555 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1556 }
1557 if(prop->Set)
1558 {
1559 strcpy(name, "__ecereProp_");
1560 FullClassNameCat(name, regClass->fullName, 0x0);
1561 strcat(name, "_Set_");
1562 FullClassNameCat(name, prop->name, 0x1);
1563 MangleClassName(name);
1564 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1565 }
1566 else
1567 ListAdd(args, MkExpConstant("0"));
1568 if(prop->Get)
1569 {
1570 strcpy(name, "__ecereProp_");
1571 FullClassNameCat(name, regClass->fullName, 0x0);
1572 strcat(name, "_Get_");
1573 FullClassNameCat(name, prop->name, 0x1);
1574 MangleClassName(name);
1575 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1576 }
1577 else
1578 ListAdd(args, MkExpConstant("0"));
1579 switch(prop->memberAccess)
1580 {
1581 case 3:
1582 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1583 break;
1584 case 2:
1585 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1586 break;
1587 case 1:
1588 default:
1589 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1590 break;
1591 }
1592 strcpy(name, "__ecereProp_");
1593 FullClassNameCat(name, regClass->fullName, 0x0);
1594 strcat(name, "_");
1595 FullClassNameCat(name, prop->name, 0x1);
1596 MangleClassName(name);
1597 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1598 ListAdd(registerModuleBody->compound.statements, stmt);
1599 }
1600 }
1601 for(member = isMember ? dataMember->members.first : regClass->membersAndProperties.first; member; member = member->next)
1602 {
1603 if(member->isProperty)
1604 {
1605 prop = (struct __ecereNameSpace__ecere__com__Property *)member;
1606 {
1607 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1608 char name[1024], nameM[1024];
1609 char * string = QMkString(prop->name);
1610
1611 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1612 ListAdd(args, MkExpString(string));
1613 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1614 {
1615 char * string = QMkString(prop->dataTypeString);
1616
1617 ListAdd(args, MkExpString(string));
1618 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1619 }
1620 if(prop->Set)
1621 {
1622 strcpy(name, "__ecereProp_");
1623 FullClassNameCat(name, regClass->fullName, 0x0);
1624 strcat(name, "_Set_");
1625 FullClassNameCat(name, prop->name, 0x1);
1626 MangleClassName(name);
1627 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1628 }
1629 else
1630 ListAdd(args, MkExpConstant("0"));
1631 if(prop->Get)
1632 {
1633 strcpy(name, "__ecereProp_");
1634 FullClassNameCat(name, regClass->fullName, 0x0);
1635 strcat(name, "_Get_");
1636 FullClassNameCat(name, prop->name, 0x1);
1637 MangleClassName(name);
1638 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1639 }
1640 else
1641 ListAdd(args, MkExpConstant("0"));
1642 switch(prop->memberAccess)
1643 {
1644 case 3:
1645 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1646 break;
1647 case 2:
1648 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1649 break;
1650 case 1:
1651 default:
1652 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1653 break;
1654 }
1655 strcpy(name, "__ecereProp_");
1656 FullClassNameCat(name, regClass->fullName, 0x0);
1657 strcat(name, "_");
1658 FullClassNameCat(name, prop->name, 0x1);
1659 MangleClassName(name);
1660 strcpy(nameM, "__ecerePropM_");
1661 FullClassNameCat(nameM, regClass->fullName, 0x0);
1662 strcat(nameM, "_");
1663 FullClassNameCat(nameM, prop->name, 0x1);
1664 MangleClassName(nameM);
1665 if(prop->dataTypeString)
1666 {
1667 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args))));
1668 }
1669 else
1670 {
1671 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddProperty")), args)));
1672 }
1673 ListAdd(registerModuleBody->compound.statements, stmt);
1674 if(prop->IsSet)
1675 {
1676 char name[1024];
1677
1678 strcpy(name, "__ecereProp_");
1679 FullClassNameCat(name, regClass->fullName, 0x1);
1680 strcat(name, "_IsSet_");
1681 FullClassNameCat(name, prop->name, 0x0);
1682 MangleClassName(name);
1683 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))))));
1684 ListAdd(registerModuleBody->compound.statements, stmt);
1685 }
1686 if(prop->symbol && ((struct Symbol *)prop->symbol)->propCategory)
1687 {
1688 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier(nameM)), MkIdentifier("category")), '=', CopyExpression(((struct Symbol *)prop->symbol)->propCategory))));
1689 ListAdd(registerModuleBody->compound.statements, stmt);
1690 }
1691 if(prop->dataTypeString)
1692 {
1693 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1694
1695 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', MkExpIdentifier(MkIdentifier(nameM))));
1696 ListAdd(list, MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0"))));
1697 stmt = MkIfStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("module")), MkIdentifier("application")), EQ_OP, MkExpMember(MkExpIdentifier(MkIdentifier("__thisModule")), MkIdentifier("application")))), MkExpressionStmt(list), (((void *)0)));
1698 ListAdd(registerModuleBody->compound.statements, stmt);
1699 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(nameM)), '=', MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")))));
1700 ListAdd(unregisterModuleBody->compound.statements, stmt);
1701 }
1702 }
1703 }
1704 else if(member->type == 0 && !isMember && regClass->type == 2)
1705 {
1706 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)member;
1707 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1708
1709 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1710 {
1711 char * string = QMkString(bitMember->name);
1712
1713 ListAdd(args, MkExpString(string));
1714 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1715 }
1716 {
1717 char * string = QMkString(bitMember->dataTypeString);
1718
1719 ListAdd(args, MkExpString(string));
1720 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1721 }
1722 {
1723 char string[256];
1724
1725 sprintf(string, "%d", bitMember->size);
1726 ListAdd(args, (exp = MkExpConstant(string)));
1727 }
1728 {
1729 char string[256];
1730
1731 sprintf(string, "%d", bitMember->pos);
1732 ListAdd(args, (exp = MkExpConstant(string)));
1733 }
1734 switch(member->memberAccess)
1735 {
1736 case 3:
1737 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1738 break;
1739 case 2:
1740 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1741 break;
1742 case 1:
1743 default:
1744 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1745 break;
1746 }
1747 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddBitMember")), args)));
1748 ListAdd(statement->compound.statements, stmt);
1749 }
1750 else if(member->memberAccess == 1 || (member->type == 0 && !member->dataTypeString))
1751 {
1752 struct __ecereNameSpace__ecere__sys__OldList * args;
1753
1754 if(privateMembers)
1755 {
1756 unsigned int offset = member->offset - lastOffset;
1757
1758 args = MkList();
1759 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1760 {
1761 char string[200];
1762
1763 sprintf(string, "\"__ecerePrivateData%d\"", privateID++);
1764 ListAdd(args, MkExpString(string));
1765 }
1766 {
1767 char string[200];
1768
1769 sprintf(string, "\"byte[%d]\"", offset);
1770 ListAdd(args, MkExpString(string));
1771 }
1772 {
1773 char string[256];
1774
1775 sprintf(string, "%d", offset);
1776 ListAdd(args, (exp = MkExpConstant(string)));
1777 }
1778 ListAdd(args, (exp = MkExpConstant("1")));
1779 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1780 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
1781 ListAdd(statement->compound.statements, stmt);
1782 privateMembers = 0x0;
1783 }
1784 if(member->type == 0)
1785 {
1786 if(!member->dataType)
1787 member->dataType = ProcessTypeString(member->dataTypeString, 0x0);
1788 ComputeTypeSize(member->dataType);
1789 args = MkList();
1790 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1791 {
1792 char * string = QMkString(member->name);
1793
1794 ListAdd(args, MkExpString(string));
1795 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1796 }
1797 {
1798 char * string = QMkString(member->dataTypeString);
1799
1800 ListAdd(args, MkExpString(string));
1801 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1802 }
1803 {
1804 char string[256];
1805
1806 sprintf(string, "%d", member->dataType->size);
1807 ListAdd(args, (exp = MkExpConstant(string)));
1808 }
1809 {
1810 char string[256];
1811
1812 sprintf(string, "%d", member->dataType->alignment);
1813 ListAdd(args, (exp = MkExpConstant(string)));
1814 }
1815 switch(member->memberAccess)
1816 {
1817 case 3:
1818 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1819 break;
1820 case 2:
1821 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1822 break;
1823 case 1:
1824 default:
1825 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1826 break;
1827 }
1828 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier(isMember ? "eMember_AddDataMember" : "eClass_AddDataMember")), args)));
1829 ListAdd(statement->compound.statements, stmt);
1830 lastOffset = member->offset + member->dataType->size;
1831 }
1832 else
1833 {
1834 static int memberCount = 0;
1835 struct Context * context;
1836 struct Statement * compound;
1837 char memberName[256];
1838
1839 sprintf(memberName, "dataMember%d", memberCount);
1840 memberCount++;
1841 curContext = statement->compound.context;
1842 context = PushContext();
1843 args = MkListOne(MkExpIdentifier(MkIdentifier((member->type == 1) ? "unionMember" : "structMember")));
1844 switch(member->memberAccess)
1845 {
1846 case 3:
1847 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
1848 break;
1849 case 2:
1850 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
1851 break;
1852 case 1:
1853 default:
1854 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
1855 break;
1856 }
1857 compound = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifierName("DataMember")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(memberName)), MkInitializerAssignment(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_New")), args)))))), MkList());
1858 compound->compound.context = context;
1859 args = MkList();
1860 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1861 ListAdd(args, MkExpIdentifier(MkIdentifier(memberName)));
1862 RegisterMembersAndProperties((struct __ecereNameSpace__ecere__com__Class *)member, 0x1, memberName, compound);
1863 if(isMember)
1864 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eMember_AddMember")), args)));
1865 else
1866 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMember")), args)));
1867 ListAdd(compound->compound.statements, stmt);
1868 PopContext(context);
1869 ListAdd(statement->compound.statements, compound);
1870 memberCount--;
1871 lastOffset = member->offset + member->memberOffset;
1872 }
1873 }
1874 else
1875 privateMembers = 0x1;
1876 }
1877 if(!isMember)
1878 {
1879 struct __ecereNameSpace__ecere__com__ClassProperty * classProperty;
1880
1881 for(prop = regClass->membersAndProperties.first; prop; prop = prop->next)
1882 {
1883 if(prop->isProperty && prop->isWatchable)
1884 {
1885 struct __ecereNameSpace__ecere__sys__OldList * args;
1886 char name[1024], nameM[1024];
1887
1888 strcpy(name, "__ecereProp_");
1889 FullClassNameCat(name, regClass->fullName, 0x1);
1890 strcat(name, "_");
1891 FullClassNameCat(name, prop->name, 0x0);
1892 MangleClassName(name);
1893 strcpy(nameM, "__ecerePropM_");
1894 FullClassNameCat(nameM, regClass->fullName, 0x1);
1895 strcat(nameM, "_");
1896 FullClassNameCat(nameM, prop->name, 0x0);
1897 MangleClassName(nameM);
1898 args = MkListOne(MkExpCondition(MkExpIdentifier(MkIdentifier(nameM)), MkListOne(MkExpIdentifier(MkIdentifier(nameM))), MkExpIdentifier(MkIdentifier(name))));
1899 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_Watchable")), args)));
1900 ListAdd(registerModuleBody->compound.statements, stmt);
1901 }
1902 }
1903 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)))
1904 {
1905 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1906 char name[1024];
1907 char * string = QMkString(classProperty->name);
1908
1909 ListAdd(args, MkExpIdentifier(MkIdentifier(className)));
1910 ListAdd(args, MkExpString(string));
1911 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1912 {
1913 char * string = QMkString(classProperty->dataTypeString);
1914
1915 ListAdd(args, MkExpString(string));
1916 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
1917 }
1918 if(classProperty->Set)
1919 {
1920 strcpy(name, "__ecereClassProp_");
1921 FullClassNameCat(name, regClass->fullName, 0x1);
1922 strcat(name, "_Set_");
1923 strcat(name, classProperty->name);
1924 MangleClassName(name);
1925 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1926 }
1927 else
1928 ListAdd(args, MkExpConstant("0"));
1929 if(classProperty->Get)
1930 {
1931 strcpy(name, "__ecereClassProp_");
1932 FullClassNameCat(name, regClass->fullName, 0x1);
1933 strcat(name, "_Get_");
1934 strcat(name, classProperty->name);
1935 MangleClassName(name);
1936 ListAdd(args, MkExpIdentifier(MkIdentifier(name)));
1937 }
1938 else
1939 ListAdd(args, MkExpConstant("0"));
1940 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddClassProperty")), args)));
1941 ListAdd(registerModuleBody->compound.statements, stmt);
1942 }
1943 }
1944 }
1945
1946 extern struct External * curExternal;
1947
1948 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
1949
1950 struct __ecereNameSpace__ecere__com__NameSpace
1951 {
1952 char *  name;
1953 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1954 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1955 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1956 int depth;
1957 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1958 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1959 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1960 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1961 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1962 } __attribute__ ((gcc_struct));
1963
1964 void GetNameSpaceString(struct __ecereNameSpace__ecere__com__NameSpace * ns, char * string)
1965 {
1966 if(ns->parent)
1967 GetNameSpaceString(ns->parent, string);
1968 if(ns->name)
1969 {
1970 strcat(string, ns->name);
1971 strcat(string, "::");
1972 }
1973 }
1974
1975 extern unsigned int parsingType;
1976
1977 extern void ProcessExpressionType(struct Expression * exp);
1978
1979 extern void ComputeExpression(struct Expression * exp);
1980
1981 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
1982
1983 struct OpTable
1984 {
1985 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1986 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1987 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1988 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1989 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1990 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1991 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1992 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1993 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1994 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1995 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1996 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1997 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1998 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1999 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
2000 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
2001 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
2002 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
2003 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
2004 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
2005 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
2006 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
2007 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
2008 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
2009 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
2010 unsigned int (*  Not)(struct Expression *, struct Operand *);
2011 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
2012 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
2013 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
2014 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
2015 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
2016 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
2017 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
2018 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
2019 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
2020 } __attribute__ ((gcc_struct));
2021
2022 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
2023
2024 struct Operand
2025 {
2026 int kind;
2027 struct Type * type;
2028 unsigned int ptrSize;
2029 union
2030 {
2031 char c;
2032 unsigned char uc;
2033 short s;
2034 unsigned short us;
2035 int i;
2036 unsigned int ui;
2037 float f;
2038 double d;
2039 long long i64;
2040 uint64 ui64;
2041 } __attribute__ ((gcc_struct));
2042 struct OpTable ops;
2043 } __attribute__ ((gcc_struct));
2044
2045 extern struct Operand GetOperand(struct Expression * exp);
2046
2047 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string, int value);
2048
2049 extern int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string);
2050
2051 extern struct ClassFunction * MkClassFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Specifier * _class, struct Declarator * decl, struct __ecereNameSpace__ecere__sys__OldList * declList);
2052
2053 extern void ProcessClassFunctionBody(struct ClassFunction * func, struct Statement * body);
2054
2055 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
2056
2057 extern struct ClassDef * MkClassDefFunction(struct ClassFunction * function);
2058
2059 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);
2060
2061 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
2062
2063 extern void FreePropertyWatch(struct PropertyWatch * watcher);
2064
2065 extern char *  sourceFile;
2066
2067 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2068
2069 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
2070
2071 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
2072
2073 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
2074
2075 extern unsigned int DummyMethod(void);
2076
2077 extern void DeclareMethod(struct __ecereNameSpace__ecere__com__Method * method, char *  name);
2078
2079 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
2080
2081 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
2082
2083 struct __ecereNameSpace__ecere__com__EnumClassData
2084 {
2085 struct __ecereNameSpace__ecere__sys__OldList values;
2086 int largest;
2087 } __attribute__ ((gcc_struct));
2088
2089 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink;
2090
2091 struct __ecereNameSpace__ecere__sys__NamedLink
2092 {
2093 struct __ecereNameSpace__ecere__sys__NamedLink * prev;
2094 struct __ecereNameSpace__ecere__sys__NamedLink * next;
2095 char *  name;
2096 void *  data;
2097 } __attribute__ ((gcc_struct));
2098
2099 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2100
2101 extern size_t strlen(const char * );
2102
2103 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
2104
2105 extern char *  PrintUInt64(uint64 result);
2106
2107 extern struct Expression * MkExpInstance(struct Instantiation * inst);
2108
2109 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
2110
2111 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
2112
2113 int __ecereVMethodID_class_OnGetString;
2114
2115 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType;
2116
2117 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)
2118 {
2119 struct ClassDef * def;
2120 struct __ecereNameSpace__ecere__com__Class * regClass = symbol->registered;
2121
2122 if(regClass)
2123 {
2124 classType = regClass->type;
2125 if(classType == 4 && enumValues && (inCompiler || !buildingECERECOMModule))
2126 {
2127 struct Enumerator * e;
2128
2129 for(e = enumValues->first; e; e = e->next)
2130 {
2131 if(e->exp)
2132 {
2133 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->kind = 3, destType->refCount = 1, destType);
2134
2135 e->exp->destType = destType;
2136 parsingType = 0x1;
2137 ProcessExpressionType(e->exp);
2138 parsingType = 0x0;
2139 if(!e->exp->expType)
2140 {
2141 destType->kind = 8;
2142 destType->_class = symbol;
2143 ProcessExpressionType(e->exp);
2144 }
2145 ComputeExpression(e->exp);
2146 if(e->exp->isConstant && e->exp->type == 2)
2147 {
2148 struct Operand op = GetOperand(e->exp);
2149 int value;
2150
2151 switch(op.kind)
2152 {
2153 case 1:
2154 value = op.c;
2155 break;
2156 case 2:
2157 value = op.s;
2158 break;
2159 default:
2160 value = op.i;
2161 }
2162 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
2163 }
2164 else
2165 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2166 }
2167 else
2168 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2169 }
2170 }
2171 if(definitions != (((void *)0)))
2172 {
2173 if(inCompiler)
2174 {
2175 for(def = definitions->first; def; def = def->next)
2176 {
2177 if(def->type == 4 && def->propertyWatch)
2178 {
2179 struct PropertyWatch * propWatch = def->propertyWatch;
2180 struct ClassFunction * func;
2181 char watcherName[1024];
2182 struct Identifier * propID;
2183 struct Statement * stmt = MkExpressionStmt(MkList());
2184 struct Declarator * decl;
2185
2186 sprintf(watcherName, "__ecerePropertySelfWatcher_%d", propWatcherID++);
2187 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2188 {
2189 strcat(watcherName, "_");
2190 strcat(watcherName, propID->string);
2191 }
2192 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifier(VOID)), (((void *)0)))));
2193 func = MkClassFunction(MkListOne(MkSpecifier(VOID)), (((void *)0)), decl, (((void *)0)));
2194 ProcessClassFunctionBody(func, propWatch->compound);
2195 decl->symbol = __extension__ ({
2196 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2197
2198 __ecereInstance1->id = symbol->id, __ecereInstance1->idCode = symbol->idCode, __ecereInstance1;
2199 });
2200 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
2201 func->id = symbol->id;
2202 func->idCode = symbol->idCode;
2203 func->dontMangle = 0x1;
2204 {
2205 struct External * externalDecl = MkExternalDeclaration((((void *)0)));
2206 struct Declaration * decl;
2207 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2208
2209 ListAdd(specifiers, MkSpecifier(STATIC));
2210 ListAdd(specifiers, MkSpecifier(VOID));
2211 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, externalDecl);
2212 decl = MkDeclaration(specifiers, MkListOne(MkInitDeclarator(MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifierName(regClass->fullName)), (((void *)0))))), (((void *)0)))));
2213 externalDecl->declaration = decl;
2214 if(decl->symbol && !decl->symbol->methodExternal)
2215 {
2216 decl->symbol->methodExternal = externalDecl;
2217 decl->symbol->id = symbol->id;
2218 decl->symbol->idCode = symbol->idCode;
2219 }
2220 }
2221 propWatch->compound = (((void *)0));
2222 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(func));
2223 stmt->type = 3;
2224 stmt->expressions = MkList();
2225 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
2226 {
2227 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, propID->string, privateModule);
2228
2229 if(prop)
2230 {
2231 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2232
2233 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2234 ListAdd(args, MkExpString(QMkString(propID->string)));
2235 ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
2236 ListAdd(stmt->expressions, MkExpCall(MkExpIdentifier(MkIdentifier("eProperty_SelfWatch")), args));
2237 }
2238 else
2239 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Property %s not found in class %s\n", (((void *)0))), propID->string, regClass->fullName);
2240 }
2241 FreePropertyWatch(def->propertyWatch);
2242 def->propertyWatch = (struct PropertyWatch *)stmt;
2243 }
2244 }
2245 }
2246 for(def = definitions->first; def; def = def->next)
2247 {
2248 if(def->type == 0)
2249 {
2250 ProcessClassFunction(regClass, def->function, defs, external->prev, declMode == 3);
2251 }
2252 }
2253 }
2254 if(inCompiler && symbol->id != (((int)0x7fffffff)) && regClass)
2255 {
2256 struct Statement * stmt;
2257 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2258 struct __ecereNameSpace__ecere__com__Method * method;
2259 struct Expression * exp;
2260 char * registerFunction = (((void *)0));
2261 int inheritanceAccess = 1;
2262
2263 CreateRegisterModuleBody();
2264 curExternal = registerModuleExternal;
2265 switch(regClass->type)
2266 {
2267 case 1:
2268 ListAdd(args, MkExpIdentifier(MkIdentifier("structClass")));
2269 break;
2270 case 2:
2271 ListAdd(args, MkExpIdentifier(MkIdentifier("bitClass")));
2272 break;
2273 case 4:
2274 ListAdd(args, MkExpIdentifier(MkIdentifier("enumClass")));
2275 break;
2276 case 5:
2277 ListAdd(args, MkExpIdentifier(MkIdentifier("noHeadClass")));
2278 break;
2279 case 3:
2280 ListAdd(args, MkExpIdentifier(MkIdentifier("unitClass")));
2281 break;
2282 case 0:
2283 ListAdd(args, MkExpIdentifier(MkIdentifier("normalClass")));
2284 break;
2285 }
2286 {
2287 char nameSpace[1024] = "";
2288 char className[1024] = "";
2289 char * string;
2290
2291 GetNameSpaceString(regClass->nameSpace, nameSpace);
2292 if(declMode == 3)
2293 {
2294 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, className);
2295 __ecereNameSpace__ecere__sys__ChangeCh(className, '.', '_');
2296 strcat(className, "}");
2297 }
2298 strcat(className, nameSpace);
2299 strcat(className, regClass->name);
2300 string = QMkString(className);
2301 ListAdd(args, MkExpString(string));
2302 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2303 }
2304 if(baseSpecs != (((void *)0)))
2305 {
2306 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
2307
2308 if(baseType->kind != 9 && baseType->kind != 10)
2309 {
2310 char baseName[1024] = "";
2311 char * string;
2312
2313 if(baseType->kind == 8 && baseType->_class && baseType->_class->isStatic)
2314 {
2315 __ecereNameSpace__ecere__sys__GetLastDirectory(sourceFile, baseName);
2316 __ecereNameSpace__ecere__sys__ChangeCh(baseName, '.', '_');
2317 strcat(baseName, "}");
2318 strcat(baseName, baseType->_class->string);
2319 }
2320 else
2321 PrintType(baseType, baseName, 0x0, 0x1);
2322 string = QMkString(baseName);
2323 ListAdd(args, MkExpString(string));
2324 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2325 }
2326 else
2327 ListAdd(args, MkExpConstant("0"));
2328 FreeType(baseType);
2329 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->specifier == PRIVATE)
2330 inheritanceAccess = 2;
2331 }
2332 else
2333 ListAdd(args, MkExpConstant("0"));
2334 if(regClass->type == 1 || regClass->type == 0 || regClass->type == 5)
2335 {
2336 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2337
2338 {
2339 struct __ecereNameSpace__ecere__com__Class * base;
2340
2341 for(base = regClass->base; base && base->type != 1000; base = base->next)
2342 {
2343 for(member = base->membersAndProperties.first; member; member = member->next)
2344 if(!member->isProperty)
2345 break;
2346 if(member)
2347 break;
2348 }
2349 }
2350 if(regClass->type == 1 && symbol->declaredStruct && member)
2351 {
2352 char baseStructName[1024];
2353
2354 baseStructName[0] = (char)0;
2355 strcpy(baseStructName, (regClass->base->templateClass ? regClass->base->templateClass : regClass->base)->fullName);
2356 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))))));
2357 }
2358 else
2359 ListAdd(args, symbol->declaredStruct ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(symbol->structName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2360 }
2361 else
2362 {
2363 ListAdd(args, MkExpConstant("0"));
2364 }
2365 {
2366 char classDataStructName[1024];
2367
2368 strcpy(classDataStructName, "__ecereClassData_");
2369 FullClassNameCat(classDataStructName, symbol->string, 0x0);
2370 ListAdd(args, symbol->classData ? MkExpTypeSize(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(classDataStructName), (((void *)0)))), (((void *)0)))) : MkExpConstant("0"));
2371 }
2372 if(regClass->type == 0 || regClass->type == 5)
2373 {
2374 ListAdd(args, symbol->needConstructor ? MkExpIdentifier(MkIdentifier(symbol->constructorName)) : MkExpConstant("0"));
2375 ListAdd(args, symbol->needDestructor ? MkExpIdentifier(MkIdentifier(symbol->destructorName)) : MkExpConstant("0"));
2376 }
2377 else
2378 {
2379 ListAdd(args, MkExpConstant("0"));
2380 ListAdd(args, MkExpConstant("0"));
2381 }
2382 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2383 switch(declMode)
2384 {
2385 case 3:
2386 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2387 break;
2388 case 2:
2389 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2390 break;
2391 case 1:
2392 default:
2393 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2394 break;
2395 }
2396 switch(inheritanceAccess)
2397 {
2398 case 2:
2399 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2400 break;
2401 case 1:
2402 default:
2403 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2404 break;
2405 }
2406 registerFunction = "eSystem_RegisterClass";
2407 stmt = MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("class")), '=', MkExpCall((exp = MkExpIdentifier(MkIdentifier(registerFunction))), args))));
2408 ListAdd(registerModuleBody->compound.statements, stmt);
2409 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)));
2410 ListAdd(registerModuleBody->compound.statements, stmt);
2411 if(external && external->type == 2 && external->_class->deleteWatchable)
2412 {
2413 args = MkListOne(MkExpIdentifier(MkIdentifier("class")));
2414 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DestructionWatchable")), args)));
2415 ListAdd(registerModuleBody->compound.statements, stmt);
2416 }
2417 if(regClass->base)
2418 {
2419 struct __ecereNameSpace__ecere__com__Class * base = regClass->base;
2420 int c;
2421
2422 for(c = 0; c < base->vTblSize; c++)
2423 {
2424 struct Symbol * method = (struct Symbol *)regClass->_vTbl[c];
2425
2426 if((void *)method != DummyMethod && base->_vTbl[c] != (void *)method)
2427 {
2428 struct External * external = method->methodExternal;
2429 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2430 struct Identifier * id = external->function ? GetDeclId(external->function->declarator) : (((void *)0));
2431
2432 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2433 {
2434 char * string = QMkString(method->method->name);
2435
2436 ListAdd(args, MkExpString(string));
2437 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2438 }
2439 ListAdd(args, MkExpConstant("0"));
2440 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2441 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2442 exp->expType = __extension__ ({
2443 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2444
2445 __ecereInstance1->refCount = 1, __ecereInstance1;
2446 });
2447 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2448 ListAdd(registerModuleBody->compound.statements, stmt);
2449 }
2450 }
2451 }
2452 {
2453 int c;
2454
2455 for(c = regClass->base ? regClass->base->vTblSize : 0; c < regClass->vTblSize; c++)
2456 {
2457 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)))
2458 {
2459 if(method->type == 1 && method->_class == regClass && method->vid == c)
2460 {
2461 char name[1024];
2462 struct Expression * exp;
2463 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->methodCodeExternal : (((void *)0));
2464 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2465 struct Identifier * id = (external && external->function) ? GetDeclId(external->function->declarator) : (((void *)0));
2466
2467 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2468 {
2469 char * string = QMkString(method->name);
2470
2471 ListAdd(args, MkExpString(string));
2472 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2473 }
2474 {
2475 char * string = QMkString(method->dataTypeString);
2476
2477 ListAdd(args, MkExpString(string));
2478 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2479 }
2480 if(id && external->function->body)
2481 {
2482 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2483 exp->expType = __extension__ ({
2484 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2485
2486 __ecereInstance1->refCount = 1, __ecereInstance1;
2487 });
2488 }
2489 else
2490 {
2491 ListAdd(args, (exp = MkExpConstant("0")));
2492 }
2493 switch(method->memberAccess)
2494 {
2495 case 3:
2496 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2497 break;
2498 case 2:
2499 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2500 break;
2501 case 1:
2502 default:
2503 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2504 break;
2505 }
2506 strcpy(name, "__ecereVMethodID_");
2507 FullClassNameCat(name, method->_class->fullName, 0x0);
2508 strcat(name, "_");
2509 strcat(name, method->name);
2510 exp = MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddVirtualMethod")), args);
2511 stmt = MkExpressionStmt(MkListOne(exp));
2512 DeclareMethod(method, name);
2513 ListAdd(registerModuleBody->compound.statements, stmt);
2514 }
2515 }
2516 }
2517 }
2518 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)))
2519 {
2520 if(method->type == 1 && method->_class == regClass)
2521 ;
2522 else if(method->memberAccess == 1 || !method->dataTypeString)
2523 {
2524 struct External * external = method->symbol ? ((struct Symbol *)method->symbol)->methodCodeExternal : (((void *)0));
2525 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2526 struct Identifier * id = (external && external->function) ? GetDeclId(external->function->declarator) : (((void *)0));
2527
2528 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2529 {
2530 char * string = QMkString(method->name);
2531
2532 ListAdd(args, MkExpString(string));
2533 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2534 }
2535 {
2536 char * string = QMkString(method->dataTypeString);
2537
2538 ListAdd(args, MkExpString(string));
2539 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2540 }
2541 if(id && external->function->body)
2542 {
2543 ListAdd(args, (exp = MkExpIdentifier(MkIdentifier(id->string))));
2544 exp->expType = __extension__ ({
2545 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2546
2547 __ecereInstance1->refCount = 1, __ecereInstance1;
2548 });
2549 }
2550 else
2551 {
2552 ListAdd(args, (exp = MkExpConstant("0")));
2553 }
2554 switch(method->memberAccess)
2555 {
2556 case 3:
2557 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2558 break;
2559 case 2:
2560 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2561 break;
2562 case 1:
2563 default:
2564 ListAdd(args, MkExpIdentifier(MkIdentifier("publicAccess")));
2565 break;
2566 }
2567 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddMethod")), args)));
2568 ListAdd(registerModuleBody->compound.statements, stmt);
2569 }
2570 }
2571 RegisterMembersAndProperties(regClass, 0x0, "class", registerModuleBody);
2572 if(classType == 4)
2573 {
2574 struct __ecereNameSpace__ecere__sys__NamedLink * value;
2575 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2576 struct __ecereNameSpace__ecere__com__EnumClassData * e = (regClass ? ((void *)(((char *)regClass->data) + enumClass->offsetClass)) : (((void *)0)));
2577
2578 for(value = e->values.first; value; value = value->next)
2579 {
2580 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2581
2582 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2583 {
2584 char * string = QMkString(value->name);
2585
2586 ListAdd(args, MkExpString(string));
2587 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2588 }
2589 {
2590 char temp[1024];
2591
2592 sprintf(temp, "%d", (int)value->data);
2593 ListAdd(args, MkExpConstant(temp));
2594 }
2595 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eEnum_AddFixedValue")), args)));
2596 ListAdd(registerModuleBody->compound.statements, stmt);
2597 }
2598 }
2599 if(symbol->templateParams)
2600 {
2601 struct TemplateParameter * param;
2602
2603 for(param = (*symbol->templateParams).first; param; param = param->next)
2604 {
2605 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2606
2607 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2608 {
2609 char * string = QMkString(param->identifier->string);
2610
2611 ListAdd(args, MkExpString(string));
2612 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2613 }
2614 ListAdd(args, MkExpIdentifier(MkIdentifier((param->type == 0) ? "type" : ((param->type == 1) ? "identifier" : "expression"))));
2615 switch(param->type)
2616 {
2617 case 0:
2618 case 2:
2619 {
2620 char * typeString = param->dataType ? StringFromSpecDecl(param->dataType->specifiers, param->dataType->decl) : (((void *)0));
2621 char * string = QMkString(typeString);
2622
2623 ListAdd(args, MkExpString(string));
2624 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2625 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2626 break;
2627 }
2628 case 1:
2629 {
2630 char memberTypeString[132] = "TemplateMemberType::";
2631 unsigned int needClass = 0x1;
2632
2633 ((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);
2634 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(memberTypeString))));
2635 break;
2636 }
2637 }
2638 if(param->defaultArgument)
2639 {
2640 struct __ecereNameSpace__ecere__sys__OldList * members = MkList();
2641
2642 switch(param->type)
2643 {
2644 case 0:
2645 {
2646 char * typeString = param->defaultArgument->templateDatatype ? StringFromSpecDecl(param->defaultArgument->templateDatatype->specifiers, param->defaultArgument->templateDatatype->decl) : (((void *)0));
2647 char * string = QMkString(typeString);
2648
2649 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2650 (__ecereNameSpace__ecere__com__eSystem_Delete(typeString), typeString = 0);
2651 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2652 break;
2653 }
2654 case 1:
2655 {
2656 char memberString[1024];
2657 char * string;
2658
2659 memberString[0] = '\0';
2660 if(param->defaultArgument->identifier->_class)
2661 {
2662 if(param->defaultArgument->identifier->_class->type == 8)
2663 strcpy(memberString, param->defaultArgument->identifier->_class->templateParameter->identifier->string);
2664 else if(param->defaultArgument->identifier->_class->name)
2665 strcpy(memberString, param->defaultArgument->identifier->_class->name);
2666 }
2667 if(memberString[0])
2668 strcat(memberString, "::");
2669 strcat(memberString, param->defaultArgument->identifier->string);
2670 string = QMkString(memberString);
2671 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(MkListOne(MkIdentifier("dataTypeString")), MkInitializerAssignment(MkExpString(string))));
2672 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2673 break;
2674 }
2675 case 2:
2676 {
2677 struct Operand op =
2678 {
2679 0, 0, 0, 0,
2680 {
2681 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
2682 }
2683 };
2684 struct __ecereNameSpace__ecere__sys__OldList * ids = MkList();
2685 char * ui64String;
2686 char * string = (((void *)0));
2687
2688 op = GetOperand(param->defaultArgument->expression);
2689 ui64String = PrintUInt64(op.ui64);
2690 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("expression"));
2691 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ids), MkIdentifier("ui64"));
2692 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
2693 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2694 (__ecereNameSpace__ecere__com__eSystem_Delete(ui64String), ui64String = 0);
2695 break;
2696 }
2697 }
2698 ListAdd(args, MkExpInstance(MkInstantiation(MkSpecifierName("ClassTemplateArgument"), (((void *)0)), MkListOne(MkMembersInitList(members)))));
2699 }
2700 else
2701 ListAdd(args, MkExpIdentifier(MkIdentifier("null")));
2702 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_AddTemplateParameter")), args)));
2703 ListAdd(registerModuleBody->compound.statements, stmt);
2704 }
2705 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("eClass_DoneAddingTemplateParameters")), MkListOne(MkExpIdentifier(MkIdentifier("class"))))));
2706 ListAdd(registerModuleBody->compound.statements, stmt);
2707 }
2708 if(definitions != (((void *)0)))
2709 {
2710 for(def = definitions->first; def; def = def->next)
2711 {
2712 if(def->type == 4 && def->propertyWatch)
2713 {
2714 ListAdd(registerModuleBody->compound.statements, (struct Statement *)def->propertyWatch);
2715 def->propertyWatch = (((void *)0));
2716 }
2717 else if(def->type == 5)
2718 {
2719 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("designerClass")), '=', MkExpString(QMkString(def->designer))))), (((void *)0)));
2720 ListAdd(registerModuleBody->compound.statements, stmt);
2721 }
2722 else if(def->type == 6)
2723 {
2724 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("noExpansion")), '=', MkExpConstant("1")))), (((void *)0)));
2725 ListAdd(registerModuleBody->compound.statements, stmt);
2726 }
2727 else if(def->type == 7)
2728 {
2729 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("fixed")), '=', MkExpConstant("1")))), (((void *)0)));
2730 ListAdd(registerModuleBody->compound.statements, stmt);
2731 if(regClass)
2732 regClass->fixed = 0x1;
2733 }
2734 else if(def->type == 8)
2735 {
2736 stmt = MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("class"))), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("defaultProperty")), '=', MkExpString(QMkString(def->defaultProperty->string))))), (((void *)0)));
2737 ListAdd(registerModuleBody->compound.statements, stmt);
2738 }
2739 else if(def->type == 11)
2740 {
2741 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2742
2743 ListAdd(args, MkExpIdentifier(MkIdentifier("class")));
2744 ListAdd(args, MkExpString(QMkString(def->id->string)));
2745 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(INT64)), (((void *)0))), def->initializer->exp));
2746 def->initializer->exp = (((void *)0));
2747 stmt = MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eClass_SetProperty")), args)));
2748 ListAdd(registerModuleBody->compound.statements, stmt);
2749 }
2750 }
2751 }
2752 }
2753 }
2754 }
2755
2756 extern int strcmp(const char * , const char * );
2757
2758 extern void PrintExpression(struct Expression * exp, char *  string);
2759
2760 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
2761
2762 void ProcessClassDefinitions()
2763 {
2764 struct External * external, * next;
2765
2766 CreateRegisterModuleBody();
2767 if(ast)
2768 {
2769 for(external = (*ast).first; external; external = next)
2770 {
2771 next = external->next;
2772 curExternal = external;
2773 if(external->type == 2)
2774 {
2775 struct ClassDefinition * _class = external->_class;
2776
2777 if(_class->definitions)
2778 {
2779 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), ast, external, _class->declMode);
2780 }
2781 if(inCompiler)
2782 {
2783 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2784 FreeExternal(external);
2785 }
2786 }
2787 else if(external->type == 0)
2788 {
2789 unsigned int setStaticMethod = 0x0;
2790
2791 if(external->symbol && !external->symbol->type->thisClass && !external->symbol->type->staticMethod)
2792 {
2793 external->symbol->type->staticMethod = 0x1;
2794 setStaticMethod = 0x1;
2795 }
2796 if(inCompiler)
2797 {
2798 struct FunctionDefinition * function = external->function;
2799 struct Statement * stmt;
2800 struct __ecereNameSpace__ecere__sys__OldList * args;
2801
2802 if(!strcmp(function->declarator->symbol->string, "__on_register_module"))
2803 {
2804 ListAdd(registerModuleBody->compound.statements, function->body);
2805 function->body->compound.context->parent = registerModuleBody->compound.context;
2806 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2807 function->body = (((void *)0));
2808 FreeExternal(external);
2809 continue;
2810 }
2811 if(function->declMode != 2 && function->declMode != 1)
2812 continue;
2813 args = MkList();
2814 CreateRegisterModuleBody();
2815 {
2816 char * string = QMkString(function->declarator->symbol->string);
2817
2818 ListAdd(args, MkExpString(string));
2819 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2820 }
2821 {
2822 char * string;
2823 char type[1024] = "";
2824
2825 if(setStaticMethod)
2826 function->declarator->symbol->type->staticMethod = 0x0;
2827 PrintType(function->declarator->symbol->type, type, 0x1, 0x1);
2828 if(setStaticMethod)
2829 function->declarator->symbol->type->staticMethod = 0x1;
2830 string = QMkString(type);
2831 ListAdd(args, MkExpString(string));
2832 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2833 }
2834 {
2835 ListAdd(args, MkExpIdentifier(MkIdentifier(function->declarator->symbol->string)));
2836 }
2837 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2838 switch(function->declMode)
2839 {
2840 case 3:
2841 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2842 break;
2843 case 2:
2844 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2845 break;
2846 case 1:
2847 default:
2848 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2849 break;
2850 }
2851 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterFunction"))), args)));
2852 ListAdd(registerModuleBody->compound.statements, stmt);
2853 }
2854 }
2855 else if(external->type == 1)
2856 {
2857 struct Declaration * declaration = external->declaration;
2858
2859 if(external->symbol)
2860 {
2861 if(external->symbol->type && external->symbol->type->kind == 11 && !external->symbol->type->thisClass)
2862 external->symbol->type->staticMethod = 0x1;
2863 }
2864 if(external->symbol && declaration->type == 1)
2865 {
2866 if(declaration->specifiers)
2867 {
2868 struct Specifier * specifier;
2869 unsigned int removeExternal = 0x0;
2870
2871 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2872 {
2873 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2874 {
2875 struct Symbol * symbol = FindClass(specifier->id->string);
2876
2877 if(symbol)
2878 {
2879 int classType;
2880
2881 if(specifier->type == 2)
2882 classType = 4;
2883 else
2884 classType = 1;
2885 removeExternal = 0x1;
2886 symbol->ctx = specifier->ctx;
2887 specifier->ctx = (((void *)0));
2888 ProcessClass(classType, specifier->definitions, symbol, specifier->baseSpecs, specifier->list, ast, external, declaration->declMode);
2889 }
2890 }
2891 }
2892 if(inCompiler && removeExternal)
2893 {
2894 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
2895 FreeExternal(external);
2896 }
2897 }
2898 }
2899 else if(declaration->type == 3)
2900 {
2901 if(inCompiler && declaration->declMode != 3)
2902 {
2903 struct Statement * stmt;
2904 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2905
2906 CreateRegisterModuleBody();
2907 {
2908 char * string = QMkString(declaration->id->string);
2909
2910 ListAdd(args, MkExpString(string));
2911 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2912 }
2913 {
2914 char * string;
2915 char type[1024] = "";
2916
2917 PrintExpression(declaration->exp, type);
2918 string = QMkString(type);
2919 ListAdd(args, MkExpString(string));
2920 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2921 }
2922 ListAdd(args, MkExpIdentifier(MkIdentifier("module")));
2923 switch(declaration->declMode)
2924 {
2925 case 3:
2926 ListAdd(args, MkExpIdentifier(MkIdentifier("staticAccess")));
2927 break;
2928 case 2:
2929 ListAdd(args, MkExpIdentifier(MkIdentifier("privateAccess")));
2930 break;
2931 case 1:
2932 default:
2933 ListAdd(args, MkExpIdentifier(MkIdentifier(buildingECERECOMModule ? "baseSystemAccess" : "publicAccess")));
2934 break;
2935 }
2936 stmt = MkExpressionStmt(MkListOne(MkExpCall((MkExpIdentifier(MkIdentifier("eSystem_RegisterDefine"))), args)));
2937 ListAdd(registerModuleBody->compound.statements, stmt);
2938 }
2939 }
2940 }
2941 }
2942 }
2943 }
2944
2945 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2946
2947 struct __ecereNameSpace__ecere__com__GlobalFunction;
2948
2949 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);
2950
2951 void __ecereRegisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
2952 {
2953 struct __ecereNameSpace__ecere__com__Class * class;
2954
2955 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereCom", "void SetBuildingEcereCom(bool b)", SetBuildingEcereCom, module, 1);
2956 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereCom", "bool GetBuildingEcereCom(void)", GetBuildingEcereCom, module, 1);
2957 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetBuildingEcereComModule", "void SetBuildingEcereComModule(bool b)", SetBuildingEcereComModule, module, 1);
2958 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetBuildingEcereComModule", "bool GetBuildingEcereComModule(void)", GetBuildingEcereComModule, module, 1);
2959 __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);
2960 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CreateRegisterModuleBody", "void CreateRegisterModuleBody(void)", CreateRegisterModuleBody, module, 2);
2961 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("RegisterMembersAndProperties", "void RegisterMembersAndProperties(ecere::com::Class regClass, bool isMember, char * className, Statement statement)", RegisterMembersAndProperties, module, 2);
2962 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetNameSpaceString", "void GetNameSpaceString(ecere::com::NameSpace ns, char * string)", GetNameSpaceString, module, 2);
2963 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessClassDefinitions", "void ProcessClassDefinitions(void)", ProcessClassDefinitions, module, 1);
2964 }
2965
2966 void __ecereUnregisterModule_pass1(struct __ecereNameSpace__ecere__com__Instance * module)
2967 {
2968
2969 }
2970