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

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