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

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