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