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