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

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