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

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