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

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