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

   1 #if defined(__GNUC__)
   2 typedef long long int64;
   3 typedef unsigned long long uint64;
   4 #elif defined(__TINYC__)
   5 #include <stdarg.h>
   6 #define __builtin_va_list va_list
   7 #define __builtin_va_start va_start
   8 #define __builtin_va_end va_end
   9 #ifdef _WIN32
  10 #define strcasecmp stricmp
  11 #define strncasecmp strnicmp
  12 #define __declspec(x) __attribute__((x))
  13 #endif
  14 typedef long long int64;
  15 typedef unsigned long long uint64;
  16 #else
  17 typedef __int64 int64;
  18 typedef unsigned __int64 uint64;
  19 #endif
  20 #ifdef __BIG_ENDIAN__
  21 #define __ENDIAN_PAD(x) (8 - (x))
  22 #else
  23 #define __ENDIAN_PAD(x) 0
  24 #endif
  25 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  26
  27 struct __ecereNameSpace__ecere__sys__BTNode;
  28
  29 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  30
  31 struct __ecereNameSpace__ecere__sys__BinaryTree
  32 {
  33 struct __ecereNameSpace__ecere__sys__BTNode * root;
  34 int count;
  35 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, unsigned int a, unsigned int b);
  36 void (*  FreeKey)(void *  key);
  37 };
  38
  39 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  40
  41 struct __ecereNameSpace__ecere__sys__OldList
  42 {
  43 void *  first;
  44 void *  last;
  45 int count;
  46 unsigned int offset;
  47 unsigned int circ;
  48 };
  49
  50 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  51
  52 struct __ecereNameSpace__ecere__com__Method
  53 {
  54 char *  name;
  55 struct __ecereNameSpace__ecere__com__Method * parent;
  56 struct __ecereNameSpace__ecere__com__Method * left;
  57 struct __ecereNameSpace__ecere__com__Method * right;
  58 int depth;
  59 int (*  function)();
  60 int vid;
  61 int type;
  62 struct __ecereNameSpace__ecere__com__Class * _class;
  63 void *  symbol;
  64 char *  dataTypeString;
  65 struct Type * dataType;
  66 int memberAccess;
  67 };
  68
  69 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
  70
  71 struct __ecereNameSpace__ecere__com__Property
  72 {
  73 struct __ecereNameSpace__ecere__com__Property * prev;
  74 struct __ecereNameSpace__ecere__com__Property * next;
  75 char *  name;
  76 unsigned int isProperty;
  77 int memberAccess;
  78 int id;
  79 struct __ecereNameSpace__ecere__com__Class * _class;
  80 char *  dataTypeString;
  81 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
  82 struct Type * dataType;
  83 void (*  Set)();
  84 int (*  Get)();
  85 unsigned int (*  IsSet)();
  86 void *  data;
  87 void *  symbol;
  88 int vid;
  89 unsigned int conversion;
  90 unsigned int watcherOffset;
  91 char *  category;
  92 unsigned int compiled;
  93 unsigned int selfWatchable;
  94 unsigned int isWatchable;
  95 };
  96
  97 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
  98
  99 struct CodePosition
 100 {
 101 int line;
 102 int charPos;
 103 int pos;
 104 unsigned int included;
 105 };
 106
 107 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 108
 109 struct Location
 110 {
 111 struct CodePosition start;
 112 struct CodePosition end;
 113 };
 114
 115 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 116
 117 struct ClassDefinition
 118 {
 119 struct ClassDefinition * prev;
 120 struct ClassDefinition * next;
 121 struct Location loc;
 122 struct Specifier * _class;
 123 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 124 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 125 struct Symbol * symbol;
 126 struct Location blockStart;
 127 struct Location nameLoc;
 128 int endid;
 129 int declMode;
 130 unsigned int deleteWatchable;
 131 };
 132
 133 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 134
 135 struct Context
 136 {
 137 struct Context * parent;
 138 struct __ecereNameSpace__ecere__sys__BinaryTree types;
 139 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 140 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
 141 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
 142 int nextID;
 143 int simpleID;
 144 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
 145 struct ClassDefinition * classDef;
 146 unsigned int templateTypesOnly;
 147 };
 148
 149 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 150
 151 struct Instantiation
 152 {
 153 struct Instantiation * prev;
 154 struct Instantiation * next;
 155 struct Location loc;
 156 struct Specifier * _class;
 157 struct Expression * exp;
 158 struct __ecereNameSpace__ecere__sys__OldList *  members;
 159 struct Symbol * symbol;
 160 unsigned int fullSet;
 161 unsigned int isConstant;
 162 unsigned char *  data;
 163 struct Location nameLoc;
 164 struct Location insideLoc;
 165 unsigned int built;
 166 };
 167
 168 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 169
 170 struct Declaration
 171 {
 172 struct Declaration * prev;
 173 struct Declaration * next;
 174 struct Location loc;
 175 int type;
 176 union
 177 {
 178 struct
 179 {
 180 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 181 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 182 };
 183 struct Instantiation * inst;
 184 struct
 185 {
 186 struct Identifier * id;
 187 struct Expression * exp;
 188 };
 189 };
 190 struct Specifier * extStorage;
 191 struct Symbol * symbol;
 192 int declMode;
 193 };
 194
 195 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 196
 197 struct Statement
 198 {
 199 struct Statement * prev;
 200 struct Statement * next;
 201 struct Location loc;
 202 int type;
 203 union
 204 {
 205 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 206 struct
 207 {
 208 struct Identifier * id;
 209 struct Statement * stmt;
 210 } labeled;
 211 struct
 212 {
 213 struct Expression * exp;
 214 struct Statement * stmt;
 215 } caseStmt;
 216 struct
 217 {
 218 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 219 struct __ecereNameSpace__ecere__sys__OldList * statements;
 220 struct Context * context;
 221 unsigned int isSwitch;
 222 } compound;
 223 struct
 224 {
 225 struct __ecereNameSpace__ecere__sys__OldList * exp;
 226 struct Statement * stmt;
 227 struct Statement * elseStmt;
 228 } ifStmt;
 229 struct
 230 {
 231 struct __ecereNameSpace__ecere__sys__OldList * exp;
 232 struct Statement * stmt;
 233 } switchStmt;
 234 struct
 235 {
 236 struct __ecereNameSpace__ecere__sys__OldList * exp;
 237 struct Statement * stmt;
 238 } whileStmt;
 239 struct
 240 {
 241 struct __ecereNameSpace__ecere__sys__OldList * exp;
 242 struct Statement * stmt;
 243 } doWhile;
 244 struct
 245 {
 246 struct Statement * init;
 247 struct Statement * check;
 248 struct __ecereNameSpace__ecere__sys__OldList * increment;
 249 struct Statement * stmt;
 250 } forStmt;
 251 struct
 252 {
 253 struct Identifier * id;
 254 } gotoStmt;
 255 struct
 256 {
 257 struct Specifier * spec;
 258 char * statements;
 259 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 260 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 261 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 262 } asmStmt;
 263 struct
 264 {
 265 struct Expression * watcher;
 266 struct Expression * object;
 267 struct __ecereNameSpace__ecere__sys__OldList * watches;
 268 } _watch;
 269 struct
 270 {
 271 struct Identifier * id;
 272 struct __ecereNameSpace__ecere__sys__OldList * exp;
 273 struct __ecereNameSpace__ecere__sys__OldList * filter;
 274 struct Statement * stmt;
 275 } forEachStmt;
 276 struct Declaration * decl;
 277 };
 278 };
 279
 280 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 281
 282 struct TypeName
 283 {
 284 struct TypeName * prev;
 285 struct TypeName * next;
 286 struct Location loc;
 287 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 288 struct Declarator * declarator;
 289 int classObjectType;
 290 struct Expression * bitCount;
 291 };
 292
 293 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 294
 295 struct Initializer
 296 {
 297 struct Initializer * prev;
 298 struct Initializer * next;
 299 struct Location loc;
 300 int type;
 301 union
 302 {
 303 struct Expression * exp;
 304 struct __ecereNameSpace__ecere__sys__OldList *  list;
 305 };
 306 unsigned int isConstant;
 307 };
 308
 309 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 310
 311 struct __ecereNameSpace__ecere__com__DataValue
 312 {
 313 union
 314 {
 315 char c;
 316 unsigned char uc;
 317 short s;
 318 unsigned short us;
 319 int i;
 320 unsigned int ui;
 321 void *  p;
 322 float f;
 323 double d;
 324 long long i64;
 325 uint64 ui64;
 326 };
 327 };
 328
 329 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 330
 331 struct Expression
 332 {
 333 struct Expression * prev;
 334 struct Expression * next;
 335 struct Location loc;
 336 int type;
 337 union
 338 {
 339 struct
 340 {
 341 char *  constant;
 342 struct Identifier * identifier;
 343 };
 344 struct Statement * compound;
 345 struct Instantiation * instance;
 346 char *  string;
 347 struct __ecereNameSpace__ecere__sys__OldList *  list;
 348 struct
 349 {
 350 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 351 struct Declarator * decl;
 352 } _classExp;
 353 struct
 354 {
 355 struct Identifier * id;
 356 } classData;
 357 struct
 358 {
 359 struct Expression * exp;
 360 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 361 struct Location argLoc;
 362 } call;
 363 struct
 364 {
 365 struct Expression * exp;
 366 struct __ecereNameSpace__ecere__sys__OldList * index;
 367 } index;
 368 struct
 369 {
 370 struct Expression * exp;
 371 struct Identifier * member;
 372 int memberType;
 373 unsigned int thisPtr;
 374 } member;
 375 struct
 376 {
 377 int op;
 378 struct Expression * exp1;
 379 struct Expression * exp2;
 380 } op;
 381 struct TypeName * typeName;
 382 struct Specifier * _class;
 383 struct
 384 {
 385 struct TypeName * typeName;
 386 struct Expression * exp;
 387 } cast;
 388 struct
 389 {
 390 struct Expression * cond;
 391 struct __ecereNameSpace__ecere__sys__OldList * exp;
 392 struct Expression * elseExp;
 393 } cond;
 394 struct
 395 {
 396 struct TypeName * typeName;
 397 struct Expression * size;
 398 } _new;
 399 struct
 400 {
 401 struct TypeName * typeName;
 402 struct Expression * size;
 403 struct Expression * exp;
 404 } _renew;
 405 struct
 406 {
 407 char * table;
 408 struct Identifier * id;
 409 } db;
 410 struct
 411 {
 412 struct Expression * ds;
 413 struct Expression * name;
 414 } dbopen;
 415 struct
 416 {
 417 struct TypeName * typeName;
 418 struct Initializer * initializer;
 419 } initializer;
 420 struct
 421 {
 422 struct Expression * exp;
 423 struct TypeName * typeName;
 424 } vaArg;
 425 };
 426 unsigned int debugValue;
 427 struct __ecereNameSpace__ecere__com__DataValue val;
 428 unsigned int address;
 429 unsigned int hasAddress;
 430 struct Type * expType;
 431 struct Type * destType;
 432 unsigned int usage;
 433 int tempCount;
 434 unsigned int byReference;
 435 unsigned int isConstant;
 436 unsigned int addedThis;
 437 unsigned int needCast;
 438 unsigned int thisPtr;
 439 };
 440
 441 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 442
 443 struct TemplateDatatype;
 444
 445 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 446
 447 struct TemplateArgument;
 448
 449 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 450
 451 struct TemplateParameter;
 452
 453 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 454
 455 struct Specifier
 456 {
 457 struct Specifier * prev;
 458 struct Specifier * next;
 459 struct Location loc;
 460 int type;
 461 union
 462 {
 463 int specifier;
 464 struct
 465 {
 466 char *  name;
 467 struct Symbol * symbol;
 468 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 469 };
 470 struct
 471 {
 472 struct Identifier * id;
 473 struct __ecereNameSpace__ecere__sys__OldList *  list;
 474 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 475 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 476 unsigned int addNameSpace;
 477 struct Context * ctx;
 478 };
 479 struct Expression * expression;
 480 struct Specifier * _class;
 481 struct TemplateParameter * templateParameter;
 482 };
 483 };
 484
 485 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 486
 487 struct Identifier
 488 {
 489 struct Identifier * prev;
 490 struct Identifier * next;
 491 struct Location loc;
 492 struct Symbol * classSym;
 493 struct Specifier * _class;
 494 char *  string;
 495 struct Identifier * badID;
 496 };
 497
 498 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 499
 500 struct Pointer;
 501
 502 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 503
 504 struct Declarator
 505 {
 506 struct Declarator * prev;
 507 struct Declarator * next;
 508 struct Location loc;
 509 int type;
 510 struct Symbol * symbol;
 511 struct Declarator * declarator;
 512 union
 513 {
 514 struct Identifier * identifier;
 515 struct
 516 {
 517 struct Expression * exp;
 518 struct Expression * posExp;
 519 char * attrib;
 520 } structDecl;
 521 struct
 522 {
 523 struct Expression * exp;
 524 struct Specifier * enumClass;
 525 } array;
 526 struct
 527 {
 528 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 529 } function;
 530 struct
 531 {
 532 struct Pointer * pointer;
 533 } pointer;
 534 struct
 535 {
 536 char * extended;
 537 } extended;
 538 };
 539 };
 540
 541 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 542
 543 struct FunctionDefinition
 544 {
 545 struct FunctionDefinition * prev;
 546 struct FunctionDefinition * next;
 547 struct Location loc;
 548 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 549 struct Declarator * declarator;
 550 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 551 struct Statement * body;
 552 struct __ecereNameSpace__ecere__com__Class * _class;
 553 struct __ecereNameSpace__ecere__sys__OldList attached;
 554 int declMode;
 555 struct Type * type;
 556 struct Symbol * propSet;
 557 int tempCount;
 558 unsigned int propertyNoThis;
 559 };
 560
 561 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 562
 563 struct DBTableDef;
 564
 565 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 566
 567 struct External
 568 {
 569 struct External * prev;
 570 struct External * next;
 571 struct Location loc;
 572 int type;
 573 struct Symbol * symbol;
 574 union
 575 {
 576 struct FunctionDefinition * function;
 577 struct ClassDefinition * _class;
 578 struct Declaration * declaration;
 579 char *  importString;
 580 struct Identifier * id;
 581 struct DBTableDef * table;
 582 };
 583 int importType;
 584 };
 585
 586 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 587
 588 struct ModuleImport;
 589
 590 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 591
 592 struct ClassImport;
 593
 594 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 595
 596 struct Symbol
 597 {
 598 char *  string;
 599 struct Symbol * parent;
 600 struct Symbol * left;
 601 struct Symbol * right;
 602 int depth;
 603 struct Type * type;
 604 union
 605 {
 606 struct __ecereNameSpace__ecere__com__Method * method;
 607 struct __ecereNameSpace__ecere__com__Property * _property;
 608 struct __ecereNameSpace__ecere__com__Class * registered;
 609 };
 610 int id;
 611 int idCode;
 612 union
 613 {
 614 struct
 615 {
 616 struct External * pointerExternal;
 617 struct External * structExternal;
 618 };
 619 struct
 620 {
 621 struct External * externalGet;
 622 struct External * externalSet;
 623 struct External * externalPtr;
 624 struct External * externalIsSet;
 625 };
 626 struct
 627 {
 628 struct External * methodExternal;
 629 struct External * methodCodeExternal;
 630 };
 631 };
 632 unsigned int imported;
 633 unsigned int declaredStructSym;
 634 struct __ecereNameSpace__ecere__com__Class * _class;
 635 unsigned int declaredStruct;
 636 unsigned int needConstructor;
 637 unsigned int needDestructor;
 638 char *  constructorName;
 639 char *  structName;
 640 char *  className;
 641 char *  destructorName;
 642 struct ModuleImport * module;
 643 struct ClassImport * _import;
 644 struct Location nameLoc;
 645 unsigned int isParam;
 646 unsigned int isRemote;
 647 unsigned int isStruct;
 648 unsigned int fireWatchersDone;
 649 int declaring;
 650 unsigned int classData;
 651 unsigned int isStatic;
 652 char *  shortName;
 653 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 654 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 655 struct Context * ctx;
 656 int isIterator;
 657 };
 658
 659 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 660
 661 struct Type
 662 {
 663 struct Type * prev;
 664 struct Type * next;
 665 int refCount;
 666 union
 667 {
 668 struct Symbol * _class;
 669 struct
 670 {
 671 struct __ecereNameSpace__ecere__sys__OldList members;
 672 char *  enumName;
 673 };
 674 struct
 675 {
 676 struct Type * returnType;
 677 struct __ecereNameSpace__ecere__sys__OldList params;
 678 struct Symbol * thisClass;
 679 unsigned int staticMethod;
 680 struct TemplateParameter * thisClassTemplate;
 681 };
 682 struct
 683 {
 684 struct __ecereNameSpace__ecere__com__Method * method;
 685 struct __ecereNameSpace__ecere__com__Class * methodClass;
 686 struct __ecereNameSpace__ecere__com__Class * usedClass;
 687 };
 688 struct
 689 {
 690 struct Type * arrayType;
 691 int arraySize;
 692 struct Expression * arraySizeExp;
 693 unsigned int freeExp;
 694 struct Symbol * enumClass;
 695 };
 696 struct Type * type;
 697 struct TemplateParameter * templateParameter;
 698 };
 699 unsigned int isSigned;
 700 int kind;
 701 unsigned int constant;
 702 unsigned int size;
 703 char *  name;
 704 char *  typeName;
 705 unsigned int count;
 706 unsigned int truth;
 707 int classObjectType;
 708 unsigned int byReference;
 709 unsigned int extraParam;
 710 int alignment;
 711 unsigned int directClassAccess;
 712 unsigned int computing;
 713 unsigned int dllExport;
 714 unsigned int offset;
 715 unsigned int keepCast;
 716 unsigned int passAsTemplate;
 717 int bitFieldCount;
 718 };
 719
 720 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 721
 722 struct __ecereNameSpace__ecere__com__Class
 723 {
 724 struct __ecereNameSpace__ecere__com__Class * prev;
 725 struct __ecereNameSpace__ecere__com__Class * next;
 726 char *  name;
 727 int offset;
 728 int structSize;
 729 int (* *  _vTbl)();
 730 int vTblSize;
 731 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 732 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 733 int offsetClass;
 734 int sizeClass;
 735 struct __ecereNameSpace__ecere__com__Class * base;
 736 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 737 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 738 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 739 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 740 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 741 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 742 int memberID;
 743 int startMemberID;
 744 int type;
 745 struct __ecereNameSpace__ecere__com__Instance * module;
 746 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 747 char *  dataTypeString;
 748 struct Type * dataType;
 749 int typeSize;
 750 int defaultAlignment;
 751 void (*  Initialize)();
 752 int memberOffset;
 753 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 754 char *  designerClass;
 755 unsigned int noExpansion;
 756 char *  defaultProperty;
 757 unsigned int comRedefinition;
 758 int count;
 759 unsigned int isRemote;
 760 unsigned int internalDecl;
 761 void *  data;
 762 unsigned int computeSize;
 763 int structAlignment;
 764 int destructionWatchOffset;
 765 unsigned int fixed;
 766 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 767 int inheritanceAccess;
 768 char *  fullName;
 769 void *  symbol;
 770 struct __ecereNameSpace__ecere__sys__OldList conversions;
 771 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 772 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 773 struct __ecereNameSpace__ecere__com__Class * templateClass;
 774 struct __ecereNameSpace__ecere__sys__OldList templatized;
 775 int numParams;
 776 };
 777
 778 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 779
 780 struct __ecereNameSpace__ecere__com__Instance
 781 {
 782 int (* *  _vTbl)();
 783 struct __ecereNameSpace__ecere__com__Class * _class;
 784 int _refCount;
 785 };
 786
 787 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 788
 789 struct __ecereNameSpace__ecere__com__DataMember
 790 {
 791 struct __ecereNameSpace__ecere__com__DataMember * prev;
 792 struct __ecereNameSpace__ecere__com__DataMember * next;
 793 char *  name;
 794 unsigned int isProperty;
 795 int memberAccess;
 796 int id;
 797 struct __ecereNameSpace__ecere__com__Class * _class;
 798 char *  dataTypeString;
 799 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 800 struct Type * dataType;
 801 int type;
 802 int offset;
 803 int memberID;
 804 struct __ecereNameSpace__ecere__sys__OldList members;
 805 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 806 int memberOffset;
 807 int structAlignment;
 808 };
 809
 810 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 811
 812 struct __ecereNameSpace__ecere__com__SerialBuffer
 813 {
 814 unsigned char *  _buffer;
 815 unsigned int count;
 816 unsigned int _size;
 817 unsigned int pos;
 818 };
 819
 820 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 821
 822 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 823 {
 824 union
 825 {
 826 struct
 827 {
 828 char *  dataTypeString;
 829 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 830 };
 831 struct __ecereNameSpace__ecere__com__DataValue expression;
 832 struct
 833 {
 834 char *  memberString;
 835 union
 836 {
 837 struct __ecereNameSpace__ecere__com__DataMember * member;
 838 struct __ecereNameSpace__ecere__com__Property * prop;
 839 struct __ecereNameSpace__ecere__com__Method * method;
 840 };
 841 };
 842 };
 843 };
 844
 845 typedef union YYSTYPE
 846 {
 847 int specifierType;
 848 int i;
 849 int declMode;
 850 struct Identifier * id;
 851 struct Expression * exp;
 852 struct Specifier * specifier;
 853 struct __ecereNameSpace__ecere__sys__OldList * list;
 854 struct Enumerator * enumerator;
 855 struct Declarator * declarator;
 856 struct Pointer * pointer;
 857 struct Initializer * initializer;
 858 struct InitDeclarator * initDeclarator;
 859 struct TypeName * typeName;
 860 struct Declaration * declaration;
 861 struct Statement * stmt;
 862 struct FunctionDefinition * function;
 863 struct External * external;
 864 struct Context * context;
 865 struct AsmField * asmField;
 866 struct Instantiation * instance;
 867 struct MembersInit * membersInit;
 868 struct MemberInit * memberInit;
 869 struct ClassFunction * classFunction;
 870 struct ClassDefinition * _class;
 871 struct ClassDef * classDef;
 872 struct PropertyDef * prop;
 873 char * string;
 874 struct Symbol * symbol;
 875 struct PropertyWatch * propertyWatch;
 876 struct TemplateParameter * templateParameter;
 877 struct TemplateArgument * templateArgument;
 878 struct TemplateDatatype * templateDatatype;
 879 struct DBTableEntry * dbtableEntry;
 880 struct DBIndexItem * dbindexItem;
 881 struct DBTableDef * dbtableDef;
 882 } YYSTYPE;
 883
 884 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 885
 886 struct Enumerator;
 887
 888 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 889
 890 struct InitDeclarator;
 891
 892 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 893
 894 struct AsmField;
 895
 896 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 897
 898 struct ClassFunction
 899 {
 900 struct ClassFunction * prev;
 901 struct ClassFunction * next;
 902 struct Location loc;
 903 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 904 struct Declarator * declarator;
 905 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 906 struct Statement * body;
 907 struct __ecereNameSpace__ecere__com__Class * _class;
 908 struct __ecereNameSpace__ecere__sys__OldList attached;
 909 int declMode;
 910 struct Type * type;
 911 struct Symbol * propSet;
 912 unsigned int isVirtual;
 913 unsigned int isConstructor;
 914 unsigned int isDestructor;
 915 unsigned int dontMangle;
 916 int id;
 917 int idCode;
 918 };
 919
 920 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 921
 922 struct MembersInit
 923 {
 924 struct MembersInit * prev;
 925 struct MembersInit * next;
 926 struct Location loc;
 927 int type;
 928 union
 929 {
 930 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
 931 struct ClassFunction * function;
 932 };
 933 };
 934
 935 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 936
 937 struct MemberInit
 938 {
 939 struct MemberInit * prev;
 940 struct MemberInit * next;
 941 struct Location loc;
 942 struct Location realLoc;
 943 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
 944 struct Initializer * initializer;
 945 unsigned int used;
 946 unsigned int variable;
 947 unsigned int takeOutExp;
 948 };
 949
 950 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 951
 952 struct PropertyDef
 953 {
 954 struct PropertyDef * prev;
 955 struct PropertyDef * next;
 956 struct Location loc;
 957 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 958 struct Declarator * declarator;
 959 struct Identifier * id;
 960 struct Statement * getStmt;
 961 struct Statement * setStmt;
 962 struct Statement * issetStmt;
 963 struct Symbol * symbol;
 964 unsigned int conversion;
 965 unsigned int isWatchable;
 966 char *  category;
 967 };
 968
 969 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
 970
 971 struct PropertyWatch;
 972
 973 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
 974
 975 struct ClassDef
 976 {
 977 struct ClassDef * prev;
 978 struct ClassDef * next;
 979 struct Location loc;
 980 int type;
 981 union
 982 {
 983 struct Declaration * decl;
 984 struct ClassFunction * function;
 985 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
 986 struct PropertyDef * propertyDef;
 987 struct PropertyWatch * propertyWatch;
 988 char *  designer;
 989 struct Identifier * defaultProperty;
 990 struct
 991 {
 992 struct Identifier * id;
 993 struct Initializer * initializer;
 994 };
 995 };
 996 int memberAccess;
 997 void *  object;
 998 };
 999
1000 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1001
1002 struct DBTableEntry;
1003
1004 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1005
1006 struct DBIndexItem;
1007
1008 extern YYSTYPE yylval;
1009
1010 extern struct Location yylloc;
1011
1012 extern struct External * curExternal;
1013
1014 void MangleClassName(char * className)
1015 {
1016 char output[1024];
1017 int c, d = 0;
1018 char ch;
1019
1020 for(c = 0; (ch = className[c]); c++)
1021 {
1022 if(ch == ' ')
1023 output[d++] = '_';
1024 else if(ch == '*')
1025 {
1026 output[d++] = '_';
1027 output[d++] = 'P';
1028 output[d++] = 'T';
1029 output[d++] = 'R';
1030 output[d++] = '_';
1031 }
1032 else if(ch == '<')
1033 {
1034 output[d++] = '_';
1035 output[d++] = 'T';
1036 output[d++] = 'P';
1037 output[d++] = 'L';
1038 output[d++] = '_';
1039 }
1040 else if(ch == '=')
1041 {
1042 output[d++] = '_';
1043 output[d++] = 'E';
1044 output[d++] = 'Q';
1045 output[d++] = 'U';
1046 output[d++] = '_';
1047 }
1048 else if(ch == '>')
1049 {
1050 output[d++] = '_';
1051 }
1052 else if(ch == ',')
1053 {
1054 output[d++] = '__';
1055 }
1056 else
1057 output[d++] = ch;
1058 }
1059 output[d] = (char)0;
1060 }
1061
1062 extern char *  strcat(char * , const char * );
1063
1064 extern int strlen(const char * );
1065
1066 void FullClassNameCat(char * output, char * className, unsigned int includeTemplateParams)
1067 {
1068 int c;
1069 char ch;
1070 int len;
1071
1072 for(c = 0; (ch = className[c]) && ch != '<'; c++)
1073 {
1074 if(ch == ':')
1075 {
1076 strcat(output, "__ecereNameSpace__");
1077 break;
1078 }
1079 }
1080 len = strlen(output);
1081 for(c = 0; (ch = className[c]); c++)
1082 {
1083 if(ch == ':')
1084 output[len++] = '_';
1085 else if(ch == ' ')
1086 output[len++] = '_';
1087 else if(ch == '*')
1088 {
1089 output[len++] = '_';
1090 output[len++] = 'P';
1091 output[len++] = 'T';
1092 output[len++] = 'R';
1093 output[len++] = '_';
1094 }
1095 else if(ch == '=')
1096 {
1097 output[len++] = '_';
1098 output[len++] = 'E';
1099 output[len++] = 'Q';
1100 output[len++] = 'U';
1101 output[len++] = '_';
1102 }
1103 else if(ch == '<')
1104 {
1105 if(!includeTemplateParams)
1106 break;
1107 output[len++] = '_';
1108 output[len++] = 'T';
1109 output[len++] = 'P';
1110 output[len++] = 'L';
1111 output[len++] = '_';
1112 }
1113 else if(ch == '>')
1114 {
1115 output[len++] = '_';
1116 }
1117 else if(ch == ',')
1118 {
1119 output[len++] = '__';
1120 }
1121 else
1122 output[len++] = ch;
1123 }
1124 output[len++] = (char)0;
1125 }
1126
1127 extern int AddMembers(struct __ecereNameSpace__ecere__sys__OldList *  declarations, struct __ecereNameSpace__ecere__com__Class * _class, unsigned int isMember, unsigned int *  retSize, struct __ecereNameSpace__ecere__com__Class * topClass);
1128
1129 static void AddSimpleBaseMembers(struct __ecereNameSpace__ecere__sys__OldList * list, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * topClass)
1130 {
1131 if(_class->type != 1000)
1132 AddMembers(list, _class, 0x0, (((void *)0)), topClass);
1133 }
1134
1135 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
1136
1137 struct __ecereNameSpace__ecere__com__NameSpace
1138 {
1139 char *  name;
1140 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1141 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1142 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1143 int depth;
1144 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1145 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1146 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1147 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1148 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1149 };
1150
1151 static unsigned int NameSpaceContained(struct __ecereNameSpace__ecere__com__NameSpace * ns, struct __ecereNameSpace__ecere__com__NameSpace * parent)
1152 {
1153 if(ns == parent)
1154 return 0x1;
1155 else if((*ns).parent)
1156 return NameSpaceContained((*ns).parent, parent);
1157 else
1158 return 0x0;
1159 }
1160
1161 extern void Compiler_Error(char *  format, ...);
1162
1163 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
1164
1165 struct __ecereNameSpace__ecere__com__Module
1166 {
1167 struct __ecereNameSpace__ecere__com__Instance * application;
1168 struct __ecereNameSpace__ecere__sys__OldList classes;
1169 struct __ecereNameSpace__ecere__sys__OldList defines;
1170 struct __ecereNameSpace__ecere__sys__OldList functions;
1171 struct __ecereNameSpace__ecere__sys__OldList modules;
1172 struct __ecereNameSpace__ecere__com__Instance * prev;
1173 struct __ecereNameSpace__ecere__com__Instance * next;
1174 char *  name;
1175 void *  library;
1176 void *  Unload;
1177 int importType;
1178 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
1179 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
1180 };
1181
1182 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Application;
1183
1184 struct __ecereNameSpace__ecere__com__Application
1185 {
1186 int argc;
1187 char * *  argv;
1188 int exitCode;
1189 unsigned int isGUIApp;
1190 struct __ecereNameSpace__ecere__sys__OldList allModules;
1191 char *  parsedCommand;
1192 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1193 };
1194
1195 extern unsigned int ModuleAccess(struct __ecereNameSpace__ecere__com__Instance * searchIn, struct __ecereNameSpace__ecere__com__Instance * searchFor);
1196
1197 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1198
1199 static void CheckPublicClass(struct Symbol * classSym, int access, char * word)
1200 {
1201 struct __ecereNameSpace__ecere__com__Class * regClass = classSym ? classSym->registered : (((void *)0));
1202
1203 if(regClass)
1204 {
1205 if(regClass->templateClass)
1206 regClass = regClass->templateClass;
1207 if(classSym->isStatic && access != 3)
1208 {
1209 Compiler_Error("Non-static %s making use of a static class\n", word);
1210 }
1211 else if(access == 1)
1212 {
1213 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->application + 296)))->systemNameSpace))
1214 {
1215 if(NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace) || !ModuleAccess(privateModule, regClass->module))
1216 Compiler_Error("Public %s making use of a private class\n", word);
1217 }
1218 }
1219 }
1220 }
1221
1222 static void CheckPublicTypeName(struct TypeName * type, int access)
1223 {
1224 if(type->qualifiers)
1225 {
1226 struct Specifier * spec;
1227
1228 for(spec = (*type->qualifiers).first; spec; spec = spec->next)
1229 {
1230 if(spec->type == 1)
1231 {
1232 struct Symbol * classSym = spec->symbol;
1233
1234 CheckPublicClass(classSym, access, "define");
1235 }
1236 }
1237 }
1238 }
1239
1240 static void CheckPublicExpression(struct Expression * exp, int access);
1241
1242 static void CheckPublicInitializer(struct Initializer * init, int access)
1243 {
1244 switch(init->type)
1245 {
1246 case 0:
1247 CheckPublicExpression(init->exp, access);
1248 break;
1249 case 1:
1250 {
1251 struct Initializer * i;
1252
1253 for(i = (*init->list).first; i; i = i->next)
1254 CheckPublicInitializer(i, access);
1255 break;
1256 }
1257 }
1258 }
1259
1260 static void CheckPublicExpression(struct Expression * exp, int access)
1261 {
1262 if(exp)
1263 {
1264 switch(exp->type)
1265 {
1266 case 0:
1267 break;
1268 case 2:
1269 break;
1270 case 3:
1271 break;
1272 case 4:
1273 if(exp->op.exp1)
1274 CheckPublicExpression(exp->op.exp1, access);
1275 if(exp->op.exp2)
1276 CheckPublicExpression(exp->op.exp2, access);
1277 break;
1278 case 5:
1279 {
1280 struct Expression * e;
1281
1282 for(e = (*exp->list).first; e; e = e->next)
1283 CheckPublicExpression(e, access);
1284 break;
1285 }
1286 case 6:
1287 {
1288 struct Expression * e;
1289
1290 CheckPublicExpression(exp->index.exp, access);
1291 for(e = (*exp->index.index).first; e; e = e->next)
1292 CheckPublicExpression(e, access);
1293 break;
1294 }
1295 case 7:
1296 {
1297 struct Expression * e;
1298
1299 CheckPublicExpression(exp->call.exp, access);
1300 if(exp->call.arguments)
1301 {
1302 for(e = (*exp->call.arguments).first; e; e = e->next)
1303 CheckPublicExpression(e, access);
1304 }
1305 break;
1306 }
1307 case 8:
1308 {
1309 CheckPublicExpression(exp->member.exp, access);
1310 break;
1311 }
1312 case 9:
1313 {
1314 CheckPublicExpression(exp->member.exp, access);
1315 break;
1316 }
1317 case 10:
1318 CheckPublicTypeName(exp->typeName, access);
1319 break;
1320 case 11:
1321 {
1322 struct Type * type = exp->expType;
1323
1324 CheckPublicTypeName(exp->cast.typeName, access);
1325 if(exp->cast.exp)
1326 CheckPublicExpression(exp->cast.exp, access);
1327 break;
1328 }
1329 case 12:
1330 {
1331 struct Expression * e;
1332
1333 CheckPublicExpression(exp->cond.cond, access);
1334 for(e = (*exp->cond.exp).first; e; e = e->next)
1335 CheckPublicExpression(e, access);
1336 CheckPublicExpression(exp->cond.elseExp, access);
1337 break;
1338 }
1339 case 13:
1340 case 28:
1341 CheckPublicExpression(exp->_new.size, access);
1342 break;
1343 case 14:
1344 case 29:
1345 CheckPublicExpression(exp->_renew.size, access);
1346 CheckPublicExpression(exp->_renew.exp, access);
1347 break;
1348 case 1:
1349 {
1350 struct MembersInit * members;
1351
1352 CheckPublicClass(exp->instance->_class->symbol, access, "define");
1353 for(members = (*exp->instance->members).first; members; members = members->next)
1354 {
1355 if(members->type == 0)
1356 {
1357 struct MemberInit * member;
1358
1359 for(member = (*members->dataMembers).first; member; member = member->next)
1360 {
1361 CheckPublicInitializer(member->initializer, access);
1362 }
1363 }
1364 }
1365 break;
1366 }
1367 }
1368 }
1369 }
1370
1371 static void CheckPublicDataType(struct Type * type, int access, char * word)
1372 {
1373 if(type)
1374 {
1375 switch(type->kind)
1376 {
1377 case 8:
1378 {
1379 CheckPublicClass(type->_class, access, word);
1380 break;
1381 }
1382 case 9:
1383 case 10:
1384 {
1385 break;
1386 }
1387 case 11:
1388 {
1389 struct Type * param;
1390
1391 CheckPublicDataType(type->returnType, access, word);
1392 for(param = type->params.first; param; param = param->next)
1393 CheckPublicDataType(param, access, word);
1394 CheckPublicClass(type->thisClass, access, word);
1395 break;
1396 }
1397 case 12:
1398 CheckPublicDataType(type->arrayType, access, word);
1399 if(type->enumClass)
1400 CheckPublicClass(type->enumClass, access, word);
1401 break;
1402 case 13:
1403 {
1404 CheckPublicDataType(type->type, access, word);
1405 break;
1406 }
1407 case 16:
1408 {
1409 break;
1410 }
1411 case 19:
1412 {
1413 CheckPublicClass(type->_class, access, word);
1414 break;
1415 }
1416 }
1417 }
1418 }
1419
1420 extern struct Identifier * GetDeclId(struct Declarator * decl);
1421
1422 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BTNamedLink;
1423
1424 struct __ecereNameSpace__ecere__com__BTNamedLink
1425 {
1426 char *  name;
1427 struct __ecereNameSpace__ecere__com__BTNamedLink * parent;
1428 struct __ecereNameSpace__ecere__com__BTNamedLink * left;
1429 struct __ecereNameSpace__ecere__com__BTNamedLink * right;
1430 int depth;
1431 void *  data;
1432 };
1433
1434 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1435
1436 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, char *  key);
1437
1438 static void CheckMembersDefinitions(struct __ecereNameSpace__ecere__com__Class * regClass, struct __ecereNameSpace__ecere__com__DataMember * member, struct __ecereNameSpace__ecere__sys__OldList * definitions, int access)
1439 {
1440 if(definitions != (((void *)0)))
1441 {
1442 struct ClassDef * def;
1443
1444 for(def = definitions->first; def; def = def->next)
1445 {
1446 if(def->type == 2)
1447 {
1448 struct Declaration * decl = def->decl;
1449 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1450
1451 yylloc = def->loc;
1452 if(decl->type == 0)
1453 {
1454 struct Declarator * d;
1455
1456 if(decl->declarators)
1457 {
1458 for(d = (*decl->declarators).first; d; d = d->next)
1459 {
1460 struct Identifier * declId = GetDeclId(d);
1461
1462 if(declId)
1463 {
1464 if(member)
1465 {
1466 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&member->membersAlpha, declId->string);
1467
1468 dataMember = link ? link->data : (((void *)0));
1469 }
1470 else
1471 dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(regClass, declId->string, privateModule, (((void *)0)), (((void *)0)));
1472 if(dataMember)
1473 CheckPublicDataType(dataMember->dataType, (def->memberAccess == 2) ? 2 : access, "class data member");
1474 }
1475 }
1476 }
1477 else if(decl->specifiers)
1478 {
1479 struct Specifier * spec;
1480
1481 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1482 {
1483 if(spec->type == 3 || spec->type == 4)
1484 {
1485 if(spec->definitions && !spec->id)
1486 {
1487 CheckMembersDefinitions(regClass, member, spec->definitions, (def->memberAccess == 2) ? 2 : access);
1488 }
1489 else if(spec->definitions && spec->id)
1490 {
1491 if(member)
1492 {
1493 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&member->membersAlpha, spec->id->string);
1494
1495 dataMember = link ? link->data : (((void *)0));
1496 }
1497 else
1498 dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(regClass, spec->id->string, privateModule, (((void *)0)), (((void *)0)));
1499 if(dataMember)
1500 CheckPublicDataType(dataMember->dataType, (def->memberAccess == 2) ? 2 : access, "class data member");
1501 }
1502 }
1503 }
1504 }
1505 }
1506 else if(decl->type == 2)
1507 {
1508 CheckPublicClass(decl->inst->_class->symbol, (def->memberAccess == 2) ? 2 : access, "class member instance");
1509 }
1510 }
1511 }
1512 }
1513 }
1514
1515 extern unsigned int inCompiler;
1516
1517 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1518
1519 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
1520
1521 extern struct Symbol * FindClass(char *  name);
1522
1523 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);
1524
1525 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_AddProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  dataType, void *  setStmt, void *  getStmt, int declMode);
1526
1527 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, unsigned int size, unsigned int alignment, int declMode);
1528
1529 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1530
1531 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, void *  function, int declMode);
1532
1533 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
1534
1535 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
1536
1537 extern struct ClassDef * MkClassDefDeclaration(struct Declaration * decl);
1538
1539 extern struct Specifier * MkSpecifierName(char *  name);
1540
1541 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1542
1543 extern struct Identifier * MkIdentifier(char *  string);
1544
1545 extern struct Declaration * MkStructDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * declarators, struct Specifier * extStorage);
1546
1547 extern struct Expression * QMkExpId(char *  id);
1548
1549 extern void FreeDeclarator(struct Declarator * decl);
1550
1551 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (* )(void * ));
1552
1553 extern void FreeSpecifier(struct Specifier * spec);
1554
1555 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1556
1557 extern struct Type * MkClassType(char *  name);
1558
1559 extern char *  strcpy(char * , const char * );
1560
1561 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1562
1563 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1564
1565 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1566
1567 extern void FreeExternal(struct External * external);
1568
1569 extern int declMode;
1570
1571 extern char *  strstr(char * , const char * );
1572
1573 extern char *  sourceFile;
1574
1575 extern struct Specifier * MkSpecifier(int specifier);
1576
1577 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1578
1579 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1580
1581 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1582
1583 extern struct Context * PushContext(void);
1584
1585 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1586
1587 extern struct Expression * CopyExpression(struct Expression * exp);
1588
1589 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1590
1591 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1592
1593 extern void PopContext(struct Context * ctx);
1594
1595 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
1596
1597 extern struct __ecereNameSpace__ecere__sys__OldList *  excludedSymbols;
1598
1599 extern struct ClassFunction * MkClassFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Specifier * _class, struct Declarator * decl, struct __ecereNameSpace__ecere__sys__OldList * declList);
1600
1601 extern void ProcessClassFunctionBody(struct ClassFunction * func, struct Statement * body);
1602
1603 extern struct ClassDef * MkClassDefFunction(struct ClassFunction * function);
1604
1605 extern struct Specifier * CopySpecifier(struct Specifier * spec);
1606
1607 extern struct Expression * MkExpInstance(struct Instantiation * inst);
1608
1609 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1610
1611 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1612
1613 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1614
1615 extern void FreeInitializer(struct Initializer * initializer);
1616
1617 extern struct Statement * MkReturnStmt(struct __ecereNameSpace__ecere__sys__OldList * exp);
1618
1619 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1620
1621 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (* )(void * ));
1622
1623 extern struct Declarator * PlugDeclarator(struct Declarator * decl, struct Declarator * baseDecl);
1624
1625 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
1626
1627 extern int sprintf(char * , char * , ...);
1628
1629 extern struct Declarator * GetFuncDecl(struct Declarator * decl);
1630
1631 extern void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
1632
1633 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1634
1635 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1636
1637 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1638
1639 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1640
1641 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1642
1643 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear(struct __ecereNameSpace__ecere__sys__OldList * this);
1644
1645 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 Location * loc, struct __ecereNameSpace__ecere__sys__OldList * defs, void * after, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators)
1646 {
1647 void * __ecereTemp1;
1648 char structName[1024];
1649 char className[1024];
1650 char constructorName[1024];
1651 char destructorName[1024];
1652 struct __ecereNameSpace__ecere__com__Class * regClass;
1653 struct ClassFunction * destructor = (((void *)0)), * constructor = (((void *)0));
1654 unsigned int redefinition = 0x0;
1655 unsigned int isUnion = classType == 6;
1656 struct External * external = (((void *)0));
1657 struct ClassDef * def;
1658 struct __ecereNameSpace__ecere__sys__OldList * list;
1659 struct __ecereNameSpace__ecere__sys__OldList * classDataList;
1660
1661 if(inCompiler)
1662 {
1663 list = MkList();
1664 classDataList = MkList();
1665 }
1666 regClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, symbol->string);
1667 if(!regClass)
1668 return ;
1669 classType = regClass->type;
1670 if(inCompiler)
1671 {
1672 yylloc = *loc;
1673 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace) && regClass->inheritanceAccess == 1)
1674 {
1675 if(!regClass->base->symbol)
1676 regClass->base->symbol = FindClass(regClass->base->fullName);
1677 CheckPublicClass(regClass->base->symbol, 1, "class");
1678 }
1679 else if(!symbol->isStatic && regClass->base)
1680 {
1681 if(!regClass->base->symbol)
1682 regClass->base->symbol = FindClass(regClass->base->fullName);
1683 CheckPublicClass(regClass->base->symbol, 2, "class");
1684 }
1685 }
1686 if(definitions != (((void *)0)))
1687 {
1688 for(def = definitions->first; def; def = def->next)
1689 {
1690 if(def->type == 13)
1691 {
1692 struct __ecereNameSpace__ecere__com__DataMember * member;
1693 struct __ecereNameSpace__ecere__com__Property * prop;
1694 struct __ecereNameSpace__ecere__com__Method * method;
1695
1696 if((prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, def->id->string, privateModule)))
1697 {
1698 __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, def->id->string, (((void *)0)), (((void *)0)), (((void *)0)), def->memberAccess);
1699 }
1700 else if((member = __ecereNameSpace__ecere__com__eClass_FindDataMember(regClass, def->id->string, privateModule, (((void *)0)), (((void *)0)))))
1701 {
1702 __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, def->id->string, (((void *)0)), 0, 0, def->memberAccess);
1703 }
1704 else if((method = __ecereNameSpace__ecere__com__eClass_FindMethod(regClass, def->id->string, privateModule)))
1705 {
1706 __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, def->id->string, (((void *)0)), (((void *)0)), def->memberAccess);
1707 }
1708 else
1709 {
1710 yylloc = def->loc;
1711 Compiler_Error("Couldn't find member %s to override\n", def->id->string);
1712 }
1713 }
1714 }
1715 }
1716 if(inCompiler)
1717 {
1718 external = MkExternalDeclaration((((void *)0)));
1719 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1720 curExternal = external;
1721 curExternal->symbol = symbol;
1722 }
1723 if((classType == 1 || classType == 5) && inCompiler)
1724 {
1725 AddSimpleBaseMembers(list, regClass->base, regClass);
1726 }
1727 if(definitions != (((void *)0)))
1728 {
1729 if(inCompiler)
1730 {
1731 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace))
1732 CheckMembersDefinitions(regClass, (((void *)0)), definitions, 1);
1733 else if(!symbol->isStatic)
1734 CheckMembersDefinitions(regClass, (((void *)0)), definitions, 2);
1735 }
1736 for(def = definitions->first; def; def = def->next)
1737 {
1738 if(def->type == 2)
1739 {
1740 struct Declaration * decl = def->decl;
1741
1742 if(decl->type == 0)
1743 {
1744 if(inCompiler && classType != 2)
1745 {
1746 ListAdd(list, MkClassDefDeclaration(decl));
1747 def->decl = (((void *)0));
1748 }
1749 }
1750 else if(decl->type == 2)
1751 {
1752 struct Instantiation * inst = decl->inst;
1753 struct Expression * exp = inst->exp;
1754 struct Symbol * classSym;
1755
1756 if(exp)
1757 {
1758 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
1759 struct Declarator * d;
1760
1761 ListAdd(specifiers, MkSpecifierName(inst->_class->name));
1762 d = MkDeclaratorIdentifier(MkIdentifier(exp->identifier->string));
1763 if(inCompiler)
1764 {
1765 struct __ecereNameSpace__ecere__sys__OldList * declarators = MkList();
1766
1767 ListAdd(declarators, d);
1768 decl = MkStructDeclaration(specifiers, declarators, (((void *)0)));
1769 ListAdd(list, MkClassDefDeclaration(decl));
1770 exp->type = 8;
1771 exp->member.member = exp->identifier;
1772 exp->member.exp = QMkExpId("this");
1773 exp->member.memberType = 3;
1774 exp->member.thisPtr = 0x1;
1775 }
1776 else
1777 {
1778 FreeDeclarator(d);
1779 FreeList(specifiers, FreeSpecifier);
1780 }
1781 }
1782 classSym = inst->_class->symbol;
1783 if(classSym && classSym->registered && (classSym->registered->type == 1 || classSym->registered->type == 2 || classSym->registered->type == 3))
1784 {
1785 if(inst->members && (*inst->members).count)
1786 symbol->needConstructor = 0x1;
1787 }
1788 else
1789 {
1790 symbol->needConstructor = 0x1;
1791 symbol->needDestructor = 0x1;
1792 }
1793 }
1794 }
1795 else if(def->type == 9)
1796 {
1797 struct Declaration * decl = def->decl;
1798
1799 if(decl->type == 0)
1800 {
1801 if(inCompiler && classType != 2)
1802 {
1803 ListAdd(classDataList, MkClassDefDeclaration(decl));
1804 def->decl = (((void *)0));
1805 }
1806 }
1807 }
1808 else if(def->type == 1)
1809 symbol->needConstructor = 0x1;
1810 else if(def->type == 4)
1811 symbol->needConstructor = 0x1;
1812 else if(def->type == 0)
1813 {
1814 struct ClassFunction * func = def->function;
1815
1816 if(func->isDestructor)
1817 {
1818 if(destructor)
1819 {
1820 yylloc = *loc;
1821 Compiler_Error("redefinition of destructor for class %s\n", symbol->string);
1822 }
1823 else
1824 {
1825 symbol->needDestructor = 0x1;
1826 destructor = func;
1827 if(!inCompiler && func->body)
1828 {
1829 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
1830
1831 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&func->body->compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
1832 }
1833 }
1834 }
1835 if(func->isConstructor)
1836 {
1837 if(constructor)
1838 {
1839 yylloc = *loc;
1840 Compiler_Error("redefinition of constructor for class %s\n", symbol->string);
1841 }
1842 else
1843 {
1844 symbol->needConstructor = 0x1;
1845 constructor = func;
1846 if(!inCompiler && func->body)
1847 {
1848 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
1849
1850 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&func->body->compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
1851 }
1852 }
1853 }
1854 }
1855 }
1856 }
1857 if(inCompiler)
1858 {
1859 external->symbol = (((void *)0));
1860 if((*list).count)
1861 {
1862 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * declarators = (initDeclarators != (((void *)0))) ? initDeclarators : MkList();
1863
1864 strcpy(structName, symbol->string);
1865 symbol->structName = __ecereNameSpace__ecere__sys__CopyString(structName);
1866 ListAdd(specs, MkStructOrUnion(3, MkIdentifier(structName), isUnion ? MkListOne(MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkStructOrUnion(4, (((void *)0)), list)), (((void *)0)), (((void *)0))))) : list));
1867 external->symbol = symbol;
1868 symbol->structExternal = external;
1869 external->declaration = MkDeclaration(specs, declarators);
1870 after = external;
1871 symbol->declaredStruct = 0x1;
1872 }
1873 else
1874 {
1875 curExternal = external->prev;
1876 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(defs, external);
1877 FreeExternal(external);
1878 (__ecereNameSpace__ecere__com__eSystem_Delete(list), list = 0);
1879 }
1880 if((*classDataList).count)
1881 {
1882 char classDataStructName[1024];
1883 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1884 struct External * external;
1885
1886 strcpy(classDataStructName, "__ecereClassData_");
1887 FullClassNameCat(classDataStructName, symbol->string, 0x0);
1888 declMode = 0;
1889 ListAdd(specs, MkStructOrUnion(3, MkIdentifier(classDataStructName), classDataList));
1890 external = MkExternalDeclaration(MkDeclaration(specs, (((void *)0))));
1891 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, external);
1892 after = external;
1893 symbol->classData = 0x1;
1894 }
1895 else
1896 (__ecereNameSpace__ecere__com__eSystem_Delete(classDataList), classDataList = 0);
1897 }
1898 if(inCompiler)
1899 {
1900 {
1901 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * declarators = MkList();
1902
1903 strcpy(className, "__ecereClass_");
1904 FullClassNameCat(className, symbol->string, 0x1);
1905 MangleClassName(className);
1906 symbol->className = __ecereNameSpace__ecere__sys__CopyString(className);
1907 if(!strstr(sourceFile, ".main.ec"))
1908 ListAdd(specs, MkSpecifier(286));
1909 ListAdd(specs, MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0))));
1910 ListAdd(declarators, MkInitDeclarator(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier(className))), (((void *)0))));
1911 symbol->methodExternal = MkExternalDeclaration(MkDeclaration(specs, declarators));
1912 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(defs, after, symbol->methodExternal);
1913 after = symbol->methodExternal;
1914 }
1915 if(symbol->needDestructor)
1916 {
1917 struct ClassFunction * function;
1918 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1919 struct Declarator * decl;
1920 struct Statement * body;
1921 struct Context * context;
1922 struct __ecereNameSpace__ecere__sys__OldList * declarations = (((void *)0)), * statements;
1923
1924 strcpy(destructorName, "__ecereDestructor_");
1925 FullClassNameCat(destructorName, symbol->string, 0x0);
1926 symbol->destructorName = __ecereNameSpace__ecere__sys__CopyString(destructorName);
1927 ListAdd(specs, MkSpecifier(301));
1928 context = PushContext();
1929 statements = MkList();
1930 if(definitions != (((void *)0)))
1931 {
1932 for(def = definitions->first; def; def = def->next)
1933 {
1934 if(def->type == 2 && def->decl && def->decl->type == 2)
1935 {
1936 struct Instantiation * inst = def->decl->inst;
1937 struct Symbol * classSym = inst->_class->symbol;
1938
1939 if(inst->exp && (!classSym || !classSym->registered || classSym->registered->type == 0))
1940 {
1941 struct Expression * exp = MkExpOp((((void *)0)), 328, CopyExpression(inst->exp));
1942
1943 ListAdd(statements, MkExpressionStmt(MkListOne(exp)));
1944 }
1945 if(inst->exp && (!classSym || !classSym->registered || classSym->registered->type == 5))
1946 {
1947 struct Expression * exp = MkExpOp((((void *)0)), 328, CopyExpression(inst->exp));
1948
1949 ListAdd(statements, MkExpressionStmt(MkListOne(exp)));
1950 }
1951 }
1952 }
1953 }
1954 if(destructor && destructor->body)
1955 {
1956 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*statements), (((void *)0)), destructor->body);
1957 destructor->body->compound.context->parent = context;
1958 destructor->body = (((void *)0));
1959 }
1960 body = MkCompoundStmt(declarations, statements);
1961 PopContext(context);
1962 body->compound.context = context;
1963 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(destructorName)), (((void *)0)));
1964 decl->symbol = (__ecereTemp1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), ((struct Symbol *)__ecereTemp1)->id = symbol->id, ((struct Symbol *)__ecereTemp1)->idCode = symbol->idCode, ((struct Symbol *)__ecereTemp1));
1965 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
1966 function = MkClassFunction(specs, (((void *)0)), decl, (((void *)0)));
1967 ProcessClassFunctionBody(function, body);
1968 function->id = symbol->id;
1969 function->idCode = symbol->idCode;
1970 function->dontMangle = 0x1;
1971 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(function));
1972 }
1973 if(symbol->needConstructor && inCompiler)
1974 {
1975 struct ClassFunction * function;
1976 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1977 struct Declarator * decl;
1978 struct Statement * body;
1979 struct Context * context;
1980 struct __ecereNameSpace__ecere__sys__OldList * declarations = (((void *)0)), * statements;
1981
1982 strcpy(constructorName, "__ecereConstructor_");
1983 FullClassNameCat(constructorName, symbol->string, 0x0);
1984 symbol->constructorName = __ecereNameSpace__ecere__sys__CopyString(constructorName);
1985 ListAdd(specs, MkSpecifierName("bool"));
1986 context = PushContext();
1987 statements = MkList();
1988 if(definitions != (((void *)0)))
1989 {
1990 for(def = definitions->first; def; def = def->next)
1991 {
1992 if(def->type == 2 && def->decl && def->decl->type == 2)
1993 {
1994 struct Instantiation * inst = def->decl->inst;
1995 struct Symbol * classSym = inst->_class->symbol;
1996
1997 if(inst->exp && (!classSym || !classSym->registered || classSym->registered->type == 0 || classSym->registered->type == 5))
1998 {
1999 struct Instantiation * newInst = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
2000
2001 *newInst = *inst;
2002 newInst->members = (((void *)0));
2003 newInst->exp = CopyExpression(inst->exp);
2004 newInst->_class = CopySpecifier(inst->_class);
2005 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpInstance(newInst))));
2006 inst->built = 0x1;
2007 }
2008 if(inst->exp && (!classSym || !classSym->registered || classSym->registered->type == 0))
2009 {
2010 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")), MkListOne(CopyExpression(inst->exp))))));
2011 }
2012 }
2013 }
2014 for(def = definitions->first; def; def = def->next)
2015 {
2016 if(def->type == 1 && def->defProperties)
2017 {
2018 struct MemberInit * propertyDef;
2019
2020 for(propertyDef = (*def->defProperties).first; propertyDef; propertyDef = propertyDef->next)
2021 {
2022 struct Expression * memberExp;
2023 struct Identifier * id = (*propertyDef->identifiers).first;
2024
2025 if(id)
2026 {
2027 memberExp = MkExpMember(MkExpIdentifier(MkIdentifier("this")), id);
2028 for(id = id->next; id; id = id->next)
2029 memberExp = MkExpMember(memberExp, id);
2030 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(memberExp, '=', (propertyDef->initializer && propertyDef->initializer->type == 0 ? propertyDef->initializer->exp : (((void *)0)))))));
2031 }
2032 if(propertyDef->initializer)
2033 {
2034 if(propertyDef->initializer->type == 0)
2035 propertyDef->initializer->exp = (((void *)0));
2036 FreeInitializer(propertyDef->initializer);
2037 }
2038 propertyDef->initializer = (((void *)0));
2039 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear((&*propertyDef->identifiers));
2040 }
2041 }
2042 }
2043 for(def = definitions->first; def; def = def->next)
2044 {
2045 if(def->type == 2 && def->decl && def->decl->type == 2)
2046 {
2047 struct Instantiation * inst = def->decl->inst;
2048 struct Symbol * classSym = inst->_class->symbol;
2049
2050 if(inst->exp || (!classSym || !classSym->registered || classSym->registered->type == 0 || classSym->registered->type == 5))
2051 {
2052 if(!(inst->exp && (!classSym || !classSym->registered || classSym->registered->type == 0 || classSym->registered->type == 5)) || (inst->members && (*inst->members).count))
2053 {
2054 def->decl->inst = (((void *)0));
2055 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpInstance(inst))));
2056 }
2057 }
2058 }
2059 }
2060 }
2061 if(constructor && constructor->body)
2062 {
2063 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*statements), constructor->body);
2064 constructor->body->compound.context->parent = context;
2065 constructor->body = (((void *)0));
2066 }
2067 ListAdd(statements, MkReturnStmt(MkListOne(MkExpIdentifier(MkIdentifier("true")))));
2068 body = MkCompoundStmt(declarations, statements);
2069 PopContext(context);
2070 body->compound.context = context;
2071 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(constructorName)), (((void *)0)));
2072 decl->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2073 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), decl->symbol);
2074 decl->symbol->id = symbol->id;
2075 decl->symbol->idCode = symbol->idCode;
2076 function = MkClassFunction(specs, (((void *)0)), decl, (((void *)0)));
2077 ProcessClassFunctionBody(function, body);
2078 function->id = symbol->id;
2079 function->idCode = symbol->idCode;
2080 function->dontMangle = 0x1;
2081 if(definitions != (((void *)0)))
2082 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, (((void *)0)), MkClassDefFunction(function));
2083 }
2084 }
2085 if(definitions != (((void *)0)))
2086 {
2087 for(def = definitions->first; def; def = def->next)
2088 {
2089 if(def->type == 3 && def->propertyDef)
2090 {
2091 struct PropertyDef * propertyDef = def->propertyDef;
2092 struct ClassDef * after = def;
2093 struct ClassDef * newDef;
2094
2095 if(inCompiler)
2096 {
2097 yylloc = propertyDef->loc;
2098 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace) && def->memberAccess == 1)
2099 CheckPublicDataType(propertyDef->symbol->type, 1, "class property");
2100 else if(!symbol->isStatic)
2101 CheckPublicDataType(propertyDef->symbol->type, 2, "class property");
2102 }
2103 {
2104 {
2105 struct ClassFunction * func;
2106 struct Declarator * decl;
2107 char name[1024];
2108 struct __ecereNameSpace__ecere__sys__OldList * params;
2109
2110 if(propertyDef->getStmt && propertyDef->id)
2111 {
2112 strcpy(name, "__ecereProp_");
2113 FullClassNameCat(name, symbol->string, 0x0);
2114 strcat(name, "_Get_");
2115 FullClassNameCat(name, propertyDef->id->string, 0x1);
2116 MangleClassName(name);
2117 params = MkList();
2118 if(propertyDef->symbol->type && propertyDef->symbol->type->kind == 8 && propertyDef->symbol->type->_class && propertyDef->symbol->type->_class->registered && propertyDef->symbol->type->_class->registered->type == 1)
2119 {
2120 ListAdd(params, MkTypeName(CopyList(propertyDef->specifiers, CopySpecifier), MkDeclaratorIdentifier(MkIdentifier("value"))));
2121 decl = PlugDeclarator(propertyDef->declarator, MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(name)), params));
2122 func = MkClassFunction(MkListOne(MkSpecifier(301)), (((void *)0)), decl, (((void *)0)));
2123 }
2124 else
2125 {
2126 decl = PlugDeclarator(propertyDef->declarator, MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(name)), params));
2127 func = MkClassFunction(CopyList(propertyDef->specifiers, CopySpecifier), (((void *)0)), decl, (((void *)0)));
2128 }
2129 ProcessClassFunctionBody(func, propertyDef->getStmt);
2130 func->declarator->symbol = propertyDef->symbol;
2131 propertyDef->symbol->externalGet = (struct External *)func;
2132 func->dontMangle = 0x1;
2133 newDef = MkClassDefFunction(func);
2134 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, after, newDef);
2135 after = newDef;
2136 if(inCompiler)
2137 propertyDef->getStmt = (((void *)0));
2138 else
2139 func->body = (((void *)0));
2140 }
2141 if(propertyDef->setStmt && propertyDef->id)
2142 {
2143 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2144
2145 strcpy(name, "__ecereProp_");
2146 FullClassNameCat(name, symbol->string, 0x0);
2147 strcat(name, "_Set_");
2148 FullClassNameCat(name, propertyDef->id->string, 0x1);
2149 MangleClassName(name);
2150 params = MkList();
2151 ListAdd(params, MkTypeName(CopyList(propertyDef->specifiers, CopySpecifier), PlugDeclarator(propertyDef->declarator, MkDeclaratorIdentifier(MkIdentifier("value")))));
2152 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(name)), params);
2153 if(!propertyDef->symbol->_property || !propertyDef->symbol->_property->conversion)
2154 ListAdd(specifiers, MkSpecifier(301));
2155 else
2156 {
2157 if(regClass->type == 1)
2158 ListAdd(specifiers, MkSpecifier(301));
2159 else
2160 ListAdd(specifiers, MkSpecifierName(regClass->fullName));
2161 }
2162 func = MkClassFunction(specifiers, (((void *)0)), decl, (((void *)0)));
2163 ProcessClassFunctionBody(func, propertyDef->setStmt);
2164 func->dontMangle = 0x1;
2165 func->declarator->symbol = propertyDef->symbol;
2166 propertyDef->symbol->externalSet = (struct External *)func;
2167 if(!propertyDef->conversion && regClass->type == 0)
2168 func->propSet = propertyDef->symbol;
2169 newDef = MkClassDefFunction(func);
2170 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, after, newDef);
2171 after = newDef;
2172 if(inCompiler)
2173 propertyDef->setStmt = (((void *)0));
2174 else
2175 func->body = (((void *)0));
2176 }
2177 if(propertyDef->issetStmt && propertyDef->id)
2178 {
2179 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2180
2181 strcpy(name, "__ecereProp_");
2182 FullClassNameCat(name, symbol->string, 0x0);
2183 strcat(name, "_IsSet_");
2184 FullClassNameCat(name, propertyDef->id->string, 0x1);
2185 MangleClassName(name);
2186 params = MkList();
2187 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(name)), params);
2188 ListAdd(specifiers, MkSpecifierName("bool"));
2189 func = MkClassFunction(specifiers, (((void *)0)), decl, (((void *)0)));
2190 ProcessClassFunctionBody(func, propertyDef->issetStmt);
2191 func->dontMangle = 0x1;
2192 func->declarator->symbol = propertyDef->symbol;
2193 propertyDef->symbol->externalIsSet = (struct External *)func;
2194 newDef = MkClassDefFunction(func);
2195 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, after, newDef);
2196 after = newDef;
2197 if(inCompiler)
2198 propertyDef->issetStmt = (((void *)0));
2199 else
2200 func->body = (((void *)0));
2201 }
2202 if(propertyDef->id && inCompiler)
2203 {
2204 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(symbol->registered, propertyDef->id->string, privateModule);
2205 struct Declaration * decl;
2206 struct External * external;
2207 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2208
2209 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(286));
2210 ListAdd(specifiers, MkSpecifierName("Property"));
2211 strcpy(name, "__ecereProp_");
2212 FullClassNameCat(name, symbol->string, 0x0);
2213 strcat(name, "_");
2214 FullClassNameCat(name, propertyDef->id->string, 0x1);
2215 MangleClassName(name);
2216 {
2217 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
2218
2219 ListAdd(list, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(name)), (((void *)0))));
2220 strcpy(name, "__ecerePropM_");
2221 FullClassNameCat(name, symbol->string, 0x0);
2222 strcat(name, "_");
2223 FullClassNameCat(name, propertyDef->id->string, 0x1);
2224 MangleClassName(name);
2225 ListAdd(list, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(name)), (((void *)0))));
2226 decl = MkDeclaration(specifiers, list);
2227 }
2228 external = MkExternalDeclaration(decl);
2229 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal ? curExternal->prev : (((void *)0)), external);
2230 external->symbol = propertyDef->symbol;
2231 propertyDef->symbol->externalPtr = external;
2232 if(inCompiler && prop && prop->symbol)
2233 ((struct Symbol *)prop->symbol)->externalPtr = external;
2234 }
2235 }
2236 }
2237 }
2238 else if(def->type == 10 && def->propertyDef)
2239 {
2240 struct PropertyDef * propertyDef = def->propertyDef;
2241 struct ClassDef * after = def;
2242 struct ClassDef * newDef;
2243
2244 {
2245 if(inCompiler)
2246 {
2247 yylloc = propertyDef->loc;
2248 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace))
2249 CheckPublicDataType(propertyDef->symbol->type, 1, "classwide property");
2250 else if(!symbol->isStatic)
2251 CheckPublicDataType(propertyDef->symbol->type, 2, "classwide property");
2252 }
2253 {
2254 struct ClassFunction * func;
2255 struct Declarator * decl;
2256 char name[1024];
2257 struct __ecereNameSpace__ecere__sys__OldList * params;
2258
2259 if(propertyDef->getStmt && propertyDef->id)
2260 {
2261 struct Declarator * declId;
2262
2263 sprintf(name, "class::__ecereClassProp_");
2264 FullClassNameCat(name, symbol->string, 0x0);
2265 strcat(name, "_Get_");
2266 strcat(name, propertyDef->id->string);
2267 MangleClassName(name);
2268 params = MkList();
2269 declId = MkDeclaratorIdentifier(MkIdentifier(name));
2270 if(propertyDef->symbol->type && propertyDef->symbol->type->kind == 8 && propertyDef->symbol->type->_class && propertyDef->symbol->type->_class->registered && propertyDef->symbol->type->_class->registered->type == 1)
2271 {
2272 ListAdd(params, MkTypeName(CopyList(propertyDef->specifiers, CopySpecifier), MkDeclaratorIdentifier(MkIdentifier("value"))));
2273 decl = PlugDeclarator(propertyDef->declarator, MkDeclaratorFunction(declId, params));
2274 func = MkClassFunction(MkListOne(MkSpecifier(301)), (((void *)0)), decl, (((void *)0)));
2275 }
2276 else
2277 {
2278 decl = PlugDeclarator(propertyDef->declarator, MkDeclaratorFunction(declId, params));
2279 func = MkClassFunction(CopyList(propertyDef->specifiers, CopySpecifier), (((void *)0)), decl, (((void *)0)));
2280 }
2281 ProcessClassFunctionBody(func, propertyDef->getStmt);
2282 func->declarator->symbol = propertyDef->symbol;
2283 propertyDef->symbol->externalGet = (struct External *)func;
2284 func->dontMangle = 0x1;
2285 newDef = MkClassDefFunction(func);
2286 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, after, newDef);
2287 after = newDef;
2288 if(inCompiler)
2289 propertyDef->getStmt = (((void *)0));
2290 else
2291 func->body = (((void *)0));
2292 }
2293 if(propertyDef->setStmt && propertyDef->id)
2294 {
2295 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
2296
2297 strcpy(name, "class::__ecereClassProp_");
2298 FullClassNameCat(name, symbol->string, 0x0);
2299 strcat(name, "_Set_");
2300 strcat(name, propertyDef->id->string);
2301 MangleClassName(name);
2302 params = MkList();
2303 ListAdd(params, MkTypeName(CopyList(propertyDef->specifiers, CopySpecifier), PlugDeclarator(propertyDef->declarator, MkDeclaratorIdentifier(MkIdentifier("value")))));
2304 decl = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(name)), params);
2305 ListAdd(specifiers, MkSpecifier(301));
2306 func = MkClassFunction(specifiers, (((void *)0)), decl, (((void *)0)));
2307 ProcessClassFunctionBody(func, propertyDef->setStmt);
2308 func->dontMangle = 0x1;
2309 func->declarator->symbol = propertyDef->symbol;
2310 propertyDef->symbol->externalSet = (struct External *)func;
2311 newDef = MkClassDefFunction(func);
2312 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(definitions, after, newDef);
2313 after = newDef;
2314 if(inCompiler)
2315 propertyDef->setStmt = (((void *)0));
2316 else
2317 func->body = (((void *)0));
2318 }
2319 }
2320 }
2321 }
2322 else if(def->type == 0 && def->function->declarator)
2323 {
2324 struct ClassFunction * func = def->function;
2325
2326 func->_class = regClass;
2327 if(!func->dontMangle)
2328 {
2329 struct Declarator * funcDecl = GetFuncDecl(func->declarator);
2330 struct Identifier * id = GetDeclId(funcDecl);
2331 struct __ecereNameSpace__ecere__com__Method * method;
2332
2333 if(!funcDecl->function.parameters || !(*funcDecl->function.parameters).first)
2334 {
2335 if(!funcDecl->function.parameters)
2336 funcDecl->function.parameters = MkList();
2337 ListAdd(funcDecl->function.parameters, MkTypeName(MkListOne(MkSpecifier(301)), (((void *)0))));
2338 }
2339 method = __ecereNameSpace__ecere__com__eClass_FindMethod(regClass, id->string, privateModule);
2340 FreeSpecifier(id->_class);
2341 id->_class = (((void *)0));
2342 if(inCompiler && method)
2343 {
2344 char * newId = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (strlen(id->string) + strlen("__ecereMethod___ecereNameSpace__") + strlen(symbol->string) + 2));
2345
2346 newId[0] = '\0';
2347 ProcessMethodType(method);
2348 yylloc = def->loc;
2349 if(!NameSpaceContained(regClass->nameSpace, &((struct __ecereNameSpace__ecere__com__Module *)(((char *)regClass->module + 12)))->privateNameSpace) && method->memberAccess == 1)
2350 CheckPublicDataType(method->dataType, 1, "class method");
2351 strcpy(newId, "__ecereMethod_");
2352 FullClassNameCat(newId, symbol->string, 0x0);
2353 strcat(newId, "_");
2354 strcat(newId, id->string);
2355 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
2356 id->string = newId;
2357 if(method->type != 1)
2358 {
2359 if(method->symbol)
2360 {
2361 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct Symbol *)method->symbol)->string), ((struct Symbol *)method->symbol)->string = 0);
2362 ((struct Symbol *)method->symbol)->string = __ecereNameSpace__ecere__sys__CopyString(newId);
2363 }
2364 }
2365 }
2366 }
2367 }
2368 }
2369 }
2370 }
2371
2372 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
2373
2374 void PreProcessClassDefinitions()
2375 {
2376 struct External * external, * next;
2377
2378 curExternal = (((void *)0));
2379 if(ast)
2380 {
2381 for(external = (*ast).first; external; external = next)
2382 {
2383 next = external->next;
2384 curExternal = external;
2385 if(external->type == 2)
2386 {
2387 struct ClassDefinition * _class = external->_class;
2388
2389 if(_class->definitions)
2390 {
2391 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), &_class->loc, ast, external->prev, (((void *)0)));
2392 }
2393 }
2394 else if(external->type == 1)
2395 {
2396 struct Declaration * declaration = external->declaration;
2397
2398 if(declaration->type == 1)
2399 {
2400 if(declaration->specifiers)
2401 {
2402 struct Specifier * specifier;
2403
2404 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2405 {
2406 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2407 {
2408 struct Symbol * symbol = FindClass(specifier->id->string);
2409
2410 if(symbol)
2411 {
2412 ProcessClass((specifier->type == 4) ? 6 : 0, specifier->definitions, symbol, specifier->baseSpecs, specifier->list, &specifier->loc, ast, external->prev, declaration->declarators);
2413 declaration->declarators = (((void *)0));
2414 }
2415 }
2416 }
2417 }
2418 }
2419 else if(inCompiler && declaration->type == 3)
2420 {
2421 yylloc = declaration->loc;
2422 if(declaration->declMode == 1)
2423 CheckPublicExpression(declaration->exp, 1);
2424 else if(declaration->declMode != 3)
2425 CheckPublicExpression(declaration->exp, 2);
2426 }
2427 }
2428 else if(external->type == 3)
2429 {
2430 }
2431 else if(inCompiler && external->type == 0)
2432 {
2433 yylloc = external->function->loc;
2434 if(!external->function->type)
2435 external->function->type = ProcessType(external->function->specifiers, external->function->declarator);
2436 if(external->function->declMode == 1)
2437 CheckPublicDataType(external->function->type, 1, "function");
2438 else if(external->function->declMode != 3)
2439 CheckPublicDataType(external->function->type, 2, "function");
2440 }
2441 }
2442 }
2443 }
2444
2445 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2446
2447 struct __ecereNameSpace__ecere__com__GlobalFunction;
2448
2449 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);
2450
2451 void __ecereRegisterModule_pass0(struct __ecereNameSpace__ecere__com__Instance * module)
2452 {
2453 struct __ecereNameSpace__ecere__com__Class * class;
2454
2455 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MangleClassName", "void MangleClassName(char * className)", MangleClassName, module, 1);
2456 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FullClassNameCat", "void FullClassNameCat(char * output, char * className, bool includeTemplateParams)", FullClassNameCat, module, 1);
2457 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PreProcessClassDefinitions", "void PreProcessClassDefinitions(void)", PreProcessClassDefinitions, module, 1);
2458 }
2459
2460 void __ecereUnregisterModule_pass0(struct __ecereNameSpace__ecere__com__Instance * module)
2461 {
2462
2463 }
2464