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

   1 /* Code generated from eC source file: copy.ec */
   2 #if defined(__GNUC__)
   3 typedef long long int64;
   4 typedef unsigned long long uint64;
   5 #ifndef _WIN32
   6 #define __declspec(x)
   7 #endif
   8 #elif defined(__TINYC__)
   9 #include <stdarg.h>
  10 #define __builtin_va_list va_list
  11 #define __builtin_va_start va_start
  12 #define __builtin_va_end va_end
  13 #ifdef _WIN32
  14 #define strcasecmp stricmp
  15 #define strncasecmp strnicmp
  16 #define __declspec(x) __attribute__((x))
  17 #else
  18 #define __declspec(x)
  19 #endif
  20 typedef long long int64;
  21 typedef unsigned long long uint64;
  22 #else
  23 typedef __int64 int64;
  24 typedef unsigned __int64 uint64;
  25 #endif
  26 #ifdef __BIG_ENDIAN__
  27 #define __ENDIAN_PAD(x) (8 - (x))
  28 #else
  29 #define __ENDIAN_PAD(x) 0
  30 #endif
  31 #include <stdint.h>
  32 #include <sys/types.h>
  33 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  34
  35 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  36
  37 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  38
  39 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  40
  41 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
  42
  43 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  44
  45 struct __ecereNameSpace__ecere__sys__BTNode;
  46
  47 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  48
  49 struct __ecereNameSpace__ecere__sys__BinaryTree
  50 {
  51 struct __ecereNameSpace__ecere__sys__BTNode * root;
  52 int count;
  53 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  54 void (*  FreeKey)(void *  key);
  55 } __attribute__ ((gcc_struct));
  56
  57 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  58
  59 struct __ecereNameSpace__ecere__sys__OldList
  60 {
  61 void *  first;
  62 void *  last;
  63 int count;
  64 unsigned int offset;
  65 unsigned int circ;
  66 } __attribute__ ((gcc_struct));
  67
  68 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  69
  70 struct __ecereNameSpace__ecere__com__Method
  71 {
  72 char *  name;
  73 struct __ecereNameSpace__ecere__com__Method * parent;
  74 struct __ecereNameSpace__ecere__com__Method * left;
  75 struct __ecereNameSpace__ecere__com__Method * right;
  76 int depth;
  77 int (*  function)();
  78 int vid;
  79 int type;
  80 struct __ecereNameSpace__ecere__com__Class * _class;
  81 void *  symbol;
  82 char *  dataTypeString;
  83 struct Type * dataType;
  84 int memberAccess;
  85 } __attribute__ ((gcc_struct));
  86
  87 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
  88
  89 struct __ecereNameSpace__ecere__com__Property
  90 {
  91 struct __ecereNameSpace__ecere__com__Property * prev;
  92 struct __ecereNameSpace__ecere__com__Property * next;
  93 char *  name;
  94 unsigned int isProperty;
  95 int memberAccess;
  96 int id;
  97 struct __ecereNameSpace__ecere__com__Class * _class;
  98 char *  dataTypeString;
  99 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 100 struct Type * dataType;
 101 void (*  Set)(void * , int);
 102 int (*  Get)(void * );
 103 unsigned int (*  IsSet)(void * );
 104 void *  data;
 105 void *  symbol;
 106 int vid;
 107 unsigned int conversion;
 108 unsigned int watcherOffset;
 109 char *  category;
 110 unsigned int compiled;
 111 unsigned int selfWatchable;
 112 unsigned int isWatchable;
 113 } __attribute__ ((gcc_struct));
 114
 115 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
 116
 117 struct CodePosition
 118 {
 119 int line;
 120 int charPos;
 121 int pos;
 122 int included;
 123 } __attribute__ ((gcc_struct));
 124
 125 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 126
 127 struct Location
 128 {
 129 struct CodePosition start;
 130 struct CodePosition end;
 131 } __attribute__ ((gcc_struct));
 132
 133 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attrib;
 134
 135 struct Attrib
 136 {
 137 struct Location loc;
 138 int type;
 139 struct __ecereNameSpace__ecere__sys__OldList *  attribs;
 140 } __attribute__ ((gcc_struct));
 141
 142 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ExtDecl;
 143
 144 struct ExtDecl
 145 {
 146 struct Location loc;
 147 int type;
 148 union
 149 {
 150 char * s;
 151 struct Attrib * attr;
 152 } __attribute__ ((gcc_struct));
 153 } __attribute__ ((gcc_struct));
 154
 155 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 156
 157 struct ClassDefinition;
 158
 159 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 160
 161 struct Context;
 162
 163 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 164
 165 struct Instantiation
 166 {
 167 struct Instantiation * prev;
 168 struct Instantiation * next;
 169 struct Location loc;
 170 struct Specifier * _class;
 171 struct Expression * exp;
 172 struct __ecereNameSpace__ecere__sys__OldList *  members;
 173 struct Symbol * symbol;
 174 unsigned int fullSet;
 175 unsigned int isConstant;
 176 unsigned char *  data;
 177 struct Location nameLoc;
 178 struct Location insideLoc;
 179 unsigned int built;
 180 } __attribute__ ((gcc_struct));
 181
 182 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 183
 184 struct Declaration
 185 {
 186 struct Declaration * prev;
 187 struct Declaration * next;
 188 struct Location loc;
 189 int type;
 190 union
 191 {
 192 struct
 193 {
 194 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 195 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 196 } __attribute__ ((gcc_struct));
 197 struct Instantiation * inst;
 198 struct
 199 {
 200 struct Identifier * id;
 201 struct Expression * exp;
 202 } __attribute__ ((gcc_struct));
 203 } __attribute__ ((gcc_struct));
 204 struct Specifier * extStorage;
 205 struct Symbol * symbol;
 206 int declMode;
 207 } __attribute__ ((gcc_struct));
 208
 209 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 210
 211 struct Statement
 212 {
 213 struct Statement * prev;
 214 struct Statement * next;
 215 struct Location loc;
 216 int type;
 217 union
 218 {
 219 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 220 struct
 221 {
 222 struct Identifier * id;
 223 struct Statement * stmt;
 224 } __attribute__ ((gcc_struct)) labeled;
 225 struct
 226 {
 227 struct Expression * exp;
 228 struct Statement * stmt;
 229 } __attribute__ ((gcc_struct)) caseStmt;
 230 struct
 231 {
 232 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 233 struct __ecereNameSpace__ecere__sys__OldList * statements;
 234 struct Context * context;
 235 unsigned int isSwitch;
 236 } __attribute__ ((gcc_struct)) compound;
 237 struct
 238 {
 239 struct __ecereNameSpace__ecere__sys__OldList * exp;
 240 struct Statement * stmt;
 241 struct Statement * elseStmt;
 242 } __attribute__ ((gcc_struct)) ifStmt;
 243 struct
 244 {
 245 struct __ecereNameSpace__ecere__sys__OldList * exp;
 246 struct Statement * stmt;
 247 } __attribute__ ((gcc_struct)) switchStmt;
 248 struct
 249 {
 250 struct __ecereNameSpace__ecere__sys__OldList * exp;
 251 struct Statement * stmt;
 252 } __attribute__ ((gcc_struct)) whileStmt;
 253 struct
 254 {
 255 struct __ecereNameSpace__ecere__sys__OldList * exp;
 256 struct Statement * stmt;
 257 } __attribute__ ((gcc_struct)) doWhile;
 258 struct
 259 {
 260 struct Statement * init;
 261 struct Statement * check;
 262 struct __ecereNameSpace__ecere__sys__OldList * increment;
 263 struct Statement * stmt;
 264 } __attribute__ ((gcc_struct)) forStmt;
 265 struct
 266 {
 267 struct Identifier * id;
 268 } __attribute__ ((gcc_struct)) gotoStmt;
 269 struct
 270 {
 271 struct Specifier * spec;
 272 char * statements;
 273 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 274 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 275 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 276 } __attribute__ ((gcc_struct)) asmStmt;
 277 struct
 278 {
 279 struct Expression * watcher;
 280 struct Expression * object;
 281 struct __ecereNameSpace__ecere__sys__OldList * watches;
 282 } __attribute__ ((gcc_struct)) _watch;
 283 struct
 284 {
 285 struct Identifier * id;
 286 struct __ecereNameSpace__ecere__sys__OldList * exp;
 287 struct __ecereNameSpace__ecere__sys__OldList * filter;
 288 struct Statement * stmt;
 289 } __attribute__ ((gcc_struct)) forEachStmt;
 290 struct Declaration * decl;
 291 } __attribute__ ((gcc_struct));
 292 } __attribute__ ((gcc_struct));
 293
 294 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 295
 296 struct TypeName
 297 {
 298 struct TypeName * prev;
 299 struct TypeName * next;
 300 struct Location loc;
 301 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 302 struct Declarator * declarator;
 303 int classObjectType;
 304 struct Expression * bitCount;
 305 } __attribute__ ((gcc_struct));
 306
 307 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 308
 309 struct Initializer
 310 {
 311 struct Initializer * prev;
 312 struct Initializer * next;
 313 struct Location loc;
 314 int type;
 315 union
 316 {
 317 struct Expression * exp;
 318 struct __ecereNameSpace__ecere__sys__OldList *  list;
 319 } __attribute__ ((gcc_struct));
 320 unsigned int isConstant;
 321 } __attribute__ ((gcc_struct));
 322
 323 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 324
 325 struct __ecereNameSpace__ecere__com__DataValue
 326 {
 327 union
 328 {
 329 char c;
 330 unsigned char uc;
 331 short s;
 332 unsigned short us;
 333 int i;
 334 unsigned int ui;
 335 void *  p;
 336 float f;
 337 double d;
 338 long long i64;
 339 uint64 ui64;
 340 } __attribute__ ((gcc_struct));
 341 } __attribute__ ((gcc_struct));
 342
 343 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 344
 345 struct Expression
 346 {
 347 struct Expression * prev;
 348 struct Expression * next;
 349 struct Location loc;
 350 int type;
 351 union
 352 {
 353 struct
 354 {
 355 char *  constant;
 356 struct Identifier * identifier;
 357 } __attribute__ ((gcc_struct));
 358 struct Statement * compound;
 359 struct Instantiation * instance;
 360 struct
 361 {
 362 char *  string;
 363 unsigned int intlString;
 364 } __attribute__ ((gcc_struct));
 365 struct __ecereNameSpace__ecere__sys__OldList *  list;
 366 struct
 367 {
 368 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 369 struct Declarator * decl;
 370 } __attribute__ ((gcc_struct)) _classExp;
 371 struct
 372 {
 373 struct Identifier * id;
 374 } __attribute__ ((gcc_struct)) classData;
 375 struct
 376 {
 377 struct Expression * exp;
 378 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 379 struct Location argLoc;
 380 } __attribute__ ((gcc_struct)) call;
 381 struct
 382 {
 383 struct Expression * exp;
 384 struct __ecereNameSpace__ecere__sys__OldList * index;
 385 } __attribute__ ((gcc_struct)) index;
 386 struct
 387 {
 388 struct Expression * exp;
 389 struct Identifier * member;
 390 int memberType;
 391 unsigned int thisPtr;
 392 } __attribute__ ((gcc_struct)) member;
 393 struct
 394 {
 395 int op;
 396 struct Expression * exp1;
 397 struct Expression * exp2;
 398 } __attribute__ ((gcc_struct)) op;
 399 struct TypeName * typeName;
 400 struct Specifier * _class;
 401 struct
 402 {
 403 struct TypeName * typeName;
 404 struct Expression * exp;
 405 } __attribute__ ((gcc_struct)) cast;
 406 struct
 407 {
 408 struct Expression * cond;
 409 struct __ecereNameSpace__ecere__sys__OldList * exp;
 410 struct Expression * elseExp;
 411 } __attribute__ ((gcc_struct)) cond;
 412 struct
 413 {
 414 struct TypeName * typeName;
 415 struct Expression * size;
 416 } __attribute__ ((gcc_struct)) _new;
 417 struct
 418 {
 419 struct TypeName * typeName;
 420 struct Expression * size;
 421 struct Expression * exp;
 422 } __attribute__ ((gcc_struct)) _renew;
 423 struct
 424 {
 425 char * table;
 426 struct Identifier * id;
 427 } __attribute__ ((gcc_struct)) db;
 428 struct
 429 {
 430 struct Expression * ds;
 431 struct Expression * name;
 432 } __attribute__ ((gcc_struct)) dbopen;
 433 struct
 434 {
 435 struct TypeName * typeName;
 436 struct Initializer * initializer;
 437 } __attribute__ ((gcc_struct)) initializer;
 438 struct
 439 {
 440 struct Expression * exp;
 441 struct TypeName * typeName;
 442 } __attribute__ ((gcc_struct)) vaArg;
 443 } __attribute__ ((gcc_struct));
 444 unsigned int debugValue;
 445 struct __ecereNameSpace__ecere__com__DataValue val;
 446 uint64 address;
 447 unsigned int hasAddress;
 448 struct Type * expType;
 449 struct Type * destType;
 450 unsigned int usage;
 451 int tempCount;
 452 unsigned int byReference;
 453 unsigned int isConstant;
 454 unsigned int addedThis;
 455 unsigned int needCast;
 456 unsigned int thisPtr;
 457 } __attribute__ ((gcc_struct));
 458
 459 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 460
 461 struct TemplateDatatype;
 462
 463 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 464
 465 struct TemplateArgument;
 466
 467 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 468
 469 struct TemplateParameter;
 470
 471 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 472
 473 struct Specifier
 474 {
 475 struct Specifier * prev;
 476 struct Specifier * next;
 477 struct Location loc;
 478 int type;
 479 union
 480 {
 481 int specifier;
 482 struct
 483 {
 484 struct ExtDecl * extDecl;
 485 char *  name;
 486 struct Symbol * symbol;
 487 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 488 } __attribute__ ((gcc_struct));
 489 struct
 490 {
 491 struct Identifier * id;
 492 struct __ecereNameSpace__ecere__sys__OldList *  list;
 493 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 494 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 495 unsigned int addNameSpace;
 496 struct Context * ctx;
 497 struct ExtDecl * extDeclStruct;
 498 } __attribute__ ((gcc_struct));
 499 struct Expression * expression;
 500 struct Specifier * _class;
 501 struct TemplateParameter * templateParameter;
 502 } __attribute__ ((gcc_struct));
 503 } __attribute__ ((gcc_struct));
 504
 505 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 506
 507 struct Identifier
 508 {
 509 struct Identifier * prev;
 510 struct Identifier * next;
 511 struct Location loc;
 512 struct Symbol * classSym;
 513 struct Specifier * _class;
 514 char *  string;
 515 struct Identifier * badID;
 516 } __attribute__ ((gcc_struct));
 517
 518 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 519
 520 struct Pointer
 521 {
 522 struct Pointer * prev;
 523 struct Pointer * next;
 524 struct Location loc;
 525 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 526 struct Pointer * pointer;
 527 } __attribute__ ((gcc_struct));
 528
 529 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 530
 531 struct Declarator
 532 {
 533 struct Declarator * prev;
 534 struct Declarator * next;
 535 struct Location loc;
 536 int type;
 537 struct Symbol * symbol;
 538 struct Declarator * declarator;
 539 union
 540 {
 541 struct Identifier * identifier;
 542 struct
 543 {
 544 struct Expression * exp;
 545 struct Expression * posExp;
 546 struct Attrib * attrib;
 547 } __attribute__ ((gcc_struct)) structDecl;
 548 struct
 549 {
 550 struct Expression * exp;
 551 struct Specifier * enumClass;
 552 } __attribute__ ((gcc_struct)) array;
 553 struct
 554 {
 555 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 556 } __attribute__ ((gcc_struct)) function;
 557 struct
 558 {
 559 struct Pointer * pointer;
 560 } __attribute__ ((gcc_struct)) pointer;
 561 struct
 562 {
 563 struct ExtDecl * extended;
 564 } __attribute__ ((gcc_struct)) extended;
 565 } __attribute__ ((gcc_struct));
 566 } __attribute__ ((gcc_struct));
 567
 568 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 569
 570 struct FunctionDefinition;
 571
 572 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 573
 574 struct DBTableDef;
 575
 576 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 577
 578 struct External;
 579
 580 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 581
 582 struct ModuleImport;
 583
 584 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 585
 586 struct ClassImport;
 587
 588 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 589
 590 struct Symbol
 591 {
 592 char *  string;
 593 struct Symbol * parent;
 594 struct Symbol * left;
 595 struct Symbol * right;
 596 int depth;
 597 struct Type * type;
 598 union
 599 {
 600 struct __ecereNameSpace__ecere__com__Method * method;
 601 struct __ecereNameSpace__ecere__com__Property * _property;
 602 struct __ecereNameSpace__ecere__com__Class * registered;
 603 } __attribute__ ((gcc_struct));
 604 int id;
 605 int idCode;
 606 union
 607 {
 608 struct
 609 {
 610 struct External * pointerExternal;
 611 struct External * structExternal;
 612 } __attribute__ ((gcc_struct));
 613 struct
 614 {
 615 struct External * externalGet;
 616 struct External * externalSet;
 617 struct External * externalPtr;
 618 struct External * externalIsSet;
 619 } __attribute__ ((gcc_struct));
 620 struct
 621 {
 622 struct External * methodExternal;
 623 struct External * methodCodeExternal;
 624 } __attribute__ ((gcc_struct));
 625 } __attribute__ ((gcc_struct));
 626 unsigned int imported;
 627 unsigned int declaredStructSym;
 628 struct __ecereNameSpace__ecere__com__Class * _class;
 629 unsigned int declaredStruct;
 630 unsigned int needConstructor;
 631 unsigned int needDestructor;
 632 char *  constructorName;
 633 char *  structName;
 634 char *  className;
 635 char *  destructorName;
 636 struct ModuleImport * module;
 637 struct ClassImport * _import;
 638 struct Location nameLoc;
 639 unsigned int isParam;
 640 unsigned int isRemote;
 641 unsigned int isStruct;
 642 unsigned int fireWatchersDone;
 643 int declaring;
 644 unsigned int classData;
 645 unsigned int isStatic;
 646 char *  shortName;
 647 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 648 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 649 struct Context * ctx;
 650 int isIterator;
 651 struct Expression * propCategory;
 652 } __attribute__ ((gcc_struct));
 653
 654 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 655
 656 struct Type
 657 {
 658 struct Type * prev;
 659 struct Type * next;
 660 int refCount;
 661 union
 662 {
 663 struct Symbol * _class;
 664 struct
 665 {
 666 struct __ecereNameSpace__ecere__sys__OldList members;
 667 char *  enumName;
 668 } __attribute__ ((gcc_struct));
 669 struct
 670 {
 671 struct Type * returnType;
 672 struct __ecereNameSpace__ecere__sys__OldList params;
 673 struct Symbol * thisClass;
 674 unsigned int staticMethod;
 675 struct TemplateParameter * thisClassTemplate;
 676 } __attribute__ ((gcc_struct));
 677 struct
 678 {
 679 struct __ecereNameSpace__ecere__com__Method * method;
 680 struct __ecereNameSpace__ecere__com__Class * methodClass;
 681 struct __ecereNameSpace__ecere__com__Class * usedClass;
 682 } __attribute__ ((gcc_struct));
 683 struct
 684 {
 685 struct Type * arrayType;
 686 int arraySize;
 687 struct Expression * arraySizeExp;
 688 unsigned int freeExp;
 689 struct Symbol * enumClass;
 690 } __attribute__ ((gcc_struct));
 691 struct Type * type;
 692 struct TemplateParameter * templateParameter;
 693 } __attribute__ ((gcc_struct));
 694 int kind;
 695 unsigned int size;
 696 char *  name;
 697 char *  typeName;
 698 int classObjectType;
 699 int alignment;
 700 unsigned int offset;
 701 int bitFieldCount;
 702 int count;
 703 unsigned int isSigned : 1;
 704 unsigned int constant : 1;
 705 unsigned int truth : 1;
 706 unsigned int byReference : 1;
 707 unsigned int extraParam : 1;
 708 unsigned int directClassAccess : 1;
 709 unsigned int computing : 1;
 710 unsigned int keepCast : 1;
 711 unsigned int passAsTemplate : 1;
 712 unsigned int dllExport : 1;
 713 unsigned int attrStdcall : 1;
 714 unsigned int declaredWithStruct : 1;
 715 unsigned int typedByReference : 1;
 716 } __attribute__ ((gcc_struct));
 717
 718 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 719
 720 struct __ecereNameSpace__ecere__com__Class
 721 {
 722 struct __ecereNameSpace__ecere__com__Class * prev;
 723 struct __ecereNameSpace__ecere__com__Class * next;
 724 char *  name;
 725 int offset;
 726 int structSize;
 727 int (* *  _vTbl)();
 728 int vTblSize;
 729 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 730 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 731 int offsetClass;
 732 int sizeClass;
 733 struct __ecereNameSpace__ecere__com__Class * base;
 734 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 735 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 736 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 737 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 738 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 739 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 740 int memberID;
 741 int startMemberID;
 742 int type;
 743 struct __ecereNameSpace__ecere__com__Instance * module;
 744 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 745 char *  dataTypeString;
 746 struct Type * dataType;
 747 int typeSize;
 748 int defaultAlignment;
 749 void (*  Initialize)();
 750 int memberOffset;
 751 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 752 char *  designerClass;
 753 unsigned int noExpansion;
 754 char *  defaultProperty;
 755 unsigned int comRedefinition;
 756 int count;
 757 unsigned int isRemote;
 758 unsigned int internalDecl;
 759 void *  data;
 760 unsigned int computeSize;
 761 int structAlignment;
 762 int destructionWatchOffset;
 763 unsigned int fixed;
 764 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 765 int inheritanceAccess;
 766 char *  fullName;
 767 void *  symbol;
 768 struct __ecereNameSpace__ecere__sys__OldList conversions;
 769 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 770 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 771 struct __ecereNameSpace__ecere__com__Class * templateClass;
 772 struct __ecereNameSpace__ecere__sys__OldList templatized;
 773 int numParams;
 774 unsigned int isInstanceClass;
 775 unsigned int byValueSystemClass;
 776 } __attribute__ ((gcc_struct));
 777
 778 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
 779
 780 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 781
 782 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 783
 784 struct __ecereNameSpace__ecere__com__Instance
 785 {
 786 int (* *  _vTbl)();
 787 struct __ecereNameSpace__ecere__com__Class * _class;
 788 int _refCount;
 789 } __attribute__ ((gcc_struct));
 790
 791 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 792
 793 struct __ecereNameSpace__ecere__com__DataMember
 794 {
 795 struct __ecereNameSpace__ecere__com__DataMember * prev;
 796 struct __ecereNameSpace__ecere__com__DataMember * next;
 797 char *  name;
 798 unsigned int isProperty;
 799 int memberAccess;
 800 int id;
 801 struct __ecereNameSpace__ecere__com__Class * _class;
 802 char *  dataTypeString;
 803 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 804 struct Type * dataType;
 805 int type;
 806 int offset;
 807 int memberID;
 808 struct __ecereNameSpace__ecere__sys__OldList members;
 809 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 810 int memberOffset;
 811 int structAlignment;
 812 } __attribute__ ((gcc_struct));
 813
 814 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 815
 816 struct __ecereNameSpace__ecere__com__SerialBuffer
 817 {
 818 unsigned char *  _buffer;
 819 unsigned int count;
 820 unsigned int _size;
 821 unsigned int pos;
 822 } __attribute__ ((gcc_struct));
 823
 824 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 825
 826 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 827 {
 828 union
 829 {
 830 struct
 831 {
 832 char *  dataTypeString;
 833 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 834 } __attribute__ ((gcc_struct));
 835 struct __ecereNameSpace__ecere__com__DataValue expression;
 836 struct
 837 {
 838 char *  memberString;
 839 union
 840 {
 841 struct __ecereNameSpace__ecere__com__DataMember * member;
 842 struct __ecereNameSpace__ecere__com__Property * prop;
 843 struct __ecereNameSpace__ecere__com__Method * method;
 844 } __attribute__ ((gcc_struct));
 845 } __attribute__ ((gcc_struct));
 846 } __attribute__ ((gcc_struct));
 847 } __attribute__ ((gcc_struct));
 848
 849 extern struct Identifier * MkIdentifier(char *  string);
 850
 851 struct Specifier * CopySpecifier(struct Specifier * spec);
 852
 853 struct Identifier * CopyIdentifier(struct Identifier * id)
 854 {
 855 if(id)
 856 {
 857 struct Identifier * copy = MkIdentifier(id->string);
 858
 859 copy->_class = id->_class ? CopySpecifier(id->_class) : (((void *)0));
 860 copy->classSym = id->classSym;
 861 return copy;
 862 }
 863 return (((void *)0));
 864 }
 865
 866 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
 867
 868 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
 869
 870 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
 871
 872 static struct Pointer * CopyPointer(struct Pointer * ptr)
 873 {
 874 if(ptr)
 875 {
 876 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
 877 struct Specifier * spec;
 878
 879 if(ptr->qualifiers)
 880 {
 881 for(spec = (*ptr->qualifiers).first; spec; spec = spec->next)
 882 ListAdd(list, CopySpecifier(spec));
 883 }
 884 return MkPointer(list, CopyPointer(ptr->pointer));
 885 }
 886 return (((void *)0));
 887 }
 888
 889 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
 890
 891 struct Expression * CopyExpression(struct Expression * exp);
 892
 893 extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
 894
 895 struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
 896
 897 static struct Initializer * CopyInitializer(struct Initializer * initializer)
 898 {
 899 struct Initializer * copy = (((void *)0));
 900
 901 ;
 902 if(initializer->type == 0)
 903 copy = MkInitializerAssignment(CopyExpression(initializer->exp));
 904 else if(initializer->type == 1)
 905 copy = MkInitializerList(CopyList(initializer->list, CopyInitializer));
 906 if(copy)
 907 {
 908 copy->loc = initializer->loc;
 909 copy->isConstant = initializer->isConstant;
 910 }
 911 return copy;
 912 }
 913
 914 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 915
 916 struct MemberInit
 917 {
 918 struct MemberInit * prev;
 919 struct MemberInit * next;
 920 struct Location loc;
 921 struct Location realLoc;
 922 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
 923 struct Initializer * initializer;
 924 unsigned int used;
 925 unsigned int variable;
 926 unsigned int takeOutExp;
 927 } __attribute__ ((gcc_struct));
 928
 929 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
 930
 931 static struct MemberInit * CopyMemberInit(struct MemberInit * member)
 932 {
 933 return MkMemberInit(CopyList(member->identifiers, CopyIdentifier), CopyInitializer(member->initializer));
 934 }
 935
 936 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 937
 938 struct ClassFunction;
 939
 940 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 941
 942 struct MembersInit
 943 {
 944 struct MembersInit * prev;
 945 struct MembersInit * next;
 946 struct Location loc;
 947 int type;
 948 union
 949 {
 950 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
 951 struct ClassFunction * function;
 952 } __attribute__ ((gcc_struct));
 953 } __attribute__ ((gcc_struct));
 954
 955 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
 956
 957 static struct MembersInit * CopyMembersInit(struct MembersInit * members)
 958 {
 959 struct __ecereNameSpace__ecere__sys__OldList * list = (((void *)0));
 960
 961 switch(members->type)
 962 {
 963 case 0:
 964 {
 965 if(members)
 966 {
 967 struct MemberInit * member;
 968
 969 list = MkList();
 970 for(member = (*members->dataMembers).first; member; member = member->next)
 971 ListAdd(list, CopyMemberInit(member));
 972 }
 973 }
 974 }
 975 return MkMembersInitList(list);
 976 }
 977
 978 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
 979
 980 extern struct Symbol * FindClass(char *  name);
 981
 982 static struct Instantiation * CopyInstantiation(struct Instantiation * inst)
 983 {
 984 struct Instantiation * copy;
 985 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
 986 struct MembersInit * member;
 987
 988 if(inst->members)
 989 {
 990 for(member = (*inst->members).first; member; member = member->next)
 991 ListAdd(list, CopyMembersInit(member));
 992 }
 993 copy = MkInstantiation(CopySpecifier(inst->_class), CopyExpression(inst->exp), list);
 994 copy->data = inst->data;
 995 if(inst->data)
 996 {
 997 struct Symbol * classSym = FindClass(inst->_class->name);
 998 struct __ecereNameSpace__ecere__com__Class * _class = classSym ? classSym->registered : (((void *)0));
 999
1000 if(_class)
1001 {
1002 if(_class->type == 0)
1003 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)((struct __ecereNameSpace__ecere__com__Instance *)copy->data))->_refCount++;
1004 }
1005 }
1006 copy->loc = inst->loc;
1007 copy->isConstant = inst->isConstant;
1008 return copy;
1009 }
1010
1011 extern struct Expression * MkExpDummy(void);
1012
1013 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1014
1015 extern struct Expression * MkExpInstance(struct Instantiation * inst);
1016
1017 extern struct Expression * MkExpConstant(char *  string);
1018
1019 extern struct Expression * MkExpString(char *  string);
1020
1021 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1022
1023 extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1024
1025 extern struct Expression * MkExpIndex(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * index);
1026
1027 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1028
1029 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1030
1031 extern struct Expression * MkExpPointer(struct Expression * expression, struct Identifier * member);
1032
1033 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
1034
1035 struct TypeName * CopyTypeName(struct TypeName * typeName);
1036
1037 extern struct Expression * MkExpTypeAlign(struct TypeName * typeName);
1038
1039 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1040
1041 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
1042
1043 extern struct Expression * MkExpVaArg(struct Expression * exp, struct TypeName * type);
1044
1045 extern struct Expression * MkExpExtensionCompound(struct Statement * compound);
1046
1047 static struct Statement * CopyStatement(struct Statement * stmt);
1048
1049 extern struct Expression * MkExpExtensionInitializer(struct TypeName * typeName, struct Initializer * initializer);
1050
1051 struct Expression * CopyExpression(struct Expression * exp)
1052 {
1053 struct Expression * result = (((void *)0));
1054
1055 if(exp)
1056 switch(exp->type)
1057 {
1058 case 16:
1059 result = MkExpDummy();
1060 break;
1061 case 0:
1062 result = MkExpIdentifier(CopyIdentifier(exp->identifier));
1063 break;
1064 case 1:
1065 result = MkExpInstance(CopyInstantiation(exp->instance));
1066 break;
1067 case 2:
1068 result = MkExpConstant(exp->string);
1069 break;
1070 case 3:
1071 result = MkExpString(exp->string);
1072 break;
1073 case 4:
1074 result = MkExpOp(CopyExpression(exp->op.exp1), exp->op.op, CopyExpression(exp->op.exp2));
1075 break;
1076 case 5:
1077 {
1078 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1079 struct Expression * e;
1080
1081 for(e = (*exp->list).first; e; e = e->next)
1082 ListAdd(list, CopyExpression(e));
1083 result = MkExpBrackets(list);
1084 break;
1085 }
1086 case 6:
1087 {
1088 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1089 struct Expression * e;
1090
1091 for(e = (*exp->index.index).first; e; e = e->next)
1092 ListAdd(list, CopyExpression(e));
1093 result = MkExpIndex(CopyExpression(exp->index.exp), list);
1094 break;
1095 }
1096 case 7:
1097 {
1098 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1099 struct Expression * arg;
1100
1101 if(exp->call.arguments)
1102 {
1103 for(arg = (*exp->call.arguments).first; arg; arg = arg->next)
1104 ListAdd(list, CopyExpression(arg));
1105 }
1106 result = MkExpCall(CopyExpression(exp->call.exp), list);
1107 break;
1108 }
1109 case 8:
1110 result = MkExpMember(CopyExpression(exp->member.exp), CopyIdentifier(exp->member.member));
1111 result->member.memberType = exp->member.memberType;
1112 result->member.thisPtr = exp->member.thisPtr;
1113 break;
1114 case 9:
1115 result = MkExpPointer(CopyExpression(exp->member.exp), CopyIdentifier(exp->member.member));
1116 break;
1117 case 10:
1118 result = MkExpTypeSize(CopyTypeName(exp->typeName));
1119 break;
1120 case 36:
1121 result = MkExpTypeAlign(CopyTypeName(exp->typeName));
1122 break;
1123 case 11:
1124 result = MkExpCast(CopyTypeName(exp->cast.typeName), CopyExpression(exp->cast.exp));
1125 break;
1126 case 12:
1127 {
1128 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1129 struct Expression * e;
1130
1131 for(e = (*exp->cond.exp).first; e; e = e->next)
1132 ListAdd(list, CopyExpression(e));
1133 result = MkExpCondition(CopyExpression(exp->cond.cond), list, CopyExpression(exp->cond.elseExp));
1134 break;
1135 }
1136 case 34:
1137 result = MkExpVaArg(CopyExpression(exp->vaArg.exp), CopyTypeName(exp->vaArg.typeName));
1138 break;
1139 case 23:
1140 result = MkExpExtensionCompound(CopyStatement(exp->compound));
1141 break;
1142 case 33:
1143 result = MkExpExtensionInitializer(CopyTypeName(exp->initializer.typeName), CopyInitializer(exp->initializer.initializer));
1144 break;
1145 }
1146 if(result)
1147 {
1148 result->expType = exp->expType;
1149 if(exp->expType)
1150 exp->expType->refCount++;
1151 result->destType = exp->destType;
1152 if(exp->destType)
1153 exp->destType->refCount++;
1154 result->loc = exp->loc;
1155 result->isConstant = exp->isConstant;
1156 result->byReference = exp->byReference;
1157 }
1158 return result;
1159 }
1160
1161 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1162
1163 struct Declaration * CopyDeclaration(struct Declaration * decl);
1164
1165 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1166
1167 extern struct Statement * MkBadDeclStmt(struct Declaration * decl);
1168
1169 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1170
1171 static struct Statement * CopyStatement(struct Statement * stmt)
1172 {
1173 struct Statement * result = (((void *)0));
1174
1175 if(stmt)
1176 {
1177 switch(stmt->type)
1178 {
1179 case 2:
1180 result = MkCompoundStmt(CopyList(stmt->compound.declarations, CopyDeclaration), CopyList(stmt->compound.statements, CopyStatement));
1181 result->compound.context = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1182 break;
1183 case 3:
1184 result = MkExpressionStmt(CopyList(stmt->expressions, CopyExpression));
1185 break;
1186 case 14:
1187 result = MkBadDeclStmt(CopyDeclaration(stmt->decl));
1188 break;
1189 }
1190 }
1191 if(result)
1192 {
1193 result->loc = stmt->loc;
1194 }
1195 return result;
1196 }
1197
1198 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
1199
1200 struct Enumerator
1201 {
1202 struct Enumerator * prev;
1203 struct Enumerator * next;
1204 struct Location loc;
1205 struct Identifier * id;
1206 struct Expression * exp;
1207 } __attribute__ ((gcc_struct));
1208
1209 extern struct Enumerator * MkEnumerator(struct Identifier * id, struct Expression * exp);
1210
1211 static struct Enumerator * CopyEnumerator(struct Enumerator * enumerator)
1212 {
1213 return MkEnumerator(CopyIdentifier(enumerator->id), CopyExpression(enumerator->exp));
1214 }
1215
1216 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
1217
1218 struct PropertyDef;
1219
1220 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1221
1222 struct PropertyWatch;
1223
1224 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1225
1226 struct ClassDef
1227 {
1228 struct ClassDef * prev;
1229 struct ClassDef * next;
1230 struct Location loc;
1231 int type;
1232 union
1233 {
1234 struct Declaration * decl;
1235 struct ClassFunction * function;
1236 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1237 struct PropertyDef * propertyDef;
1238 struct PropertyWatch * propertyWatch;
1239 char *  designer;
1240 struct Identifier * defaultProperty;
1241 struct
1242 {
1243 struct Identifier * id;
1244 struct Initializer * initializer;
1245 } __attribute__ ((gcc_struct));
1246 } __attribute__ ((gcc_struct));
1247 int memberAccess;
1248 void *  object;
1249 } __attribute__ ((gcc_struct));
1250
1251 extern struct ClassDef * MkClassDefDeclaration(struct Declaration * decl);
1252
1253 struct ClassDef * CopyClassDef(struct ClassDef * def)
1254 {
1255 switch(def->type)
1256 {
1257 case 0:
1258 return (((void *)0));
1259 case 1:
1260 return (((void *)0));
1261 case 2:
1262 return MkClassDefDeclaration(CopyDeclaration(def->decl));
1263 case 3:
1264 return (((void *)0));
1265 }
1266 return (((void *)0));
1267 }
1268
1269 extern struct Specifier * MkSpecifier(int specifier);
1270
1271 extern struct Specifier * MkEnum(struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * list);
1272
1273 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1274
1275 struct ExtDecl * CopyExtDecl(struct ExtDecl * extDecl);
1276
1277 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1278
1279 extern struct Specifier * MkSpecifierSubClass(struct Specifier * _class);
1280
1281 extern struct Specifier * MkSpecifierExtended(struct ExtDecl * extDecl);
1282
1283 struct Specifier * CopySpecifier(struct Specifier * spec)
1284 {
1285 if(spec)
1286 switch(spec->type)
1287 {
1288 case 0:
1289 return MkSpecifier(spec->specifier);
1290 case 2:
1291 {
1292 struct Identifier * id = CopyIdentifier(spec->id);
1293 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1294 struct Enumerator * enumerator;
1295
1296 if(spec->list)
1297 {
1298 for(enumerator = (*spec->list).first; enumerator; enumerator = enumerator->next)
1299 ListAdd(list, CopyEnumerator(enumerator));
1300 }
1301 return MkEnum(id, list);
1302 }
1303 case 3:
1304 case 4:
1305 {
1306 struct Identifier * id = CopyIdentifier(spec->id);
1307 struct __ecereNameSpace__ecere__sys__OldList * list = (((void *)0));
1308 struct ClassDef * def;
1309 struct Specifier * s;
1310
1311 if(spec->definitions)
1312 {
1313 list = MkList();
1314 if(spec->list)
1315 {
1316 for(def = (*spec->list).first; def; def = def->next)
1317 ListAdd(list, CopyClassDef(def));
1318 }
1319 }
1320 s = MkStructOrUnion(spec->type, id, list);
1321 s->extDeclStruct = CopyExtDecl(spec->extDeclStruct);
1322 return s;
1323 }
1324 case 1:
1325 {
1326 struct Specifier * copy = (copy = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Specifier), copy->type = 1, copy->name = __ecereNameSpace__ecere__sys__CopyString(spec->name), copy->symbol = spec->symbol, copy->templateArgs = (((void *)0)), copy);
1327
1328 return copy;
1329 }
1330 case 7:
1331 return MkSpecifierSubClass(CopySpecifier(spec->_class));
1332 case 8:
1333 return __extension__ ({
1334 struct Specifier * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Specifier);
1335
1336 __ecereInstance1->loc = spec->loc, __ecereInstance1->type = 8, __ecereInstance1->templateParameter = spec->templateParameter, __ecereInstance1;
1337 });
1338 case 5:
1339 return MkSpecifierExtended(CopyExtDecl(spec->extDecl));
1340 }
1341 return (((void *)0));
1342 }
1343
1344 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1345
1346 struct Declarator * CopyDeclarator(struct Declarator * declarator);
1347
1348 struct TypeName * CopyTypeName(struct TypeName * typeName)
1349 {
1350 struct __ecereNameSpace__ecere__sys__OldList * list = (((void *)0));
1351 struct TypeName * copy;
1352
1353 if(typeName->qualifiers)
1354 {
1355 struct Specifier * spec;
1356
1357 list = MkList();
1358 for(spec = (*typeName->qualifiers).first; spec; spec = spec->next)
1359 ListAdd(list, CopySpecifier(spec));
1360 }
1361 copy = MkTypeName(list, CopyDeclarator(typeName->declarator));
1362 copy->classObjectType = typeName->classObjectType;
1363 return copy;
1364 }
1365
1366 extern struct ExtDecl * MkExtDeclAttrib(struct Attrib * attr);
1367
1368 struct Attrib * CopyAttrib(struct Attrib * attrib);
1369
1370 extern struct ExtDecl * MkExtDeclString(char * s);
1371
1372 struct ExtDecl * CopyExtDecl(struct ExtDecl * extDecl)
1373 {
1374 if(extDecl)
1375 {
1376 if(extDecl->type == 1)
1377 return MkExtDeclAttrib(CopyAttrib(extDecl->attr));
1378 else if(extDecl->type == 0)
1379 return MkExtDeclString(__ecereNameSpace__ecere__sys__CopyString(extDecl->s));
1380 }
1381 return (((void *)0));
1382 }
1383
1384 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
1385
1386 struct Attribute
1387 {
1388 struct Attribute * prev;
1389 struct Attribute * next;
1390 struct Location loc;
1391 char * attr;
1392 struct Expression * exp;
1393 } __attribute__ ((gcc_struct));
1394
1395 extern struct Attribute * MkAttribute(char * attr, struct Expression * exp);
1396
1397 struct Attribute * CopyAttribute(struct Attribute * attrib)
1398 {
1399 if(attrib)
1400 return MkAttribute(__ecereNameSpace__ecere__sys__CopyString(attrib->attr), CopyExpression(attrib->exp));
1401 return (((void *)0));
1402 }
1403
1404 extern struct Attrib * MkAttrib(int type, struct __ecereNameSpace__ecere__sys__OldList *  attribs);
1405
1406 struct Attrib * CopyAttrib(struct Attrib * attrib)
1407 {
1408 if(attrib)
1409 return MkAttrib(attrib->type, CopyList(attrib->attribs, CopyAttribute));
1410 return (((void *)0));
1411 }
1412
1413 extern struct Declarator * MkStructDeclarator(struct Declarator * declarator, struct Expression * exp);
1414
1415 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1416
1417 extern struct Declarator * MkDeclaratorBrackets(struct Declarator * declarator);
1418
1419 extern struct Declarator * MkDeclaratorEnumArray(struct Declarator * declarator, struct Specifier * _class);
1420
1421 extern struct Declarator * MkDeclaratorArray(struct Declarator * declarator, struct Expression * exp);
1422
1423 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
1424
1425 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1426
1427 extern struct Declarator * MkDeclaratorExtended(struct ExtDecl * extended, struct Declarator * declarator);
1428
1429 extern struct Declarator * MkDeclaratorExtendedEnd(struct ExtDecl * extended, struct Declarator * declarator);
1430
1431 struct Declarator * CopyDeclarator(struct Declarator * declarator)
1432 {
1433 if(declarator)
1434 {
1435 switch(declarator->type)
1436 {
1437 case 0:
1438 {
1439 struct Declarator * decl = MkStructDeclarator(CopyDeclarator(declarator->declarator), CopyExpression(declarator->structDecl.exp));
1440
1441 if(declarator->structDecl.attrib)
1442 decl->structDecl.attrib = CopyAttrib(declarator->structDecl.attrib);
1443 return decl;
1444 }
1445 case 1:
1446 return MkDeclaratorIdentifier(CopyIdentifier(declarator->identifier));
1447 case 2:
1448 return MkDeclaratorBrackets(CopyDeclarator(declarator->declarator));
1449 case 3:
1450 if(declarator->array.enumClass)
1451 return MkDeclaratorEnumArray(CopyDeclarator(declarator->declarator), CopySpecifier(declarator->array.enumClass));
1452 else
1453 return MkDeclaratorArray(CopyDeclarator(declarator->declarator), CopyExpression(declarator->array.exp));
1454 case 4:
1455 {
1456 struct __ecereNameSpace__ecere__sys__OldList * parameters = MkList();
1457 struct TypeName * param;
1458
1459 if(declarator->function.parameters)
1460 {
1461 for(param = (*declarator->function.parameters).first; param; param = param->next)
1462 ListAdd(parameters, CopyTypeName(param));
1463 }
1464 return MkDeclaratorFunction(CopyDeclarator(declarator->declarator), parameters);
1465 }
1466 case 5:
1467 return MkDeclaratorPointer(CopyPointer(declarator->pointer.pointer), CopyDeclarator(declarator->declarator));
1468 case 6:
1469 return MkDeclaratorExtended(CopyExtDecl(declarator->extended.extended), CopyDeclarator(declarator->declarator));
1470 case 7:
1471 return MkDeclaratorExtendedEnd(CopyExtDecl(declarator->extended.extended), CopyDeclarator(declarator->declarator));
1472 }
1473 }
1474 return (((void *)0));
1475 }
1476
1477 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
1478
1479 struct InitDeclarator
1480 {
1481 struct InitDeclarator * prev;
1482 struct InitDeclarator * next;
1483 struct Location loc;
1484 struct Declarator * declarator;
1485 struct Initializer * initializer;
1486 } __attribute__ ((gcc_struct));
1487
1488 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1489
1490 struct InitDeclarator * CopyInitDeclarator(struct InitDeclarator * initDecl)
1491 {
1492 return MkInitDeclarator(CopyDeclarator(initDecl->declarator), CopyInitializer(initDecl->initializer));
1493 }
1494
1495 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1496
1497 struct Declaration * CopyDeclaration(struct Declaration * decl)
1498 {
1499 if(decl->type == 1)
1500 {
1501 return MkDeclaration(CopyList(decl->specifiers, CopySpecifier), CopyList(decl->declarators, CopyInitDeclarator));
1502 }
1503 else
1504 {
1505 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList(), * declarators = MkList();
1506 struct Specifier * spec;
1507 struct Declarator * declarator;
1508
1509 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1510 ListAdd(specifiers, CopySpecifier(spec));
1511 if(decl->declarators)
1512 {
1513 for(declarator = (*decl->declarators).first; declarator; declarator = declarator->next)
1514 ListAdd(declarators, CopyDeclarator(declarator));
1515 }
1516 return MkDeclaration(specifiers, declarators);
1517 }
1518 }
1519
1520 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__Item;
1521
1522 struct __ecereNameSpace__ecere__sys__Item
1523 {
1524 struct __ecereNameSpace__ecere__sys__Item * prev;
1525 struct __ecereNameSpace__ecere__sys__Item * next;
1526 } __attribute__ ((gcc_struct));
1527
1528 struct __ecereNameSpace__ecere__sys__OldList * CopyList(struct __ecereNameSpace__ecere__sys__OldList * source, void * (* CopyFunction)(void *))
1529 {
1530 struct __ecereNameSpace__ecere__sys__OldList * list = (((void *)0));
1531
1532 if(source)
1533 {
1534 struct __ecereNameSpace__ecere__sys__Item * item;
1535
1536 list = MkList();
1537 for(item = (*source).first; item; item = item->next)
1538 ListAdd(list, CopyFunction(item));
1539 }
1540 return list;
1541 }
1542
1543 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
1544
1545 struct __ecereNameSpace__ecere__com__GlobalFunction;
1546
1547 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);
1548
1549 void __ecereRegisterModule_copy(struct __ecereNameSpace__ecere__com__Instance * module)
1550 {
1551 struct __ecereNameSpace__ecere__com__Class * class;
1552
1553 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyIdentifier", "Identifier CopyIdentifier(Identifier id)", CopyIdentifier, module, 2);
1554 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyExpression", "Expression CopyExpression(Expression exp)", CopyExpression, module, 1);
1555 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyClassDef", "ClassDef CopyClassDef(ClassDef def)", CopyClassDef, module, 2);
1556 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopySpecifier", "Specifier CopySpecifier(Specifier spec)", CopySpecifier, module, 2);
1557 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyTypeName", "TypeName CopyTypeName(TypeName typeName)", CopyTypeName, module, 2);
1558 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyExtDecl", "ExtDecl CopyExtDecl(ExtDecl extDecl)", CopyExtDecl, module, 2);
1559 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyAttribute", "Attribute CopyAttribute(Attribute attrib)", CopyAttribute, module, 2);
1560 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyAttrib", "Attrib CopyAttrib(Attrib attrib)", CopyAttrib, module, 2);
1561 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyDeclarator", "Declarator CopyDeclarator(Declarator declarator)", CopyDeclarator, module, 2);
1562 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyInitDeclarator", "InitDeclarator CopyInitDeclarator(InitDeclarator initDecl)", CopyInitDeclarator, module, 2);
1563 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyDeclaration", "Declaration CopyDeclaration(Declaration decl)", CopyDeclaration, module, 2);
1564 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CopyList", "ecere::sys::OldList * CopyList(ecere::sys::OldList * source, void * (* CopyFunction)(void *))", CopyList, module, 2);
1565 }
1566
1567 void __ecereUnregisterModule_copy(struct __ecereNameSpace__ecere__com__Instance * module)
1568 {
1569
1570 }
1571