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