The Ecere SDK - sdk/blob - compiler/bootstrap/libec/bootstrap/pass3.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 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 120
 121 struct Context;
 122
 123 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 124
 125 struct Instantiation;
 126
 127 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 128
 129 struct Declaration
 130 {
 131 struct Declaration * prev;
 132 struct Declaration * next;
 133 struct Location loc;
 134 int type;
 135 union
 136 {
 137 struct
 138 {
 139 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 140 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 141 };
 142 struct Instantiation * inst;
 143 struct
 144 {
 145 struct Identifier * id;
 146 struct Expression * exp;
 147 };
 148 };
 149 struct Specifier * extStorage;
 150 struct Symbol * symbol;
 151 int declMode;
 152 };
 153
 154 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 155
 156 struct Statement
 157 {
 158 struct Statement * prev;
 159 struct Statement * next;
 160 struct Location loc;
 161 int type;
 162 union
 163 {
 164 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 165 struct
 166 {
 167 struct Identifier * id;
 168 struct Statement * stmt;
 169 } labeled;
 170 struct
 171 {
 172 struct Expression * exp;
 173 struct Statement * stmt;
 174 } caseStmt;
 175 struct
 176 {
 177 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 178 struct __ecereNameSpace__ecere__sys__OldList * statements;
 179 struct Context * context;
 180 unsigned int isSwitch;
 181 } compound;
 182 struct
 183 {
 184 struct __ecereNameSpace__ecere__sys__OldList * exp;
 185 struct Statement * stmt;
 186 struct Statement * elseStmt;
 187 } ifStmt;
 188 struct
 189 {
 190 struct __ecereNameSpace__ecere__sys__OldList * exp;
 191 struct Statement * stmt;
 192 } switchStmt;
 193 struct
 194 {
 195 struct __ecereNameSpace__ecere__sys__OldList * exp;
 196 struct Statement * stmt;
 197 } whileStmt;
 198 struct
 199 {
 200 struct __ecereNameSpace__ecere__sys__OldList * exp;
 201 struct Statement * stmt;
 202 } doWhile;
 203 struct
 204 {
 205 struct Statement * init;
 206 struct Statement * check;
 207 struct __ecereNameSpace__ecere__sys__OldList * increment;
 208 struct Statement * stmt;
 209 } forStmt;
 210 struct
 211 {
 212 struct Identifier * id;
 213 } gotoStmt;
 214 struct
 215 {
 216 struct Specifier * spec;
 217 char * statements;
 218 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 219 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 220 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 221 } asmStmt;
 222 struct
 223 {
 224 struct Expression * watcher;
 225 struct Expression * object;
 226 struct __ecereNameSpace__ecere__sys__OldList * watches;
 227 } _watch;
 228 struct
 229 {
 230 struct Identifier * id;
 231 struct __ecereNameSpace__ecere__sys__OldList * exp;
 232 struct __ecereNameSpace__ecere__sys__OldList * filter;
 233 struct Statement * stmt;
 234 } forEachStmt;
 235 struct Declaration * decl;
 236 };
 237 };
 238
 239 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 240
 241 struct TypeName
 242 {
 243 struct TypeName * prev;
 244 struct TypeName * next;
 245 struct Location loc;
 246 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 247 struct Declarator * declarator;
 248 int classObjectType;
 249 struct Expression * bitCount;
 250 };
 251
 252 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 253
 254 struct Initializer
 255 {
 256 struct Initializer * prev;
 257 struct Initializer * next;
 258 struct Location loc;
 259 int type;
 260 union
 261 {
 262 struct Expression * exp;
 263 struct __ecereNameSpace__ecere__sys__OldList *  list;
 264 };
 265 unsigned int isConstant;
 266 };
 267
 268 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 269
 270 struct __ecereNameSpace__ecere__com__DataValue
 271 {
 272 union
 273 {
 274 char c;
 275 unsigned char uc;
 276 short s;
 277 unsigned short us;
 278 int i;
 279 unsigned int ui;
 280 void *  p;
 281 float f;
 282 double d;
 283 long long i64;
 284 uint64 ui64;
 285 };
 286 };
 287
 288 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 289
 290 struct Expression
 291 {
 292 struct Expression * prev;
 293 struct Expression * next;
 294 struct Location loc;
 295 int type;
 296 union
 297 {
 298 struct
 299 {
 300 char *  constant;
 301 struct Identifier * identifier;
 302 };
 303 struct Statement * compound;
 304 struct Instantiation * instance;
 305 char *  string;
 306 struct __ecereNameSpace__ecere__sys__OldList *  list;
 307 struct
 308 {
 309 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 310 struct Declarator * decl;
 311 } _classExp;
 312 struct
 313 {
 314 struct Identifier * id;
 315 } classData;
 316 struct
 317 {
 318 struct Expression * exp;
 319 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 320 struct Location argLoc;
 321 } call;
 322 struct
 323 {
 324 struct Expression * exp;
 325 struct __ecereNameSpace__ecere__sys__OldList * index;
 326 } index;
 327 struct
 328 {
 329 struct Expression * exp;
 330 struct Identifier * member;
 331 int memberType;
 332 unsigned int thisPtr;
 333 } member;
 334 struct
 335 {
 336 int op;
 337 struct Expression * exp1;
 338 struct Expression * exp2;
 339 } op;
 340 struct TypeName * typeName;
 341 struct Specifier * _class;
 342 struct
 343 {
 344 struct TypeName * typeName;
 345 struct Expression * exp;
 346 } cast;
 347 struct
 348 {
 349 struct Expression * cond;
 350 struct __ecereNameSpace__ecere__sys__OldList * exp;
 351 struct Expression * elseExp;
 352 } cond;
 353 struct
 354 {
 355 struct TypeName * typeName;
 356 struct Expression * size;
 357 } _new;
 358 struct
 359 {
 360 struct TypeName * typeName;
 361 struct Expression * size;
 362 struct Expression * exp;
 363 } _renew;
 364 struct
 365 {
 366 char * table;
 367 struct Identifier * id;
 368 } db;
 369 struct
 370 {
 371 struct Expression * ds;
 372 struct Expression * name;
 373 } dbopen;
 374 struct
 375 {
 376 struct TypeName * typeName;
 377 struct Initializer * initializer;
 378 } initializer;
 379 struct
 380 {
 381 struct Expression * exp;
 382 struct TypeName * typeName;
 383 } vaArg;
 384 };
 385 unsigned int debugValue;
 386 struct __ecereNameSpace__ecere__com__DataValue val;
 387 unsigned int address;
 388 unsigned int hasAddress;
 389 struct Type * expType;
 390 struct Type * destType;
 391 unsigned int usage;
 392 int tempCount;
 393 unsigned int byReference;
 394 unsigned int isConstant;
 395 unsigned int addedThis;
 396 unsigned int needCast;
 397 unsigned int thisPtr;
 398 };
 399
 400 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 401
 402 struct TemplateDatatype
 403 {
 404 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 405 struct Declarator * decl;
 406 };
 407
 408 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 409
 410 struct TemplateArgument;
 411
 412 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 413
 414 struct TemplateParameter
 415 {
 416 struct TemplateParameter * prev;
 417 struct TemplateParameter * next;
 418 struct Location loc;
 419 int type;
 420 struct Identifier * identifier;
 421 union
 422 {
 423 struct TemplateDatatype * dataType;
 424 int memberType;
 425 };
 426 struct TemplateArgument * defaultArgument;
 427 char *  dataTypeString;
 428 struct Type * baseType;
 429 };
 430
 431 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 432
 433 struct Specifier
 434 {
 435 struct Specifier * prev;
 436 struct Specifier * next;
 437 struct Location loc;
 438 int type;
 439 union
 440 {
 441 int specifier;
 442 struct
 443 {
 444 char *  name;
 445 struct Symbol * symbol;
 446 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 447 };
 448 struct
 449 {
 450 struct Identifier * id;
 451 struct __ecereNameSpace__ecere__sys__OldList *  list;
 452 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 453 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 454 unsigned int addNameSpace;
 455 struct Context * ctx;
 456 };
 457 struct Expression * expression;
 458 struct Specifier * _class;
 459 struct TemplateParameter * templateParameter;
 460 };
 461 };
 462
 463 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 464
 465 struct Identifier
 466 {
 467 struct Identifier * prev;
 468 struct Identifier * next;
 469 struct Location loc;
 470 struct Symbol * classSym;
 471 struct Specifier * _class;
 472 char *  string;
 473 struct Identifier * badID;
 474 };
 475
 476 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 477
 478 struct Pointer;
 479
 480 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 481
 482 struct Declarator
 483 {
 484 struct Declarator * prev;
 485 struct Declarator * next;
 486 struct Location loc;
 487 int type;
 488 struct Symbol * symbol;
 489 struct Declarator * declarator;
 490 union
 491 {
 492 struct Identifier * identifier;
 493 struct
 494 {
 495 struct Expression * exp;
 496 struct Expression * posExp;
 497 char * attrib;
 498 } structDecl;
 499 struct
 500 {
 501 struct Expression * exp;
 502 struct Specifier * enumClass;
 503 } array;
 504 struct
 505 {
 506 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 507 } function;
 508 struct
 509 {
 510 struct Pointer * pointer;
 511 } pointer;
 512 struct
 513 {
 514 char * extended;
 515 } extended;
 516 };
 517 };
 518
 519 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 520
 521 struct FunctionDefinition
 522 {
 523 struct FunctionDefinition * prev;
 524 struct FunctionDefinition * next;
 525 struct Location loc;
 526 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 527 struct Declarator * declarator;
 528 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 529 struct Statement * body;
 530 struct __ecereNameSpace__ecere__com__Class * _class;
 531 struct __ecereNameSpace__ecere__sys__OldList attached;
 532 int declMode;
 533 struct Type * type;
 534 struct Symbol * propSet;
 535 int tempCount;
 536 unsigned int propertyNoThis;
 537 };
 538
 539 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 540
 541 struct DBTableDef;
 542
 543 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 544
 545 struct External
 546 {
 547 struct External * prev;
 548 struct External * next;
 549 struct Location loc;
 550 int type;
 551 struct Symbol * symbol;
 552 union
 553 {
 554 struct FunctionDefinition * function;
 555 struct ClassDefinition * _class;
 556 struct Declaration * declaration;
 557 char *  importString;
 558 struct Identifier * id;
 559 struct DBTableDef * table;
 560 };
 561 int importType;
 562 };
 563
 564 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 565
 566 struct ModuleImport;
 567
 568 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 569
 570 struct ClassImport;
 571
 572 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 573
 574 struct Symbol
 575 {
 576 char *  string;
 577 struct Symbol * parent;
 578 struct Symbol * left;
 579 struct Symbol * right;
 580 int depth;
 581 struct Type * type;
 582 union
 583 {
 584 struct __ecereNameSpace__ecere__com__Method * method;
 585 struct __ecereNameSpace__ecere__com__Property * _property;
 586 struct __ecereNameSpace__ecere__com__Class * registered;
 587 };
 588 int id;
 589 int idCode;
 590 union
 591 {
 592 struct
 593 {
 594 struct External * pointerExternal;
 595 struct External * structExternal;
 596 };
 597 struct
 598 {
 599 struct External * externalGet;
 600 struct External * externalSet;
 601 struct External * externalPtr;
 602 struct External * externalIsSet;
 603 };
 604 struct
 605 {
 606 struct External * methodExternal;
 607 struct External * methodCodeExternal;
 608 };
 609 };
 610 unsigned int imported;
 611 unsigned int declaredStructSym;
 612 struct __ecereNameSpace__ecere__com__Class * _class;
 613 unsigned int declaredStruct;
 614 unsigned int needConstructor;
 615 unsigned int needDestructor;
 616 char *  constructorName;
 617 char *  structName;
 618 char *  className;
 619 char *  destructorName;
 620 struct ModuleImport * module;
 621 struct ClassImport * _import;
 622 struct Location nameLoc;
 623 unsigned int isParam;
 624 unsigned int isRemote;
 625 unsigned int isStruct;
 626 unsigned int fireWatchersDone;
 627 int declaring;
 628 unsigned int classData;
 629 unsigned int isStatic;
 630 char *  shortName;
 631 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 632 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 633 struct Context * ctx;
 634 int isIterator;
 635 };
 636
 637 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 638
 639 struct Type
 640 {
 641 struct Type * prev;
 642 struct Type * next;
 643 int refCount;
 644 union
 645 {
 646 struct Symbol * _class;
 647 struct
 648 {
 649 struct __ecereNameSpace__ecere__sys__OldList members;
 650 char *  enumName;
 651 };
 652 struct
 653 {
 654 struct Type * returnType;
 655 struct __ecereNameSpace__ecere__sys__OldList params;
 656 struct Symbol * thisClass;
 657 unsigned int staticMethod;
 658 struct TemplateParameter * thisClassTemplate;
 659 };
 660 struct
 661 {
 662 struct __ecereNameSpace__ecere__com__Method * method;
 663 struct __ecereNameSpace__ecere__com__Class * methodClass;
 664 struct __ecereNameSpace__ecere__com__Class * usedClass;
 665 };
 666 struct
 667 {
 668 struct Type * arrayType;
 669 int arraySize;
 670 struct Expression * arraySizeExp;
 671 unsigned int freeExp;
 672 struct Symbol * enumClass;
 673 };
 674 struct Type * type;
 675 struct TemplateParameter * templateParameter;
 676 };
 677 unsigned int isSigned;
 678 int kind;
 679 unsigned int constant;
 680 unsigned int size;
 681 char *  name;
 682 char *  typeName;
 683 unsigned int count;
 684 unsigned int truth;
 685 int classObjectType;
 686 unsigned int byReference;
 687 unsigned int extraParam;
 688 int alignment;
 689 unsigned int directClassAccess;
 690 unsigned int computing;
 691 unsigned int dllExport;
 692 unsigned int offset;
 693 unsigned int keepCast;
 694 unsigned int passAsTemplate;
 695 int bitFieldCount;
 696 };
 697
 698 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 699
 700 struct __ecereNameSpace__ecere__com__Class
 701 {
 702 struct __ecereNameSpace__ecere__com__Class * prev;
 703 struct __ecereNameSpace__ecere__com__Class * next;
 704 char *  name;
 705 int offset;
 706 int structSize;
 707 int (* *  _vTbl)();
 708 int vTblSize;
 709 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 710 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 711 int offsetClass;
 712 int sizeClass;
 713 struct __ecereNameSpace__ecere__com__Class * base;
 714 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 715 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 716 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 717 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 718 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 719 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 720 int memberID;
 721 int startMemberID;
 722 int type;
 723 struct __ecereNameSpace__ecere__com__Instance * module;
 724 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 725 char *  dataTypeString;
 726 struct Type * dataType;
 727 int typeSize;
 728 int defaultAlignment;
 729 void (*  Initialize)();
 730 int memberOffset;
 731 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 732 char *  designerClass;
 733 unsigned int noExpansion;
 734 char *  defaultProperty;
 735 unsigned int comRedefinition;
 736 int count;
 737 unsigned int isRemote;
 738 unsigned int internalDecl;
 739 void *  data;
 740 unsigned int computeSize;
 741 int structAlignment;
 742 int destructionWatchOffset;
 743 unsigned int fixed;
 744 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 745 int inheritanceAccess;
 746 char *  fullName;
 747 void *  symbol;
 748 struct __ecereNameSpace__ecere__sys__OldList conversions;
 749 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 750 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 751 struct __ecereNameSpace__ecere__com__Class * templateClass;
 752 struct __ecereNameSpace__ecere__sys__OldList templatized;
 753 int numParams;
 754 };
 755
 756 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 757
 758 struct __ecereNameSpace__ecere__com__Instance
 759 {
 760 int (* *  _vTbl)();
 761 struct __ecereNameSpace__ecere__com__Class * _class;
 762 int _refCount;
 763 };
 764
 765 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 766
 767 struct __ecereNameSpace__ecere__com__DataMember
 768 {
 769 struct __ecereNameSpace__ecere__com__DataMember * prev;
 770 struct __ecereNameSpace__ecere__com__DataMember * next;
 771 char *  name;
 772 unsigned int isProperty;
 773 int memberAccess;
 774 int id;
 775 struct __ecereNameSpace__ecere__com__Class * _class;
 776 char *  dataTypeString;
 777 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 778 struct Type * dataType;
 779 int type;
 780 int offset;
 781 int memberID;
 782 struct __ecereNameSpace__ecere__sys__OldList members;
 783 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 784 int memberOffset;
 785 int structAlignment;
 786 };
 787
 788 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 789
 790 struct __ecereNameSpace__ecere__com__SerialBuffer
 791 {
 792 unsigned char *  _buffer;
 793 unsigned int count;
 794 unsigned int _size;
 795 unsigned int pos;
 796 };
 797
 798 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 799
 800 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 801 {
 802 union
 803 {
 804 struct
 805 {
 806 char *  dataTypeString;
 807 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 808 };
 809 struct __ecereNameSpace__ecere__com__DataValue expression;
 810 struct
 811 {
 812 char *  memberString;
 813 union
 814 {
 815 struct __ecereNameSpace__ecere__com__DataMember * member;
 816 struct __ecereNameSpace__ecere__com__Property * prop;
 817 struct __ecereNameSpace__ecere__com__Method * method;
 818 };
 819 };
 820 };
 821 };
 822
 823 enum yytokentype
 824 {
 825 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, EXT_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
 826 };
 827
 828 typedef union YYSTYPE
 829 {
 830 int specifierType;
 831 int i;
 832 int declMode;
 833 struct Identifier * id;
 834 struct Expression * exp;
 835 struct Specifier * specifier;
 836 struct __ecereNameSpace__ecere__sys__OldList * list;
 837 struct Enumerator * enumerator;
 838 struct Declarator * declarator;
 839 struct Pointer * pointer;
 840 struct Initializer * initializer;
 841 struct InitDeclarator * initDeclarator;
 842 struct TypeName * typeName;
 843 struct Declaration * declaration;
 844 struct Statement * stmt;
 845 struct FunctionDefinition * function;
 846 struct External * external;
 847 struct Context * context;
 848 struct AsmField * asmField;
 849 struct Instantiation * instance;
 850 struct MembersInit * membersInit;
 851 struct MemberInit * memberInit;
 852 struct ClassFunction * classFunction;
 853 struct ClassDefinition * _class;
 854 struct ClassDef * classDef;
 855 struct PropertyDef * prop;
 856 char * string;
 857 struct Symbol * symbol;
 858 struct PropertyWatch * propertyWatch;
 859 struct TemplateParameter * templateParameter;
 860 struct TemplateArgument * templateArgument;
 861 struct TemplateDatatype * templateDatatype;
 862 struct DBTableEntry * dbtableEntry;
 863 struct DBIndexItem * dbindexItem;
 864 struct DBTableDef * dbtableDef;
 865 } YYSTYPE;
 866
 867 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 868
 869 struct Enumerator
 870 {
 871 struct Enumerator * prev;
 872 struct Enumerator * next;
 873 struct Location loc;
 874 struct Identifier * id;
 875 struct Expression * exp;
 876 };
 877
 878 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 879
 880 struct InitDeclarator
 881 {
 882 struct InitDeclarator * prev;
 883 struct InitDeclarator * next;
 884 struct Location loc;
 885 struct Declarator * declarator;
 886 struct Initializer * initializer;
 887 };
 888
 889 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 890
 891 struct AsmField
 892 {
 893 struct AsmField * prev;
 894 struct AsmField * next;
 895 struct Location loc;
 896 char *  command;
 897 struct Expression * expression;
 898 };
 899
 900 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 901
 902 struct ClassFunction;
 903
 904 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 905
 906 struct MembersInit;
 907
 908 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 909
 910 struct MemberInit;
 911
 912 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 913
 914 struct PropertyDef;
 915
 916 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
 917
 918 struct PropertyWatch;
 919
 920 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
 921
 922 struct ClassDef
 923 {
 924 struct ClassDef * prev;
 925 struct ClassDef * next;
 926 struct Location loc;
 927 int type;
 928 union
 929 {
 930 struct Declaration * decl;
 931 struct ClassFunction * function;
 932 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
 933 struct PropertyDef * propertyDef;
 934 struct PropertyWatch * propertyWatch;
 935 char *  designer;
 936 struct Identifier * defaultProperty;
 937 struct
 938 {
 939 struct Identifier * id;
 940 struct Initializer * initializer;
 941 };
 942 };
 943 int memberAccess;
 944 void *  object;
 945 };
 946
 947 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
 948
 949 struct DBTableEntry;
 950
 951 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
 952
 953 struct DBIndexItem;
 954
 955 extern YYSTYPE yylval;
 956
 957 extern struct Location yylloc;
 958
 959 extern struct External * curExternal;
 960
 961 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
 962
 963 extern struct Declarator * SpecDeclFromString(char *  string, struct __ecereNameSpace__ecere__sys__OldList *  specs, struct Declarator * baseDecl);
 964
 965 extern struct Specifier * CopySpecifier(struct Specifier * spec);
 966
 967 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (* )(void * ));
 968
 969 extern void FreeSpecifier(struct Specifier * spec);
 970
 971 extern void FreeDeclarator(struct Declarator * decl);
 972
 973 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
 974
 975 extern struct Symbol * FindClass(char *  name);
 976
 977 extern void FreeTemplateArgument(struct TemplateArgument * arg);
 978
 979 extern void FullClassNameCat(char *  output, char *  className, unsigned int includeTemplateParams);
 980
 981 extern struct Identifier * MkIdentifier(char *  string);
 982
 983 extern int strcmp(const char * , const char * );
 984
 985 extern struct Type * ProcessTypeString(char *  string, unsigned int staticMethod);
 986
 987 static unsigned int ReplaceClassSpec(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Specifier * spec, unsigned int param)
 988 {
 989 if(spec->type == 8)
 990 {
 991 struct TemplateParameter * parameter = spec->templateParameter;
 992
 993 if(!param && parameter->dataTypeString)
 994 {
 995 struct __ecereNameSpace__ecere__sys__OldList * newSpecs = MkList();
 996 struct Declarator * decl = SpecDeclFromString(parameter->dataTypeString, newSpecs, (((void *)0)));
 997
 998 if((*newSpecs).first)
 999 {
1000 struct Specifier * newSpec = CopySpecifier((*newSpecs).first);
1001
1002 *spec = *newSpec;
1003 ((newSpec ? (__ecereClass_Specifier->Destructor ? __ecereClass_Specifier->Destructor(newSpec) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newSpec)) : 0), newSpec = 0);
1004 }
1005 FreeList(newSpecs, FreeSpecifier);
1006 if(decl)
1007 {
1008 unsigned int isPointer = decl->type == 5;
1009
1010 if(decl)
1011 FreeDeclarator(decl);
1012 if(isPointer)
1013 return 0x1;
1014 }
1015 }
1016 else if(!param && parameter->dataType)
1017 {
1018 struct __ecereNameSpace__ecere__sys__OldList * newSpecs = parameter->dataType->specifiers;
1019 struct Declarator * decl = parameter->dataType->decl;
1020
1021 if((*newSpecs).first)
1022 {
1023 struct Specifier * newSpec = CopySpecifier((*newSpecs).first);
1024
1025 *spec = *newSpec;
1026 ((newSpec ? (__ecereClass_Specifier->Destructor ? __ecereClass_Specifier->Destructor(newSpec) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newSpec)) : 0), newSpec = 0);
1027 }
1028 if(decl)
1029 {
1030 unsigned int isPointer = decl->type == 5;
1031
1032 if(isPointer)
1033 return 0x1;
1034 }
1035 }
1036 else
1037 {
1038 spec->type = 1;
1039 spec->name = __ecereNameSpace__ecere__sys__CopyString("uint64");
1040 spec->symbol = FindClass("uint64");
1041 }
1042 }
1043 if(spec->type == 1 || spec->type == 7)
1044 {
1045 struct Symbol * classSym = spec->symbol;
1046
1047 if(spec->type == 7)
1048 {
1049 classSym = FindClass("ecere::com::Class");
1050 }
1051 if(classSym)
1052 {
1053 struct __ecereNameSpace__ecere__com__Class * _class = classSym->registered;
1054
1055 spec->type = 1;
1056 if(spec->templateArgs)
1057 {
1058 FreeList(spec->templateArgs, FreeTemplateArgument);
1059 spec->templateArgs = (((void *)0));
1060 }
1061 if(_class && _class->type == 1)
1062 {
1063 char name[1024];
1064
1065 name[0] = (char)0;
1066 FullClassNameCat(name, _class->fullName, 0x0);
1067 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1068 spec->type = 3;
1069 spec->id = MkIdentifier(name);
1070 spec->list = (((void *)0));
1071 spec->definitions = (((void *)0));
1072 }
1073 else if(_class && _class->type == 5)
1074 {
1075 char name[1024] = "";
1076
1077 FullClassNameCat(name, _class->fullName, 0x0);
1078 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1079 spec->type = 3;
1080 spec->id = MkIdentifier(name);
1081 spec->list = (((void *)0));
1082 spec->definitions = (((void *)0));
1083 }
1084 else if(_class)
1085 {
1086 if((_class->type != 1000 || !strcmp(_class->fullName, "enum") || !strcmp(_class->fullName, "ecere::com::Instance") || (_class->dataTypeString && !strcmp(_class->dataTypeString, "char *")) || !strcmp(_class->fullName, "uint64") || !strcmp(_class->fullName, "uint32") || !strcmp(_class->fullName, "uint16") || !strcmp(_class->fullName, "uint") || !strcmp(_class->fullName, "byte")))
1087 {
1088 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1089 if(_class->dataTypeString)
1090 {
1091 if(!strcmp(_class->dataTypeString, "uint64") || !strcmp(_class->dataTypeString, "uint32") || !strcmp(_class->dataTypeString, "uint16") || !strcmp(_class->dataTypeString, "uint") || !strcmp(_class->dataTypeString, "byte"))
1092 {
1093 if(!_class->dataType)
1094 _class->dataType = ProcessTypeString(_class->dataTypeString, 0x0);
1095 if(_class->dataType && _class->dataType->kind == 8)
1096 classSym = _class->dataType->_class;
1097 else
1098 classSym = FindClass(_class->dataTypeString);
1099 _class = classSym ? classSym->registered : (((void *)0));
1100 }
1101 if(!strcmp(_class->dataTypeString, "char *"))
1102 spec->name = __ecereNameSpace__ecere__sys__CopyString("char");
1103 else
1104 spec->name = __ecereNameSpace__ecere__sys__CopyString(_class->dataTypeString);
1105 spec->symbol = (((void *)0));
1106 }
1107 else
1108 {
1109 spec->name = __ecereNameSpace__ecere__sys__CopyString((((void *)0)));
1110 spec->symbol = (((void *)0));
1111 }
1112 }
1113 else if(!_class->base)
1114 {
1115 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1116 spec->type = 0;
1117 spec->specifier = VOID;
1118 return 0x1;
1119 }
1120 }
1121 else
1122 {
1123 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1124 spec->type = 3;
1125 spec->id = MkIdentifier("__ecereNameSpace__ecere__com__Instance");
1126 spec->list = (((void *)0));
1127 spec->definitions = (((void *)0));
1128 }
1129 if(_class && _class->dataTypeString && !strcmp(_class->dataTypeString, "char *"))
1130 return 0x1;
1131 if(!_class || _class->type == 0 || _class->type == 5 || !strcmp(_class->fullName, "ecere::com::Instance"))
1132 return 0x1;
1133 else if(param && _class->type == 1)
1134 return (unsigned int)2;
1135 }
1136 }
1137 else if(spec->type == 0)
1138 {
1139 if(spec->specifier == ANY_OBJECT)
1140 {
1141 spec->specifier = VOID;
1142 return 0x1;
1143 }
1144 }
1145 return 0x0;
1146 }
1147
1148 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1149
1150 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1151
1152 static void ReplaceByInstancePtr(struct Specifier * spec, struct Declarator ** declPtr, int type)
1153 {
1154 struct Declarator * decl = *declPtr;
1155
1156 if(decl && decl->type == 5)
1157 {
1158 if(type == 2)
1159 ;
1160 else
1161 decl->pointer.pointer = MkPointer((((void *)0)), decl->pointer.pointer);
1162 }
1163 else
1164 {
1165 struct Declarator * newDecl = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Declarator);
1166
1167 if(decl)
1168 {
1169 *newDecl = *decl;
1170 decl->declarator = newDecl;
1171 }
1172 else
1173 decl = newDecl;
1174 decl->type = 5;
1175 decl->pointer.pointer = MkPointer((((void *)0)), (((void *)0)));
1176 *declPtr = decl;
1177 }
1178 }
1179
1180 static void InstDeclPassDeclaration(struct Declaration * decl);
1181
1182 static void InstDeclPassIdentifier(struct Identifier * id);
1183
1184 extern int targetPlatform;
1185
1186 static void InstDeclPassSpecifier(struct Specifier * spec)
1187 {
1188 switch(spec->type)
1189 {
1190 case 0:
1191 if(spec->specifier == TYPED_OBJECT)
1192 {
1193 spec->type = 5;
1194 spec->name = __ecereNameSpace__ecere__sys__CopyString("struct __ecereNameSpace__ecere__com__Class * class, void *");
1195 }
1196 break;
1197 case 1:
1198 break;
1199 case 2:
1200 {
1201 struct Enumerator * e;
1202
1203 if(spec->list)
1204 {
1205 for(e = (*spec->list).first; e; e = e->next)
1206 {
1207 }
1208 }
1209 break;
1210 }
1211 case 3:
1212 case 4:
1213 {
1214 if(spec->definitions)
1215 {
1216 struct ClassDef * def;
1217
1218 for(def = (*spec->definitions).first; def; def = def->next)
1219 if(def->decl)
1220 InstDeclPassDeclaration(def->decl);
1221 }
1222 if(spec->id)
1223 InstDeclPassIdentifier(spec->id);
1224 break;
1225 }
1226 case 5:
1227 if(!strcmp(spec->name, "dllexport"))
1228 {
1229 struct Specifier * prevSpec;
1230
1231 (__ecereNameSpace__ecere__com__eSystem_Delete(spec->name), spec->name = 0);
1232 for(prevSpec = spec->prev; prevSpec; prevSpec = prevSpec->prev)
1233 if(prevSpec->type == 0 && prevSpec->specifier == EXTERN)
1234 break;
1235 if(prevSpec)
1236 {
1237 if(targetPlatform == 1)
1238 spec->name = __ecereNameSpace__ecere__sys__CopyString("__declspec(dllexport)");
1239 else
1240 spec->name = __ecereNameSpace__ecere__sys__CopyString("__attribute__ ((visibility(\"default\")))");
1241 }
1242 else
1243 {
1244 if(targetPlatform == 1)
1245 spec->name = __ecereNameSpace__ecere__sys__CopyString("extern __declspec(dllexport)");
1246 else
1247 spec->name = __ecereNameSpace__ecere__sys__CopyString("extern __attribute__ ((visibility(\"default\")))");
1248 }
1249 }
1250 break;
1251 }
1252 }
1253
1254 void InstDeclPassTypeName(struct TypeName * type, unsigned int param);
1255
1256 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1257
1258 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1259
1260 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1261
1262 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1263
1264 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1265
1266 static void InstDeclPassDeclarator(struct Declarator * decl)
1267 {
1268 switch(decl->type)
1269 {
1270 case 0:
1271 if(decl->declarator)
1272 InstDeclPassDeclarator(decl->declarator);
1273 break;
1274 case 1:
1275 {
1276 if(decl->identifier)
1277 InstDeclPassIdentifier(decl->identifier);
1278 break;
1279 }
1280 case 2:
1281 if(decl->declarator)
1282 InstDeclPassDeclarator(decl->declarator);
1283 break;
1284 case 3:
1285 if(decl->declarator)
1286 InstDeclPassDeclarator(decl->declarator);
1287 break;
1288 case 4:
1289 {
1290 if(decl->declarator)
1291 InstDeclPassDeclarator(decl->declarator);
1292 if(decl->function.parameters)
1293 {
1294 struct TypeName * type;
1295
1296 if(decl->declarator)
1297 InstDeclPassDeclarator(decl->declarator);
1298 for(type = (*decl->function.parameters).first; type; type = type->next)
1299 {
1300 unsigned int typedObject = 0x0;
1301 struct Specifier * spec = (((void *)0));
1302
1303 if(type->qualifiers)
1304 {
1305 spec = (struct Specifier *)(*type->qualifiers).first;
1306 if(spec && spec->type == 1 && !strcmp(spec->name, "class"))
1307 typedObject = 0x1;
1308 }
1309 InstDeclPassTypeName(type, 0x1);
1310 if(typedObject)
1311 {
1312 struct TypeName * _class = (_class = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TypeName), _class->qualifiers = MkListOne(MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0)))), _class->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier("class"))), _class);
1313
1314 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->function.parameters), spec->prev, _class);
1315 }
1316 }
1317 }
1318 break;
1319 }
1320 case 5:
1321 case 6:
1322 case 7:
1323 if((decl->type == 6 || decl->type == 7) && decl->extended.extended)
1324 {
1325 if(!strcmp(decl->extended.extended, "dllexport"))
1326 {
1327 (__ecereNameSpace__ecere__com__eSystem_Delete(decl->extended.extended), decl->extended.extended = 0);
1328 if(targetPlatform == 1)
1329 decl->extended.extended = __ecereNameSpace__ecere__sys__CopyString("extern __declspec(dllexport)");
1330 else
1331 decl->extended.extended = __ecereNameSpace__ecere__sys__CopyString("extern __attribute__ ((visibility(\"default\")))");
1332 }
1333 else if(!strcmp(decl->extended.extended, "stdcall") || !strcmp(decl->extended.extended, "_stdcall") || !strcmp(decl->extended.extended, "__stdcall") || !strcmp(decl->extended.extended, "__stdcall__"))
1334 {
1335 (__ecereNameSpace__ecere__com__eSystem_Delete(decl->extended.extended), decl->extended.extended = 0);
1336 if(targetPlatform == 1)
1337 decl->extended.extended = __ecereNameSpace__ecere__sys__CopyString("__attribute__((__stdcall__))");
1338 else
1339 decl->extended.extended = __ecereNameSpace__ecere__sys__CopyString("");
1340 }
1341 }
1342 if(decl->declarator)
1343 InstDeclPassDeclarator(decl->declarator);
1344 break;
1345 }
1346 }
1347
1348 void InstDeclPassTypeName(struct TypeName * type, unsigned int param)
1349 {
1350 if(type->qualifiers)
1351 {
1352 struct Specifier * spec;
1353
1354 for(spec = (*type->qualifiers).first; spec; spec = spec->next)
1355 {
1356 int result;
1357
1358 if((result = (unsigned int)ReplaceClassSpec(type->qualifiers, spec, param)))
1359 ReplaceByInstancePtr(spec, &type->declarator, result);
1360 else
1361 {
1362 struct Symbol * classSym = (spec->type == 1) ? spec->symbol : (((void *)0));
1363
1364 if(type->classObjectType && (!classSym || (classSym && classSym->registered && (classSym->registered->type == 4 || classSym->registered->type == 2 || classSym->registered->type == 3 || (classSym->registered->type == 1000 && strcmp(classSym->string, "ecere::com::Instance") && strcmp(classSym->string, "ecere::com::Class"))))))
1365 ReplaceByInstancePtr(spec, &type->declarator, 2);
1366 }
1367 InstDeclPassSpecifier(spec);
1368 }
1369 }
1370 if(type->declarator)
1371 InstDeclPassDeclarator(type->declarator);
1372 }
1373
1374 extern char *  strchr(char * , int);
1375
1376 extern char *  strcpy(char * , const char * );
1377
1378 extern int strlen(const char * );
1379
1380 static void InstDeclPassIdentifier(struct Identifier * id)
1381 {
1382 if(strchr(id->string, ':'))
1383 {
1384 char newID[1024];
1385 int c;
1386 char ch;
1387 int len;
1388
1389 strcpy(newID, "__ecereNameSpace__");
1390 len = strlen(newID);
1391 for(c = 0; (ch = id->string[c]); c++)
1392 {
1393 if(ch == ':')
1394 ch = '_';
1395 newID[len++] = ch;
1396 }
1397 newID[len] = (char)0;
1398 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
1399 id->string = __ecereNameSpace__ecere__sys__CopyString(newID);
1400 }
1401 }
1402
1403 extern void FreeExpContents(struct Expression * exp);
1404
1405 extern void FreeType(struct Type * type);
1406
1407 static void InstDeclPassStatement(struct Statement * stmt);
1408
1409 static void InstDeclPassExpression(struct Expression * exp)
1410 {
1411 switch(exp->type)
1412 {
1413 case 0:
1414 {
1415 if(exp->identifier)
1416 InstDeclPassIdentifier(exp->identifier);
1417 break;
1418 }
1419 case 2:
1420 break;
1421 case 3:
1422 break;
1423 case 4:
1424 if(exp->op.exp1)
1425 InstDeclPassExpression(exp->op.exp1);
1426 if(exp->op.exp2)
1427 InstDeclPassExpression(exp->op.exp2);
1428 break;
1429 case 34:
1430 case 5:
1431 {
1432 struct Expression * e;
1433
1434 for(e = (*exp->list).first; e; e = e->next)
1435 InstDeclPassExpression(e);
1436 break;
1437 }
1438 case 6:
1439 {
1440 struct Expression * e;
1441
1442 InstDeclPassExpression(exp->index.exp);
1443 for(e = (*exp->index.index).first; e; e = e->next)
1444 InstDeclPassExpression(e);
1445 break;
1446 }
1447 case 7:
1448 {
1449 struct Expression * e;
1450
1451 InstDeclPassExpression(exp->call.exp);
1452 if(exp->call.arguments)
1453 {
1454 for(e = (*exp->call.arguments).first; e; e = e->next)
1455 InstDeclPassExpression(e);
1456 }
1457 break;
1458 }
1459 case 8:
1460 {
1461 InstDeclPassExpression(exp->member.exp);
1462 break;
1463 }
1464 case 9:
1465 {
1466 InstDeclPassExpression(exp->member.exp);
1467 break;
1468 }
1469 case 10:
1470 InstDeclPassTypeName(exp->typeName, 0x0);
1471 break;
1472 case 11:
1473 {
1474 struct Type * type = exp->expType;
1475
1476 if(type && type->kind == 8 && type->_class->registered && type->_class->registered->type == 1)
1477 {
1478 struct Expression * castExp = exp->cast.exp;
1479 struct Expression * prev = exp->prev, * next = exp->next;
1480
1481 exp->cast.exp = (((void *)0));
1482 FreeExpContents(exp);
1483 FreeType(exp->expType);
1484 FreeType(exp->destType);
1485 *exp = *castExp;
1486 ((castExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(castExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(castExp)) : 0), castExp = 0);
1487 exp->prev = prev;
1488 exp->next = next;
1489 InstDeclPassExpression(exp);
1490 }
1491 else
1492 {
1493 InstDeclPassTypeName(exp->cast.typeName, 0x0);
1494 if(exp->cast.exp)
1495 InstDeclPassExpression(exp->cast.exp);
1496 }
1497 break;
1498 }
1499 case 12:
1500 {
1501 struct Expression * e;
1502
1503 InstDeclPassExpression(exp->cond.cond);
1504 for(e = (*exp->cond.exp).first; e; e = e->next)
1505 InstDeclPassExpression(e);
1506 InstDeclPassExpression(exp->cond.elseExp);
1507 break;
1508 }
1509 case 25:
1510 {
1511 InstDeclPassStatement(exp->compound);
1512 break;
1513 }
1514 case 36:
1515 {
1516 InstDeclPassExpression(exp->vaArg.exp);
1517 break;
1518 }
1519 }
1520 }
1521
1522 static void InstDeclPassInitializer(struct Initializer * init)
1523 {
1524 switch(init->type)
1525 {
1526 case 0:
1527 InstDeclPassExpression(init->exp);
1528 break;
1529 case 1:
1530 {
1531 struct Initializer * i;
1532
1533 for(i = (*init->list).first; i; i = i->next)
1534 InstDeclPassInitializer(i);
1535 break;
1536 }
1537 }
1538 }
1539
1540 static void InstDeclPassDeclaration(struct Declaration * decl)
1541 {
1542 switch(decl->type)
1543 {
1544 case 1:
1545 {
1546 if(decl->specifiers)
1547 {
1548 struct Specifier * spec;
1549
1550 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1551 {
1552 int type;
1553
1554 if((type = (unsigned int)ReplaceClassSpec(decl->specifiers, spec, 0x0)))
1555 {
1556 struct InitDeclarator * d;
1557
1558 if(decl->declarators)
1559 {
1560 for(d = (*decl->declarators).first; d; d = d->next)
1561 ReplaceByInstancePtr(spec, &d->declarator, type);
1562 }
1563 }
1564 InstDeclPassSpecifier(spec);
1565 }
1566 }
1567 if(decl->declarators)
1568 {
1569 struct InitDeclarator * d;
1570
1571 for(d = (*decl->declarators).first; d; d = d->next)
1572 {
1573 InstDeclPassDeclarator(d->declarator);
1574 if(d->initializer)
1575 InstDeclPassInitializer(d->initializer);
1576 }
1577 }
1578 break;
1579 }
1580 case 0:
1581 {
1582 if(decl->specifiers)
1583 {
1584 struct Specifier * spec;
1585
1586 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1587 {
1588 int type;
1589
1590 if((type = (unsigned int)ReplaceClassSpec(decl->specifiers, spec, 0x0)))
1591 {
1592 if(decl->declarators)
1593 {
1594 struct Declarator * d;
1595
1596 for(d = (*decl->declarators).first; d; d = d->next)
1597 ReplaceByInstancePtr(spec, &d, type);
1598 }
1599 }
1600 InstDeclPassSpecifier(spec);
1601 }
1602 }
1603 if(decl->declarators)
1604 {
1605 struct Declarator * d;
1606
1607 for(d = (*decl->declarators).first; d; d = d->next)
1608 InstDeclPassDeclarator(d);
1609 }
1610 break;
1611 }
1612 case 2:
1613 break;
1614 }
1615 }
1616
1617 extern struct Context * curContext;
1618
1619 static void InstDeclPassStatement(struct Statement * stmt)
1620 {
1621 switch(stmt->type)
1622 {
1623 case 0:
1624 InstDeclPassStatement(stmt->labeled.stmt);
1625 break;
1626 case 1:
1627 if(stmt->caseStmt.exp)
1628 InstDeclPassExpression(stmt->caseStmt.exp);
1629 if(stmt->caseStmt.stmt)
1630 InstDeclPassStatement(stmt->caseStmt.stmt);
1631 break;
1632 case 2:
1633 {
1634 struct Declaration * decl;
1635 struct Statement * s;
1636 struct Context * prevContext = curContext;
1637
1638 if(!stmt->compound.isSwitch)
1639 curContext = stmt->compound.context;
1640 if(stmt->compound.declarations)
1641 {
1642 for(decl = (*stmt->compound.declarations).first; decl; decl = decl->next)
1643 InstDeclPassDeclaration(decl);
1644 }
1645 if(stmt->compound.statements)
1646 {
1647 for(s = (*stmt->compound.statements).first; s; s = s->next)
1648 InstDeclPassStatement(s);
1649 }
1650 curContext = prevContext;
1651 break;
1652 }
1653 case 3:
1654 {
1655 if(stmt->expressions)
1656 {
1657 struct Expression * exp;
1658
1659 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
1660 InstDeclPassExpression(exp);
1661 }
1662 break;
1663 }
1664 case 4:
1665 {
1666 if(stmt->ifStmt.exp)
1667 {
1668 struct Expression * exp;
1669
1670 for(exp = (*stmt->ifStmt.exp).first; exp; exp = exp->next)
1671 InstDeclPassExpression(exp);
1672 }
1673 if(stmt->ifStmt.stmt)
1674 InstDeclPassStatement(stmt->ifStmt.stmt);
1675 if(stmt->ifStmt.elseStmt)
1676 InstDeclPassStatement(stmt->ifStmt.elseStmt);
1677 break;
1678 }
1679 case 5:
1680 {
1681 struct Expression * exp;
1682
1683 for(exp = (*stmt->switchStmt.exp).first; exp; exp = exp->next)
1684 InstDeclPassExpression(exp);
1685 InstDeclPassStatement(stmt->switchStmt.stmt);
1686 break;
1687 }
1688 case 6:
1689 {
1690 struct Expression * exp;
1691
1692 for(exp = (*stmt->whileStmt.exp).first; exp; exp = exp->next)
1693 InstDeclPassExpression(exp);
1694 InstDeclPassStatement(stmt->whileStmt.stmt);
1695 break;
1696 }
1697 case 7:
1698 {
1699 if(stmt->doWhile.exp)
1700 {
1701 struct Expression * exp;
1702
1703 for(exp = (*stmt->doWhile.exp).first; exp; exp = exp->next)
1704 InstDeclPassExpression(exp);
1705 }
1706 if(stmt->doWhile.stmt)
1707 InstDeclPassStatement(stmt->doWhile.stmt);
1708 break;
1709 }
1710 case 8:
1711 {
1712 struct Expression * exp;
1713
1714 if(stmt->forStmt.init)
1715 InstDeclPassStatement(stmt->forStmt.init);
1716 if(stmt->forStmt.check)
1717 InstDeclPassStatement(stmt->forStmt.check);
1718 if(stmt->forStmt.increment)
1719 {
1720 for(exp = (*stmt->forStmt.increment).first; exp; exp = exp->next)
1721 InstDeclPassExpression(exp);
1722 }
1723 if(stmt->forStmt.stmt)
1724 InstDeclPassStatement(stmt->forStmt.stmt);
1725 break;
1726 }
1727 case 9:
1728 break;
1729 case 10:
1730 break;
1731 case 11:
1732 break;
1733 case 12:
1734 {
1735 struct Expression * exp;
1736
1737 if(stmt->expressions)
1738 {
1739 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
1740 InstDeclPassExpression(exp);
1741 }
1742 break;
1743 }
1744 case 13:
1745 {
1746 struct AsmField * field;
1747
1748 if(stmt->asmStmt.inputFields)
1749 {
1750 for(field = (*stmt->asmStmt.inputFields).first; field; field = field->next)
1751 if(field->expression)
1752 InstDeclPassExpression(field->expression);
1753 }
1754 if(stmt->asmStmt.outputFields)
1755 {
1756 for(field = (*stmt->asmStmt.outputFields).first; field; field = field->next)
1757 if(field->expression)
1758 InstDeclPassExpression(field->expression);
1759 }
1760 if(stmt->asmStmt.clobberedFields)
1761 {
1762 for(field = (*stmt->asmStmt.clobberedFields).first; field; field = field->next)
1763 if(field->expression)
1764 InstDeclPassExpression(field->expression);
1765 }
1766 break;
1767 }
1768 }
1769 }
1770
1771 extern struct Context * globalContext;
1772
1773 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
1774
1775 void ProcessInstanceDeclarations()
1776 {
1777 struct External * external;
1778
1779 curContext = globalContext;
1780 for(external = (*ast).first; external; external = external->next)
1781 {
1782 curExternal = external;
1783 if(external->type == 0)
1784 {
1785 struct FunctionDefinition * func = external->function;
1786
1787 if(func->specifiers)
1788 {
1789 struct Specifier * spec;
1790
1791 for(spec = (*func->specifiers).first; spec; spec = spec->next)
1792 {
1793 int type;
1794
1795 if((type = (unsigned int)ReplaceClassSpec(func->specifiers, spec, 0x0)))
1796 ReplaceByInstancePtr(spec, &func->declarator, type);
1797 InstDeclPassSpecifier(spec);
1798 }
1799 }
1800 InstDeclPassDeclarator(func->declarator);
1801 if(func->body)
1802 InstDeclPassStatement(func->body);
1803 }
1804 else if(external->type == 1)
1805 {
1806 if(external->declaration)
1807 InstDeclPassDeclaration(external->declaration);
1808 }
1809 }
1810 }
1811
1812 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
1813
1814 struct __ecereNameSpace__ecere__com__GlobalFunction;
1815
1816 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);
1817
1818 void __ecereRegisterModule_pass3(struct __ecereNameSpace__ecere__com__Instance * module)
1819 {
1820 struct __ecereNameSpace__ecere__com__Class * class;
1821
1822 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("InstDeclPassTypeName", "void InstDeclPassTypeName(TypeName type, bool param)", InstDeclPassTypeName, module, 2);
1823 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessInstanceDeclarations", "void ProcessInstanceDeclarations(void)", ProcessInstanceDeclarations, module, 1);
1824 }
1825
1826 void __ecereUnregisterModule_pass3(struct __ecereNameSpace__ecere__com__Instance * module)
1827 {
1828
1829 }
1830