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