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