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