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