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