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