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

   1 /* Code generated from eC source file: pass15.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 #include <stdint.h>
  39 #include <sys/types.h>
  40
  41 #if /*defined(_W64) || */(defined(__WORDSIZE) && __WORDSIZE == 8) || defined(__x86_64__)
  42 #define _64BIT 1
  43 #else
  44 #define _64BIT 0
  45 #endif
  46
  47 #define arch_PointerSize                  sizeof(void *)
  48 #define structSize_Instance               (_64BIT ? 24 : 12)
  49 #define structSize_Module                 (_64BIT ? 560 : 300)
  50 #define structSize_NamedLink64            (_64BIT ? 32 : 24)
  51
  52 struct __ecereNameSpace__ecere__com__Instance;
  53
  54 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  55
  56 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  57
  58 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  59
  60 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  61
  62 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
  63
  64 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  65
  66 struct __ecereNameSpace__ecere__sys__BTNode;
  67
  68 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  69
  70 struct __ecereNameSpace__ecere__sys__BinaryTree
  71 {
  72 struct __ecereNameSpace__ecere__sys__BTNode * root;
  73 int count;
  74 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  75 void (*  FreeKey)(void *  key);
  76 } __attribute__ ((gcc_struct));
  77
  78 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  79
  80 struct __ecereNameSpace__ecere__sys__OldList
  81 {
  82 void *  first;
  83 void *  last;
  84 int count;
  85 unsigned int offset;
  86 unsigned int circ;
  87 } __attribute__ ((gcc_struct));
  88
  89 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  90
  91 struct __ecereNameSpace__ecere__com__Method
  92 {
  93 const char *  name;
  94 struct __ecereNameSpace__ecere__com__Method * parent;
  95 struct __ecereNameSpace__ecere__com__Method * left;
  96 struct __ecereNameSpace__ecere__com__Method * right;
  97 int depth;
  98 int (*  function)();
  99 int vid;
 100 int type;
 101 struct __ecereNameSpace__ecere__com__Class * _class;
 102 void *  symbol;
 103 const char *  dataTypeString;
 104 struct Type * dataType;
 105 int memberAccess;
 106 } __attribute__ ((gcc_struct));
 107
 108 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
 109
 110 struct __ecereNameSpace__ecere__com__Property
 111 {
 112 struct __ecereNameSpace__ecere__com__Property * prev;
 113 struct __ecereNameSpace__ecere__com__Property * next;
 114 const char *  name;
 115 unsigned int isProperty;
 116 int memberAccess;
 117 int id;
 118 struct __ecereNameSpace__ecere__com__Class * _class;
 119 const char *  dataTypeString;
 120 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 121 struct Type * dataType;
 122 void (*  Set)(void * , int);
 123 int (*  Get)(void * );
 124 unsigned int (*  IsSet)(void * );
 125 void *  data;
 126 void *  symbol;
 127 int vid;
 128 unsigned int conversion;
 129 unsigned int watcherOffset;
 130 const char *  category;
 131 unsigned int compiled;
 132 unsigned int selfWatchable;
 133 unsigned int isWatchable;
 134 } __attribute__ ((gcc_struct));
 135
 136 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
 137
 138 struct CodePosition
 139 {
 140 int line;
 141 int charPos;
 142 int pos;
 143 int included;
 144 } __attribute__ ((gcc_struct));
 145
 146 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 147
 148 struct Location
 149 {
 150 struct CodePosition start;
 151 struct CodePosition end;
 152 } __attribute__ ((gcc_struct));
 153
 154 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attrib;
 155
 156 struct Attrib;
 157
 158 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ExtDecl;
 159
 160 struct ExtDecl
 161 {
 162 struct Location loc;
 163 int type;
 164 union
 165 {
 166 char * s;
 167 struct Attrib * attr;
 168 } __attribute__ ((gcc_struct)) __anon1;
 169 } __attribute__ ((gcc_struct));
 170
 171 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 172
 173 struct ClassDefinition
 174 {
 175 struct ClassDefinition * prev;
 176 struct ClassDefinition * next;
 177 struct Location loc;
 178 struct Specifier * _class;
 179 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 180 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 181 struct Symbol * symbol;
 182 struct Location blockStart;
 183 struct Location nameLoc;
 184 int endid;
 185 int declMode;
 186 unsigned int deleteWatchable;
 187 } __attribute__ ((gcc_struct));
 188
 189 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 190
 191 struct Context
 192 {
 193 struct Context * parent;
 194 struct __ecereNameSpace__ecere__sys__BinaryTree types;
 195 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 196 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
 197 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
 198 int nextID;
 199 int simpleID;
 200 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
 201 struct ClassDefinition * classDef;
 202 unsigned int templateTypesOnly;
 203 unsigned int hasNameSpace;
 204 } __attribute__ ((gcc_struct));
 205
 206 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 207
 208 struct Instantiation
 209 {
 210 struct Instantiation * prev;
 211 struct Instantiation * next;
 212 struct Location loc;
 213 struct Specifier * _class;
 214 struct Expression * exp;
 215 struct __ecereNameSpace__ecere__sys__OldList *  members;
 216 struct Symbol * symbol;
 217 unsigned int fullSet;
 218 unsigned int isConstant;
 219 unsigned char *  data;
 220 struct Location nameLoc;
 221 struct Location insideLoc;
 222 unsigned int built;
 223 } __attribute__ ((gcc_struct));
 224
 225 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 226
 227 struct Declaration
 228 {
 229 struct Declaration * prev;
 230 struct Declaration * next;
 231 struct Location loc;
 232 int type;
 233 union
 234 {
 235 struct
 236 {
 237 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 238 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 239 } __attribute__ ((gcc_struct)) __anon1;
 240 struct Instantiation * inst;
 241 struct
 242 {
 243 struct Identifier * id;
 244 struct Expression * exp;
 245 } __attribute__ ((gcc_struct)) __anon2;
 246 } __attribute__ ((gcc_struct)) __anon1;
 247 struct Specifier * extStorage;
 248 struct Symbol * symbol;
 249 int declMode;
 250 } __attribute__ ((gcc_struct));
 251
 252 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 253
 254 struct Statement
 255 {
 256 struct Statement * prev;
 257 struct Statement * next;
 258 struct Location loc;
 259 int type;
 260 union
 261 {
 262 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 263 struct
 264 {
 265 struct Identifier * id;
 266 struct Statement * stmt;
 267 } __attribute__ ((gcc_struct)) labeled;
 268 struct
 269 {
 270 struct Expression * exp;
 271 struct Statement * stmt;
 272 } __attribute__ ((gcc_struct)) caseStmt;
 273 struct
 274 {
 275 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 276 struct __ecereNameSpace__ecere__sys__OldList * statements;
 277 struct Context * context;
 278 unsigned int isSwitch;
 279 } __attribute__ ((gcc_struct)) compound;
 280 struct
 281 {
 282 struct __ecereNameSpace__ecere__sys__OldList * exp;
 283 struct Statement * stmt;
 284 struct Statement * elseStmt;
 285 } __attribute__ ((gcc_struct)) ifStmt;
 286 struct
 287 {
 288 struct __ecereNameSpace__ecere__sys__OldList * exp;
 289 struct Statement * stmt;
 290 } __attribute__ ((gcc_struct)) switchStmt;
 291 struct
 292 {
 293 struct __ecereNameSpace__ecere__sys__OldList * exp;
 294 struct Statement * stmt;
 295 } __attribute__ ((gcc_struct)) whileStmt;
 296 struct
 297 {
 298 struct __ecereNameSpace__ecere__sys__OldList * exp;
 299 struct Statement * stmt;
 300 } __attribute__ ((gcc_struct)) doWhile;
 301 struct
 302 {
 303 struct Statement * init;
 304 struct Statement * check;
 305 struct __ecereNameSpace__ecere__sys__OldList * increment;
 306 struct Statement * stmt;
 307 } __attribute__ ((gcc_struct)) forStmt;
 308 struct
 309 {
 310 struct Identifier * id;
 311 } __attribute__ ((gcc_struct)) gotoStmt;
 312 struct
 313 {
 314 struct Specifier * spec;
 315 char * statements;
 316 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 317 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 318 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 319 } __attribute__ ((gcc_struct)) asmStmt;
 320 struct
 321 {
 322 struct Expression * watcher;
 323 struct Expression * object;
 324 struct __ecereNameSpace__ecere__sys__OldList * watches;
 325 } __attribute__ ((gcc_struct)) _watch;
 326 struct
 327 {
 328 struct Identifier * id;
 329 struct __ecereNameSpace__ecere__sys__OldList * exp;
 330 struct __ecereNameSpace__ecere__sys__OldList * filter;
 331 struct Statement * stmt;
 332 } __attribute__ ((gcc_struct)) forEachStmt;
 333 struct Declaration * decl;
 334 } __attribute__ ((gcc_struct)) __anon1;
 335 } __attribute__ ((gcc_struct));
 336
 337 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 338
 339 struct TypeName
 340 {
 341 struct TypeName * prev;
 342 struct TypeName * next;
 343 struct Location loc;
 344 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 345 struct Declarator * declarator;
 346 int classObjectType;
 347 struct Expression * bitCount;
 348 } __attribute__ ((gcc_struct));
 349
 350 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 351
 352 struct Initializer
 353 {
 354 struct Initializer * prev;
 355 struct Initializer * next;
 356 struct Location loc;
 357 int type;
 358 union
 359 {
 360 struct Expression * exp;
 361 struct __ecereNameSpace__ecere__sys__OldList *  list;
 362 } __attribute__ ((gcc_struct)) __anon1;
 363 unsigned int isConstant;
 364 struct Identifier * id;
 365 } __attribute__ ((gcc_struct));
 366
 367 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 368
 369 struct __ecereNameSpace__ecere__com__DataValue
 370 {
 371 union
 372 {
 373 char c;
 374 unsigned char uc;
 375 short s;
 376 unsigned short us;
 377 int i;
 378 unsigned int ui;
 379 void *  p;
 380 float f;
 381 double d;
 382 long long i64;
 383 uint64 ui64;
 384 } __attribute__ ((gcc_struct)) __anon1;
 385 } __attribute__ ((gcc_struct));
 386
 387 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 388
 389 struct Expression
 390 {
 391 struct Expression * prev;
 392 struct Expression * next;
 393 struct Location loc;
 394 int type;
 395 union
 396 {
 397 struct
 398 {
 399 char *  constant;
 400 struct Identifier * identifier;
 401 } __attribute__ ((gcc_struct)) __anon1;
 402 struct Statement * compound;
 403 struct Instantiation * instance;
 404 struct
 405 {
 406 char *  string;
 407 unsigned int intlString;
 408 unsigned int wideString;
 409 } __attribute__ ((gcc_struct)) __anon2;
 410 struct __ecereNameSpace__ecere__sys__OldList *  list;
 411 struct
 412 {
 413 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 414 struct Declarator * decl;
 415 } __attribute__ ((gcc_struct)) _classExp;
 416 struct
 417 {
 418 struct Identifier * id;
 419 } __attribute__ ((gcc_struct)) classData;
 420 struct
 421 {
 422 struct Expression * exp;
 423 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 424 struct Location argLoc;
 425 } __attribute__ ((gcc_struct)) call;
 426 struct
 427 {
 428 struct Expression * exp;
 429 struct __ecereNameSpace__ecere__sys__OldList * index;
 430 } __attribute__ ((gcc_struct)) index;
 431 struct
 432 {
 433 struct Expression * exp;
 434 struct Identifier * member;
 435 int memberType;
 436 unsigned int thisPtr;
 437 } __attribute__ ((gcc_struct)) member;
 438 struct
 439 {
 440 int op;
 441 struct Expression * exp1;
 442 struct Expression * exp2;
 443 } __attribute__ ((gcc_struct)) op;
 444 struct TypeName * typeName;
 445 struct Specifier * _class;
 446 struct
 447 {
 448 struct TypeName * typeName;
 449 struct Expression * exp;
 450 } __attribute__ ((gcc_struct)) cast;
 451 struct
 452 {
 453 struct Expression * cond;
 454 struct __ecereNameSpace__ecere__sys__OldList * exp;
 455 struct Expression * elseExp;
 456 } __attribute__ ((gcc_struct)) cond;
 457 struct
 458 {
 459 struct TypeName * typeName;
 460 struct Expression * size;
 461 } __attribute__ ((gcc_struct)) _new;
 462 struct
 463 {
 464 struct TypeName * typeName;
 465 struct Expression * size;
 466 struct Expression * exp;
 467 } __attribute__ ((gcc_struct)) _renew;
 468 struct
 469 {
 470 char * table;
 471 struct Identifier * id;
 472 } __attribute__ ((gcc_struct)) db;
 473 struct
 474 {
 475 struct Expression * ds;
 476 struct Expression * name;
 477 } __attribute__ ((gcc_struct)) dbopen;
 478 struct
 479 {
 480 struct TypeName * typeName;
 481 struct Initializer * initializer;
 482 } __attribute__ ((gcc_struct)) initializer;
 483 struct
 484 {
 485 struct Expression * exp;
 486 struct TypeName * typeName;
 487 } __attribute__ ((gcc_struct)) vaArg;
 488 } __attribute__ ((gcc_struct)) __anon1;
 489 unsigned int debugValue;
 490 struct __ecereNameSpace__ecere__com__DataValue val;
 491 uint64 address;
 492 unsigned int hasAddress;
 493 struct Type * expType;
 494 struct Type * destType;
 495 unsigned int usage;
 496 int tempCount;
 497 unsigned int byReference;
 498 unsigned int isConstant;
 499 unsigned int addedThis;
 500 unsigned int needCast;
 501 unsigned int thisPtr;
 502 unsigned int opDestType;
 503 unsigned int needTemplateCast;
 504 } __attribute__ ((gcc_struct));
 505
 506 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 507
 508 struct TemplateDatatype
 509 {
 510 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 511 struct Declarator * decl;
 512 } __attribute__ ((gcc_struct));
 513
 514 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 515
 516 struct TemplateArgument;
 517
 518 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 519
 520 struct TemplateParameter
 521 {
 522 struct TemplateParameter * prev;
 523 struct TemplateParameter * next;
 524 struct Location loc;
 525 int type;
 526 struct Identifier * identifier;
 527 union
 528 {
 529 struct TemplateDatatype * dataType;
 530 int memberType;
 531 } __attribute__ ((gcc_struct)) __anon1;
 532 struct TemplateArgument * defaultArgument;
 533 const char *  dataTypeString;
 534 struct Type * baseType;
 535 } __attribute__ ((gcc_struct));
 536
 537 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 538
 539 struct Specifier
 540 {
 541 struct Specifier * prev;
 542 struct Specifier * next;
 543 struct Location loc;
 544 int type;
 545 union
 546 {
 547 int specifier;
 548 struct
 549 {
 550 struct ExtDecl * extDecl;
 551 char *  name;
 552 struct Symbol * symbol;
 553 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 554 } __attribute__ ((gcc_struct)) __anon1;
 555 struct
 556 {
 557 struct Identifier * id;
 558 struct __ecereNameSpace__ecere__sys__OldList *  list;
 559 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 560 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 561 unsigned int addNameSpace;
 562 struct Context * ctx;
 563 struct ExtDecl * extDeclStruct;
 564 } __attribute__ ((gcc_struct)) __anon2;
 565 struct Expression * expression;
 566 struct Specifier * _class;
 567 struct TemplateParameter * templateParameter;
 568 } __attribute__ ((gcc_struct)) __anon1;
 569 } __attribute__ ((gcc_struct));
 570
 571 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 572
 573 struct Identifier
 574 {
 575 struct Identifier * prev;
 576 struct Identifier * next;
 577 struct Location loc;
 578 struct Symbol * classSym;
 579 struct Specifier * _class;
 580 char *  string;
 581 struct Identifier * badID;
 582 } __attribute__ ((gcc_struct));
 583
 584 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 585
 586 struct Pointer;
 587
 588 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 589
 590 struct Declarator
 591 {
 592 struct Declarator * prev;
 593 struct Declarator * next;
 594 struct Location loc;
 595 int type;
 596 struct Symbol * symbol;
 597 struct Declarator * declarator;
 598 union
 599 {
 600 struct Identifier * identifier;
 601 struct
 602 {
 603 struct Expression * exp;
 604 struct Expression * posExp;
 605 struct Attrib * attrib;
 606 } __attribute__ ((gcc_struct)) structDecl;
 607 struct
 608 {
 609 struct Expression * exp;
 610 struct Specifier * enumClass;
 611 } __attribute__ ((gcc_struct)) array;
 612 struct
 613 {
 614 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 615 } __attribute__ ((gcc_struct)) function;
 616 struct
 617 {
 618 struct Pointer * pointer;
 619 } __attribute__ ((gcc_struct)) pointer;
 620 struct
 621 {
 622 struct ExtDecl * extended;
 623 } __attribute__ ((gcc_struct)) extended;
 624 } __attribute__ ((gcc_struct)) __anon1;
 625 } __attribute__ ((gcc_struct));
 626
 627 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 628
 629 struct FunctionDefinition
 630 {
 631 struct FunctionDefinition * prev;
 632 struct FunctionDefinition * next;
 633 struct Location loc;
 634 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 635 struct Declarator * declarator;
 636 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 637 struct Statement * body;
 638 struct __ecereNameSpace__ecere__com__Class * _class;
 639 struct __ecereNameSpace__ecere__sys__OldList attached;
 640 int declMode;
 641 struct Type * type;
 642 struct Symbol * propSet;
 643 int tempCount;
 644 unsigned int propertyNoThis;
 645 } __attribute__ ((gcc_struct));
 646
 647 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 648
 649 struct DBTableDef;
 650
 651 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 652
 653 struct External
 654 {
 655 struct External * prev;
 656 struct External * next;
 657 struct Location loc;
 658 int type;
 659 struct Symbol * symbol;
 660 union
 661 {
 662 struct FunctionDefinition * function;
 663 struct ClassDefinition * _class;
 664 struct Declaration * declaration;
 665 char *  importString;
 666 struct Identifier * id;
 667 struct DBTableDef * table;
 668 } __attribute__ ((gcc_struct)) __anon1;
 669 int importType;
 670 } __attribute__ ((gcc_struct));
 671
 672 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 673
 674 struct ModuleImport
 675 {
 676 struct ModuleImport * prev;
 677 struct ModuleImport * next;
 678 char *  name;
 679 struct __ecereNameSpace__ecere__sys__OldList classes;
 680 struct __ecereNameSpace__ecere__sys__OldList functions;
 681 int importType;
 682 int importAccess;
 683 } __attribute__ ((gcc_struct));
 684
 685 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 686
 687 struct ClassImport
 688 {
 689 struct ClassImport * prev;
 690 struct ClassImport * next;
 691 char *  name;
 692 struct __ecereNameSpace__ecere__sys__OldList methods;
 693 struct __ecereNameSpace__ecere__sys__OldList properties;
 694 unsigned int itself;
 695 int isRemote;
 696 } __attribute__ ((gcc_struct));
 697
 698 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 699
 700 struct Symbol
 701 {
 702 char *  string;
 703 struct Symbol * parent;
 704 struct Symbol * left;
 705 struct Symbol * right;
 706 int depth;
 707 struct Type * type;
 708 union
 709 {
 710 struct __ecereNameSpace__ecere__com__Method * method;
 711 struct __ecereNameSpace__ecere__com__Property * _property;
 712 struct __ecereNameSpace__ecere__com__Class * registered;
 713 } __attribute__ ((gcc_struct)) __anon1;
 714 int id;
 715 int idCode;
 716 union
 717 {
 718 struct
 719 {
 720 struct External * pointerExternal;
 721 struct External * structExternal;
 722 } __attribute__ ((gcc_struct)) __anon1;
 723 struct
 724 {
 725 struct External * externalGet;
 726 struct External * externalSet;
 727 struct External * externalPtr;
 728 struct External * externalIsSet;
 729 } __attribute__ ((gcc_struct)) __anon2;
 730 struct
 731 {
 732 struct External * methodExternal;
 733 struct External * methodCodeExternal;
 734 } __attribute__ ((gcc_struct)) __anon3;
 735 } __attribute__ ((gcc_struct)) __anon2;
 736 unsigned int imported;
 737 unsigned int declaredStructSym;
 738 struct __ecereNameSpace__ecere__com__Class * _class;
 739 unsigned int declaredStruct;
 740 unsigned int needConstructor;
 741 unsigned int needDestructor;
 742 char *  constructorName;
 743 char *  structName;
 744 char *  className;
 745 char *  destructorName;
 746 struct ModuleImport * module;
 747 struct ClassImport * _import;
 748 struct Location nameLoc;
 749 unsigned int isParam;
 750 unsigned int isRemote;
 751 unsigned int isStruct;
 752 unsigned int fireWatchersDone;
 753 int declaring;
 754 unsigned int classData;
 755 unsigned int isStatic;
 756 char *  shortName;
 757 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 758 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 759 struct Context * ctx;
 760 int isIterator;
 761 struct Expression * propCategory;
 762 } __attribute__ ((gcc_struct));
 763
 764 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 765
 766 struct Type
 767 {
 768 struct Type * prev;
 769 struct Type * next;
 770 int refCount;
 771 union
 772 {
 773 struct Symbol * _class;
 774 struct
 775 {
 776 struct __ecereNameSpace__ecere__sys__OldList members;
 777 char *  enumName;
 778 } __attribute__ ((gcc_struct)) __anon1;
 779 struct
 780 {
 781 struct Type * returnType;
 782 struct __ecereNameSpace__ecere__sys__OldList params;
 783 struct Symbol * thisClass;
 784 unsigned int staticMethod;
 785 struct TemplateParameter * thisClassTemplate;
 786 } __attribute__ ((gcc_struct)) __anon2;
 787 struct
 788 {
 789 struct __ecereNameSpace__ecere__com__Method * method;
 790 struct __ecereNameSpace__ecere__com__Class * methodClass;
 791 struct __ecereNameSpace__ecere__com__Class * usedClass;
 792 } __attribute__ ((gcc_struct)) __anon3;
 793 struct
 794 {
 795 struct Type * arrayType;
 796 int arraySize;
 797 struct Expression * arraySizeExp;
 798 unsigned int freeExp;
 799 struct Symbol * enumClass;
 800 } __attribute__ ((gcc_struct)) __anon4;
 801 struct Type * type;
 802 struct TemplateParameter * templateParameter;
 803 } __attribute__ ((gcc_struct)) __anon1;
 804 int kind;
 805 unsigned int size;
 806 char *  name;
 807 char *  typeName;
 808 int classObjectType;
 809 int alignment;
 810 unsigned int offset;
 811 int bitFieldCount;
 812 int count;
 813 unsigned int isSigned : 1;
 814 unsigned int constant : 1;
 815 unsigned int truth : 1;
 816 unsigned int byReference : 1;
 817 unsigned int extraParam : 1;
 818 unsigned int directClassAccess : 1;
 819 unsigned int computing : 1;
 820 unsigned int keepCast : 1;
 821 unsigned int passAsTemplate : 1;
 822 unsigned int dllExport : 1;
 823 unsigned int attrStdcall : 1;
 824 unsigned int declaredWithStruct : 1;
 825 unsigned int typedByReference : 1;
 826 unsigned int casted : 1;
 827 } __attribute__ ((gcc_struct));
 828
 829 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 830
 831 struct __ecereNameSpace__ecere__com__Class
 832 {
 833 struct __ecereNameSpace__ecere__com__Class * prev;
 834 struct __ecereNameSpace__ecere__com__Class * next;
 835 const char *  name;
 836 int offset;
 837 int structSize;
 838 void * *  _vTbl;
 839 int vTblSize;
 840 unsigned int (*  Constructor)(void * );
 841 void (*  Destructor)(void * );
 842 int offsetClass;
 843 int sizeClass;
 844 struct __ecereNameSpace__ecere__com__Class * base;
 845 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 846 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 847 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 848 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 849 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 850 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 851 int memberID;
 852 int startMemberID;
 853 int type;
 854 struct __ecereNameSpace__ecere__com__Instance * module;
 855 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 856 const char *  dataTypeString;
 857 struct Type * dataType;
 858 int typeSize;
 859 int defaultAlignment;
 860 void (*  Initialize)();
 861 int memberOffset;
 862 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 863 const char *  designerClass;
 864 unsigned int noExpansion;
 865 const char *  defaultProperty;
 866 unsigned int comRedefinition;
 867 int count;
 868 int isRemote;
 869 unsigned int internalDecl;
 870 void *  data;
 871 unsigned int computeSize;
 872 int structAlignment;
 873 int destructionWatchOffset;
 874 unsigned int fixed;
 875 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 876 int inheritanceAccess;
 877 const char *  fullName;
 878 void *  symbol;
 879 struct __ecereNameSpace__ecere__sys__OldList conversions;
 880 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 881 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 882 struct __ecereNameSpace__ecere__com__Class * templateClass;
 883 struct __ecereNameSpace__ecere__sys__OldList templatized;
 884 int numParams;
 885 unsigned int isInstanceClass;
 886 unsigned int byValueSystemClass;
 887 } __attribute__ ((gcc_struct));
 888
 889 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 890
 891 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 892
 893 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 894
 895 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 896
 897 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 898
 899 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);
 900
 901 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 902
 903 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 904
 905 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 906
 907 struct __ecereNameSpace__ecere__com__Instance
 908 {
 909 void * *  _vTbl;
 910 struct __ecereNameSpace__ecere__com__Class * _class;
 911 int _refCount;
 912 } __attribute__ ((gcc_struct));
 913
 914 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 915
 916 struct __ecereNameSpace__ecere__com__DataMember
 917 {
 918 struct __ecereNameSpace__ecere__com__DataMember * prev;
 919 struct __ecereNameSpace__ecere__com__DataMember * next;
 920 const char *  name;
 921 unsigned int isProperty;
 922 int memberAccess;
 923 int id;
 924 struct __ecereNameSpace__ecere__com__Class * _class;
 925 const char *  dataTypeString;
 926 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 927 struct Type * dataType;
 928 int type;
 929 int offset;
 930 int memberID;
 931 struct __ecereNameSpace__ecere__sys__OldList members;
 932 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 933 int memberOffset;
 934 int structAlignment;
 935 } __attribute__ ((gcc_struct));
 936
 937 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 938
 939 struct __ecereNameSpace__ecere__com__SerialBuffer
 940 {
 941 unsigned char *  _buffer;
 942 unsigned int count;
 943 unsigned int _size;
 944 unsigned int pos;
 945 } __attribute__ ((gcc_struct));
 946
 947 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 948
 949 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 950 {
 951 union
 952 {
 953 struct
 954 {
 955 const char *  dataTypeString;
 956 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 957 } __attribute__ ((gcc_struct)) __anon1;
 958 struct __ecereNameSpace__ecere__com__DataValue expression;
 959 struct
 960 {
 961 const char *  memberString;
 962 union
 963 {
 964 struct __ecereNameSpace__ecere__com__DataMember * member;
 965 struct __ecereNameSpace__ecere__com__Property * prop;
 966 struct __ecereNameSpace__ecere__com__Method * method;
 967 } __attribute__ ((gcc_struct)) __anon1;
 968 } __attribute__ ((gcc_struct)) __anon2;
 969 } __attribute__ ((gcc_struct)) __anon1;
 970 } __attribute__ ((gcc_struct));
 971
 972 void exit(int status);
 973
 974 void * calloc(size_t nmemb, size_t size);
 975
 976 void free(void * ptr);
 977
 978 void * malloc(size_t size);
 979
 980 void * realloc(void * ptr, size_t size);
 981
 982 long int strtol(const char * nptr, char ** endptr, int base);
 983
 984 long long int strtoll(const char * nptr, char ** endptr, int base);
 985
 986 unsigned long long int strtoull(const char * nptr, char ** endptr, int base);
 987
 988 enum yytokentype
 989 {
 990 IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, LONG = 294, SIGNED = 295, UNSIGNED = 296, FLOAT = 297, DOUBLE = 298, CONST = 299, VOLATILE = 300, VOID = 301, VALIST = 302, STRUCT = 303, UNION = 304, ENUM = 305, ELLIPSIS = 306, CASE = 307, DEFAULT = 308, IF = 309, SWITCH = 310, WHILE = 311, DO = 312, FOR = 313, GOTO = 314, CONTINUE = 315, BREAK = 316, RETURN = 317, IFX = 318, ELSE = 319, CLASS = 320, THISCLASS = 321, CLASS_NAME = 322, PROPERTY = 323, SETPROP = 324, GETPROP = 325, NEWOP = 326, RENEW = 327, DELETE = 328, EXT_DECL = 329, EXT_STORAGE = 330, IMPORT = 331, DEFINE = 332, VIRTUAL = 333, ATTRIB = 334, PUBLIC = 335, PRIVATE = 336, TYPED_OBJECT = 337, ANY_OBJECT = 338, _INCREF = 339, EXTENSION = 340, ASM = 341, TYPEOF = 342, WATCH = 343, STOPWATCHING = 344, FIREWATCHERS = 345, WATCHABLE = 346, CLASS_DESIGNER = 347, CLASS_NO_EXPANSION = 348, CLASS_FIXED = 349, ISPROPSET = 350, CLASS_DEFAULT_PROPERTY = 351, PROPERTY_CATEGORY = 352, CLASS_DATA = 353, CLASS_PROPERTY = 354, SUBCLASS = 355, NAMESPACE = 356, NEW0OP = 357, RENEW0 = 358, VAARG = 359, DBTABLE = 360, DBFIELD = 361, DBINDEX = 362, DATABASE_OPEN = 363, ALIGNOF = 364, ATTRIB_DEP = 365, __ATTRIB = 366, BOOL = 367, _BOOL = 368, _COMPLEX = 369, _IMAGINARY = 370, RESTRICT = 371, THREAD = 372, WIDE_STRING_LITERAL = 373
 991 };
 992
 993 typedef union YYSTYPE
 994 {
 995 int specifierType;
 996 int i;
 997 int declMode;
 998 struct Identifier * id;
 999 struct Expression * exp;
1000 struct Specifier * specifier;
1001 struct __ecereNameSpace__ecere__sys__OldList * list;
1002 struct Enumerator * enumerator;
1003 struct Declarator * declarator;
1004 struct Pointer * pointer;
1005 struct Initializer * initializer;
1006 struct InitDeclarator * initDeclarator;
1007 struct TypeName * typeName;
1008 struct Declaration * declaration;
1009 struct Statement * stmt;
1010 struct FunctionDefinition * function;
1011 struct External * external;
1012 struct Context * context;
1013 struct AsmField * asmField;
1014 struct Attrib * attrib;
1015 struct ExtDecl * extDecl;
1016 struct Attribute * attribute;
1017 struct Instantiation * instance;
1018 struct MembersInit * membersInit;
1019 struct MemberInit * memberInit;
1020 struct ClassFunction * classFunction;
1021 struct ClassDefinition * _class;
1022 struct ClassDef * classDef;
1023 struct PropertyDef * prop;
1024 char * string;
1025 struct Symbol * symbol;
1026 struct PropertyWatch * propertyWatch;
1027 struct TemplateParameter * templateParameter;
1028 struct TemplateArgument * templateArgument;
1029 struct TemplateDatatype * templateDatatype;
1030 struct DBTableEntry * dbtableEntry;
1031 struct DBIndexItem * dbindexItem;
1032 struct DBTableDef * dbtableDef;
1033 } __attribute__ ((gcc_struct)) YYSTYPE;
1034
1035 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
1036
1037 struct Enumerator
1038 {
1039 struct Enumerator * prev;
1040 struct Enumerator * next;
1041 struct Location loc;
1042 struct Identifier * id;
1043 struct Expression * exp;
1044 } __attribute__ ((gcc_struct));
1045
1046 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
1047
1048 struct InitDeclarator
1049 {
1050 struct InitDeclarator * prev;
1051 struct InitDeclarator * next;
1052 struct Location loc;
1053 struct Declarator * declarator;
1054 struct Initializer * initializer;
1055 } __attribute__ ((gcc_struct));
1056
1057 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
1058
1059 struct AsmField
1060 {
1061 struct AsmField * prev;
1062 struct AsmField * next;
1063 struct Location loc;
1064 char *  command;
1065 struct Expression * expression;
1066 struct Identifier * symbolic;
1067 } __attribute__ ((gcc_struct));
1068
1069 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
1070
1071 struct Attribute;
1072
1073 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
1074
1075 struct ClassFunction
1076 {
1077 struct ClassFunction * prev;
1078 struct ClassFunction * next;
1079 struct Location loc;
1080 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1081 struct Declarator * declarator;
1082 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
1083 struct Statement * body;
1084 struct __ecereNameSpace__ecere__com__Class * _class;
1085 struct __ecereNameSpace__ecere__sys__OldList attached;
1086 int declMode;
1087 struct Type * type;
1088 struct Symbol * propSet;
1089 unsigned int isVirtual;
1090 unsigned int isConstructor;
1091 unsigned int isDestructor;
1092 unsigned int dontMangle;
1093 int id;
1094 int idCode;
1095 } __attribute__ ((gcc_struct));
1096
1097 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
1098
1099 struct MembersInit
1100 {
1101 struct MembersInit * prev;
1102 struct MembersInit * next;
1103 struct Location loc;
1104 int type;
1105 union
1106 {
1107 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
1108 struct ClassFunction * function;
1109 } __attribute__ ((gcc_struct)) __anon1;
1110 } __attribute__ ((gcc_struct));
1111
1112 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
1113
1114 struct MemberInit
1115 {
1116 struct MemberInit * prev;
1117 struct MemberInit * next;
1118 struct Location loc;
1119 struct Location realLoc;
1120 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
1121 struct Initializer * initializer;
1122 unsigned int used;
1123 unsigned int variable;
1124 unsigned int takeOutExp;
1125 } __attribute__ ((gcc_struct));
1126
1127 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
1128
1129 struct PropertyDef
1130 {
1131 struct PropertyDef * prev;
1132 struct PropertyDef * next;
1133 struct Location loc;
1134 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1135 struct Declarator * declarator;
1136 struct Identifier * id;
1137 struct Statement * getStmt;
1138 struct Statement * setStmt;
1139 struct Statement * issetStmt;
1140 struct Symbol * symbol;
1141 struct Expression * category;
1142 struct
1143 {
1144 unsigned int conversion : 1;
1145 unsigned int isWatchable : 1;
1146 unsigned int isDBProp : 1;
1147 } __attribute__ ((gcc_struct)) __anon1;
1148 } __attribute__ ((gcc_struct));
1149
1150 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1151
1152 struct PropertyWatch
1153 {
1154 struct PropertyWatch * prev;
1155 struct PropertyWatch * next;
1156 struct Location loc;
1157 struct Statement * compound;
1158 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1159 unsigned int deleteWatch;
1160 } __attribute__ ((gcc_struct));
1161
1162 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1163
1164 struct ClassDef
1165 {
1166 struct ClassDef * prev;
1167 struct ClassDef * next;
1168 struct Location loc;
1169 int type;
1170 union
1171 {
1172 struct Declaration * decl;
1173 struct ClassFunction * function;
1174 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1175 struct PropertyDef * propertyDef;
1176 struct PropertyWatch * propertyWatch;
1177 char *  designer;
1178 struct Identifier * defaultProperty;
1179 struct
1180 {
1181 struct Identifier * id;
1182 struct Initializer * initializer;
1183 } __attribute__ ((gcc_struct)) __anon1;
1184 } __attribute__ ((gcc_struct)) __anon1;
1185 int memberAccess;
1186 void *  object;
1187 } __attribute__ ((gcc_struct));
1188
1189 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1190
1191 struct DBTableEntry;
1192
1193 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1194
1195 struct DBIndexItem;
1196
1197 extern YYSTYPE yylval;
1198
1199 extern struct Location yylloc;
1200
1201 extern struct __ecereNameSpace__ecere__sys__OldList * ast;
1202
1203 extern int returnCode;
1204
1205 extern struct Expression * parsedExpression;
1206
1207 extern unsigned int yydebug;
1208
1209 void SetYydebug(unsigned int b)
1210 {
1211 yydebug = b;
1212 }
1213
1214 extern unsigned int echoOn;
1215
1216 void resetScanner();
1217
1218 int propWatcherID;
1219
1220 int expression_yyparse();
1221
1222 static struct Statement * curCompound;
1223
1224 struct External * curExternal, * afterExternal;
1225
1226 static struct Type * curSwitchType;
1227
1228 static struct __ecereNameSpace__ecere__com__Class * currentClass;
1229
1230 struct __ecereNameSpace__ecere__com__Class * thisClass;
1231
1232 void SetThisClass(struct __ecereNameSpace__ecere__com__Class * c)
1233 {
1234 thisClass = c;
1235 }
1236
1237 struct __ecereNameSpace__ecere__com__Class * GetThisClass()
1238 {
1239 return thisClass;
1240 }
1241
1242 static char * thisNameSpace;
1243
1244 struct __ecereNameSpace__ecere__com__Class * containerClass;
1245
1246 unsigned int thisClassParams = 1;
1247
1248 unsigned int internalValueCounter;
1249
1250 extern unsigned int outputLineNumbers;
1251
1252 extern void OutputExpression(struct Expression * exp, struct __ecereNameSpace__ecere__com__Instance * f);
1253
1254 extern size_t strlen(const char * );
1255
1256 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__TempFile;
1257
1258 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1259
1260 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek;
1261
1262 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Read;
1263
1264 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
1265
1266 void PrintExpression(struct Expression * exp, char * string)
1267 {
1268 {
1269 struct __ecereNameSpace__ecere__com__Instance * f = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
1270 int count;
1271 unsigned int backOutputLineNumbers = outputLineNumbers;
1272
1273 outputLineNumbers = 0;
1274 if(exp)
1275 OutputExpression(exp, f);
1276 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))__extension__ ({
1277 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = f;
1278
1279 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__TempFile->_vTbl;
1280 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek])(f, 0, 0);
1281 count = strlen(string);
1282 count += ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  buffer, unsigned int size, unsigned int count))__extension__ ({
1283 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = f;
1284
1285 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__TempFile->_vTbl;
1286 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Read])(f, string + count, 1, 1023);
1287 string[count] = '\0';
1288 (__ecereNameSpace__ecere__com__eInstance_DecRef(f), f = 0);
1289 outputLineNumbers = backOutputLineNumbers;
1290 }
1291 }
1292
1293 extern struct Type * ProcessTypeString(const char *  string, unsigned int staticMethod);
1294
1295 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1296
1297 struct Type * ProcessTemplateParameterType(struct TemplateParameter * param)
1298 {
1299 if(param && param->type == 0 && (param->__anon1.dataType || param->dataTypeString))
1300 {
1301 if(!param->baseType)
1302 {
1303 if(param->dataTypeString)
1304 param->baseType = ProcessTypeString(param->dataTypeString, 0);
1305 else
1306 param->baseType = ProcessType(param->__anon1.dataType->specifiers, param->__anon1.dataType->decl);
1307 }
1308 return param->baseType;
1309 }
1310 return (((void *)0));
1311 }
1312
1313 unsigned int NeedCast(struct Type * type1, struct Type * type2)
1314 {
1315 if(!type1 || !type2 || type1->keepCast || type2->keepCast)
1316 return 1;
1317 if(type1->kind == 20 && type2->kind == 4 && type2->passAsTemplate == 0)
1318 {
1319 return 0;
1320 }
1321 if(type1->kind == type2->kind)
1322 {
1323 switch(type1->kind)
1324 {
1325 case 24:
1326 case 1:
1327 case 2:
1328 case 3:
1329 case 4:
1330 case 22:
1331 case 23:
1332 if(type1->passAsTemplate && !type2->passAsTemplate)
1333 return 1;
1334 return type1->isSigned != type2->isSigned;
1335 case 8:
1336 return type1->__anon1._class != type2->__anon1._class;
1337 case 13:
1338 return (type1->__anon1.type && type2->__anon1.type && type1->__anon1.type->constant != type2->__anon1.type->constant) || NeedCast(type1->__anon1.type, type2->__anon1.type);
1339 default:
1340 return 1;
1341 }
1342 }
1343 return 1;
1344 }
1345
1346 extern int strcmp(const char * , const char * );
1347
1348 extern struct Context * curContext;
1349
1350 extern struct Context * topContext;
1351
1352 extern unsigned int __ecereNameSpace__ecere__com__eClass_IsDerived(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from);
1353
1354 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1355
1356 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1357
1358 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1359
1360 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1361
1362 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1363
1364 struct __ecereNameSpace__ecere__com__ClassProperty
1365 {
1366 const char *  name;
1367 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1368 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1369 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1370 int depth;
1371 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1372 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1373 const char *  dataTypeString;
1374 struct Type * dataType;
1375 unsigned int constant;
1376 } __attribute__ ((gcc_struct));
1377
1378 extern struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_FindClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
1379
1380 extern struct Expression * QMkExpId(const char *  id);
1381
1382 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter;
1383
1384 struct __ecereNameSpace__ecere__com__ClassTemplateParameter
1385 {
1386 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * prev;
1387 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * next;
1388 const char *  name;
1389 int type;
1390 union
1391 {
1392 const char *  dataTypeString;
1393 int memberType;
1394 } __attribute__ ((gcc_struct)) __anon1;
1395 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg;
1396 void *  param;
1397 } __attribute__ ((gcc_struct));
1398
1399 extern struct Expression * GetTemplateArgExpByName(const char *  paramName, struct __ecereNameSpace__ecere__com__Class * curClass, int tplType);
1400
1401 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1402
1403 extern void FreeIdentifier(struct Identifier * id);
1404
1405 void ProcessExpressionType(struct Expression * exp);
1406
1407 extern struct Declarator * SpecDeclFromString(const char *  string, struct __ecereNameSpace__ecere__sys__OldList *  specs, struct Declarator * baseDecl);
1408
1409 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1410
1411 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1412
1413 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1414
1415 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1416
1417 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1418
1419 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1420
1421 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, const char *  key);
1422
1423 static void ReplaceClassMembers(struct Expression * exp, struct __ecereNameSpace__ecere__com__Class * _class)
1424 {
1425 if(exp->type == 0 && exp->__anon1.__anon1.identifier)
1426 {
1427 struct Identifier * id = exp->__anon1.__anon1.identifier;
1428 struct Context * ctx;
1429 struct Symbol * symbol = (((void *)0));
1430
1431 if(!id->_class || !id->_class->__anon1.__anon1.name || strcmp(id->_class->__anon1.__anon1.name, "property"))
1432 {
1433 for(ctx = curContext; ctx != topContext->parent && !symbol; ctx = ctx->parent)
1434 {
1435 symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&ctx->symbols, id->string);
1436 if(symbol)
1437 break;
1438 }
1439 }
1440 if(!symbol && ((!id->_class || (id->_class->__anon1.__anon1.name && !strcmp(id->_class->__anon1.__anon1.name, "property"))) || (id->classSym && __ecereNameSpace__ecere__com__eClass_IsDerived(_class, id->classSym->__anon1.registered))))
1441 {
1442 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, privateModule);
1443 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
1444 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
1445 struct __ecereNameSpace__ecere__com__ClassProperty * classProp = (((void *)0));
1446
1447 if(!prop)
1448 {
1449 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, id->string, privateModule);
1450 }
1451 if(!prop && !method)
1452 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, id->string, privateModule, (((void *)0)), (((void *)0)));
1453 if(!prop && !method && !member)
1454 {
1455 classProp = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, id->string);
1456 }
1457 if(prop || method || member || classProp)
1458 {
1459 exp->type = 8;
1460 exp->__anon1.member.member = id;
1461 exp->__anon1.member.memberType = 0;
1462 exp->__anon1.member.exp = QMkExpId("this");
1463 exp->addedThis = 1;
1464 }
1465 else if(_class && _class->templateParams.first)
1466 {
1467 struct __ecereNameSpace__ecere__com__Class * sClass;
1468
1469 for(sClass = _class; sClass; sClass = sClass->base)
1470 {
1471 if(sClass->templateParams.first)
1472 {
1473 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
1474
1475 for(param = sClass->templateParams.first; param; param = param->next)
1476 {
1477 if(param->type == 2 && !strcmp(param->name, id->string))
1478 {
1479 struct Expression * argExp = GetTemplateArgExpByName(param->name, _class, 2);
1480
1481 if(argExp)
1482 {
1483 struct Declarator * decl;
1484 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1485
1486 FreeIdentifier(exp->__anon1.member.member);
1487 ProcessExpressionType(argExp);
1488 decl = SpecDeclFromString(param->__anon1.dataTypeString, specs, (((void *)0)));
1489 exp->expType = ProcessType(specs, decl);
1490 exp->type = 5;
1491 exp->__anon1.list = MkListOne(MkExpOp((((void *)0)), '*', MkExpCast(MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl)), MkExpOp((((void *)0)), '&', argExp))));
1492 }
1493 }
1494 }
1495 }
1496 }
1497 }
1498 }
1499 }
1500 }
1501
1502 extern int sprintf(char * , const char * , ...);
1503
1504 extern char *  strcat(char * , const char * );
1505
1506 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
1507
1508 char * PrintInt(long long result)
1509 {
1510 char temp[100];
1511
1512 if(result > (((int)0x7fffffff)))
1513 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1514 else
1515 sprintf(temp, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), result);
1516 if(result > (((int)0x7fffffff)) || result < (((int)0x80000000)))
1517 strcat(temp, "LL");
1518 return __ecereNameSpace__ecere__sys__CopyString(temp);
1519 }
1520
1521 char * PrintUInt(uint64 result)
1522 {
1523 char temp[100];
1524
1525 if(result > (0xffffffff))
1526 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64XLL" : "0x%llXLL"), result);
1527 else if(result > (((int)0x7fffffff)))
1528 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1529 else
1530 sprintf(temp, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), result);
1531 return __ecereNameSpace__ecere__sys__CopyString(temp);
1532 }
1533
1534 char * PrintInt64(long long result)
1535 {
1536 char temp[100];
1537
1538 if(result > (((int)0x7fffffff)) || result < (((int)0x80000000)))
1539 sprintf(temp, ((__runtimePlatform == 1) ? "%I64dLL" : "%lldLL"), result);
1540 else
1541 sprintf(temp, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), result);
1542 return __ecereNameSpace__ecere__sys__CopyString(temp);
1543 }
1544
1545 char * PrintUInt64(uint64 result)
1546 {
1547 char temp[100];
1548
1549 if(result > (0xffffffff))
1550 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64XLL" : "0x%llXLL"), result);
1551 else if(result > (((int)0x7fffffff)))
1552 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1553 else
1554 sprintf(temp, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), result);
1555 return __ecereNameSpace__ecere__sys__CopyString(temp);
1556 }
1557
1558 char * PrintHexUInt(uint64 result)
1559 {
1560 char temp[100];
1561
1562 if(result > (0xffffffff))
1563 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1564 else
1565 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1566 if(result > (0xffffffff))
1567 strcat(temp, "LL");
1568 return __ecereNameSpace__ecere__sys__CopyString(temp);
1569 }
1570
1571 char * PrintHexUInt64(uint64 result)
1572 {
1573 char temp[100];
1574
1575 if(result > (0xffffffff))
1576 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64XLL" : "0x%llXLL"), result);
1577 else
1578 sprintf(temp, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), result);
1579 return __ecereNameSpace__ecere__sys__CopyString(temp);
1580 }
1581
1582 char * PrintShort(short result)
1583 {
1584 char temp[100];
1585
1586 sprintf(temp, "%d", (unsigned short)result);
1587 return __ecereNameSpace__ecere__sys__CopyString(temp);
1588 }
1589
1590 char * PrintUShort(unsigned short result)
1591 {
1592 char temp[100];
1593
1594 if(result > (unsigned short)32767)
1595 sprintf(temp, "0x%X", (int)result);
1596 else
1597 sprintf(temp, "%d", (int)result);
1598 return __ecereNameSpace__ecere__sys__CopyString(temp);
1599 }
1600
1601 extern int isprint(int c);
1602
1603 char * PrintChar(char result)
1604 {
1605 char temp[100];
1606
1607 if(result > (char)0 && isprint(result))
1608 sprintf(temp, "'%c'", result);
1609 else if(result < (char)0)
1610 sprintf(temp, "%d", (int)result);
1611 else
1612 sprintf(temp, "0x%X", (unsigned char)result);
1613 return __ecereNameSpace__ecere__sys__CopyString(temp);
1614 }
1615
1616 char * PrintUChar(unsigned char result)
1617 {
1618 char temp[100];
1619
1620 sprintf(temp, "0x%X", result);
1621 return __ecereNameSpace__ecere__sys__CopyString(temp);
1622 }
1623
1624 extern char *  strcpy(char * , const char * );
1625
1626 extern unsigned int (* __ecereProp_float_Get_isInf)(float this);
1627
1628 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_isInf;
1629
1630 extern int (* __ecereProp_float_Get_signBit)(float this);
1631
1632 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_signBit;
1633
1634 extern unsigned int (* __ecereProp_float_Get_isNan)(float this);
1635
1636 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_isNan;
1637
1638 char * PrintFloat(float result)
1639 {
1640 char temp[350];
1641
1642 if(__ecereProp_float_Get_isInf(result))
1643 {
1644 if(__ecereProp_float_Get_signBit(result))
1645 strcpy(temp, "-inf");
1646 else
1647 strcpy(temp, "inf");
1648 }
1649 else if(__ecereProp_float_Get_isNan(result))
1650 {
1651 if(__ecereProp_float_Get_signBit(result))
1652 strcpy(temp, "-nan");
1653 else
1654 strcpy(temp, "nan");
1655 }
1656 else
1657 sprintf(temp, "%.16ff", result);
1658 return __ecereNameSpace__ecere__sys__CopyString(temp);
1659 }
1660
1661 extern unsigned int (* __ecereProp_double_Get_isInf)(double this);
1662
1663 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_isInf;
1664
1665 extern int (* __ecereProp_double_Get_signBit)(double this);
1666
1667 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_signBit;
1668
1669 extern unsigned int (* __ecereProp_double_Get_isNan)(double this);
1670
1671 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_isNan;
1672
1673 char * PrintDouble(double result)
1674 {
1675 char temp[350];
1676
1677 if(__ecereProp_double_Get_isInf(result))
1678 {
1679 if(__ecereProp_double_Get_signBit(result))
1680 strcpy(temp, "-inf");
1681 else
1682 strcpy(temp, "inf");
1683 }
1684 else if(__ecereProp_double_Get_isNan(result))
1685 {
1686 if(__ecereProp_double_Get_signBit(result))
1687 strcpy(temp, "-nan");
1688 else
1689 strcpy(temp, "nan");
1690 }
1691 else
1692 sprintf(temp, "%.16f", result);
1693 return __ecereNameSpace__ecere__sys__CopyString(temp);
1694 }
1695
1696 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
1697
1698 struct OpTable
1699 {
1700 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1701 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1702 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1703 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1704 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1705 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1706 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1707 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1708 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1709 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1710 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1711 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1712 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1713 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1714 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
1715 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
1716 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
1717 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
1718 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
1719 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
1720 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
1721 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
1722 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
1723 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1724 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1725 unsigned int (*  Not)(struct Expression *, struct Operand *);
1726 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
1727 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
1728 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
1729 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
1730 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
1731 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
1732 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
1733 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
1734 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
1735 } __attribute__ ((gcc_struct));
1736
1737 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
1738
1739 struct Operand
1740 {
1741 int kind;
1742 struct Type * type;
1743 unsigned int ptrSize;
1744 union
1745 {
1746 char c;
1747 unsigned char uc;
1748 short s;
1749 unsigned short us;
1750 int i;
1751 unsigned int ui;
1752 float f;
1753 double d;
1754 long long i64;
1755 uint64 ui64;
1756 } __attribute__ ((gcc_struct)) __anon1;
1757 struct OpTable ops;
1758 } __attribute__ ((gcc_struct));
1759
1760 unsigned int GetOpInt(struct Operand * op2, int * value2)
1761 {
1762 if(op2->kind == 3 && op2->type->isSigned)
1763 *value2 = op2->__anon1.i;
1764 else if(op2->kind == 3)
1765 *value2 = (int)op2->__anon1.ui;
1766 else if(op2->kind == 4 && op2->type->isSigned)
1767 *value2 = (int)op2->__anon1.i64;
1768 else if(op2->kind == 4)
1769 *value2 = (int)op2->__anon1.ui64;
1770 else if(op2->kind == 23 && op2->type->isSigned)
1771 *value2 = (int)op2->__anon1.i64;
1772 else if(op2->kind == 23)
1773 *value2 = (int)op2->__anon1.ui64;
1774 else if(op2->kind == 22 && op2->type->isSigned)
1775 *value2 = (int)op2->__anon1.i64;
1776 else if(op2->kind == 22)
1777 *value2 = (int)op2->__anon1.ui64;
1778 else if(op2->kind == 2 && op2->type->isSigned)
1779 *value2 = (int)op2->__anon1.s;
1780 else if(op2->kind == 2)
1781 *value2 = (int)op2->__anon1.us;
1782 else if(op2->kind == 1 && op2->type->isSigned)
1783 *value2 = (int)op2->__anon1.c;
1784 else if(op2->kind == 24 || op2->kind == 1)
1785 *value2 = (int)op2->__anon1.uc;
1786 else if(op2->kind == 6)
1787 *value2 = (int)op2->__anon1.f;
1788 else if(op2->kind == 7)
1789 *value2 = (int)op2->__anon1.d;
1790 else if(op2->kind == 13)
1791 *value2 = (int)op2->__anon1.ui64;
1792 else
1793 return 0;
1794 return 1;
1795 }
1796
1797 struct Operand GetOperand(struct Expression * exp);
1798
1799 unsigned int GetInt(struct Expression * exp, int * value2)
1800 {
1801 struct Operand op2 = GetOperand(exp);
1802
1803 return GetOpInt(&op2, value2);
1804 }
1805
1806 unsigned int GetOpUInt(struct Operand * op2, unsigned int * value2)
1807 {
1808 if(op2->kind == 3 && op2->type->isSigned)
1809 *value2 = (unsigned int)op2->__anon1.i;
1810 else if(op2->kind == 3)
1811 *value2 = op2->__anon1.ui;
1812 else if(op2->kind == 4 && op2->type->isSigned)
1813 *value2 = (unsigned int)op2->__anon1.i64;
1814 else if(op2->kind == 4)
1815 *value2 = (unsigned int)op2->__anon1.ui64;
1816 else if(op2->kind == 23 && op2->type->isSigned)
1817 *value2 = (unsigned int)op2->__anon1.i64;
1818 else if(op2->kind == 23)
1819 *value2 = (unsigned int)op2->__anon1.ui64;
1820 else if(op2->kind == 22 && op2->type->isSigned)
1821 *value2 = (unsigned int)op2->__anon1.i64;
1822 else if(op2->kind == 22)
1823 *value2 = (unsigned int)op2->__anon1.ui64;
1824 else if(op2->kind == 2 && op2->type->isSigned)
1825 *value2 = (unsigned int)op2->__anon1.s;
1826 else if(op2->kind == 2)
1827 *value2 = (unsigned int)op2->__anon1.us;
1828 else if(op2->kind == 1 && op2->type->isSigned)
1829 *value2 = (unsigned int)op2->__anon1.c;
1830 else if(op2->kind == 24 || op2->kind == 1)
1831 *value2 = (unsigned int)op2->__anon1.uc;
1832 else if(op2->kind == 6)
1833 *value2 = (unsigned int)op2->__anon1.f;
1834 else if(op2->kind == 7)
1835 *value2 = (unsigned int)op2->__anon1.d;
1836 else if(op2->kind == 13)
1837 *value2 = (unsigned int)op2->__anon1.ui64;
1838 else
1839 return 0;
1840 return 1;
1841 }
1842
1843 unsigned int GetUInt(struct Expression * exp, unsigned int * value2)
1844 {
1845 struct Operand op2 = GetOperand(exp);
1846
1847 return GetOpUInt(&op2, value2);
1848 }
1849
1850 unsigned int GetOpInt64(struct Operand * op2, long long * value2)
1851 {
1852 if(op2->kind == 3 && op2->type->isSigned)
1853 *value2 = (long long)op2->__anon1.i;
1854 else if(op2->kind == 3)
1855 *value2 = (long long)op2->__anon1.ui;
1856 else if(op2->kind == 4 && op2->type->isSigned)
1857 *value2 = op2->__anon1.i64;
1858 else if(op2->kind == 4)
1859 *value2 = (long long)op2->__anon1.ui64;
1860 else if(op2->kind == 23 && op2->type->isSigned)
1861 *value2 = op2->__anon1.i64;
1862 else if(op2->kind == 23)
1863 *value2 = (long long)op2->__anon1.ui64;
1864 else if(op2->kind == 22 && op2->type->isSigned)
1865 *value2 = op2->__anon1.i64;
1866 else if(op2->kind == 22)
1867 *value2 = (long long)op2->__anon1.ui64;
1868 else if(op2->kind == 2 && op2->type->isSigned)
1869 *value2 = (long long)op2->__anon1.s;
1870 else if(op2->kind == 2)
1871 *value2 = (long long)op2->__anon1.us;
1872 else if(op2->kind == 1 && op2->type->isSigned)
1873 *value2 = (long long)op2->__anon1.c;
1874 else if(op2->kind == 24 || op2->kind == 1)
1875 *value2 = (long long)op2->__anon1.uc;
1876 else if(op2->kind == 6)
1877 *value2 = (long long)op2->__anon1.f;
1878 else if(op2->kind == 7)
1879 *value2 = (long long)op2->__anon1.d;
1880 else if(op2->kind == 13)
1881 *value2 = (long long)op2->__anon1.ui64;
1882 else
1883 return 0;
1884 return 1;
1885 }
1886
1887 unsigned int GetInt64(struct Expression * exp, long long * value2)
1888 {
1889 struct Operand op2 = GetOperand(exp);
1890
1891 return GetOpInt64(&op2, value2);
1892 }
1893
1894 unsigned int GetOpUInt64(struct Operand * op2, uint64 * value2)
1895 {
1896 if(op2->kind == 3 && op2->type->isSigned)
1897 *value2 = (uint64)op2->__anon1.i;
1898 else if(op2->kind == 3)
1899 *value2 = (uint64)op2->__anon1.ui;
1900 else if(op2->kind == 4 && op2->type->isSigned)
1901 *value2 = (uint64)op2->__anon1.i64;
1902 else if(op2->kind == 4)
1903 *value2 = op2->__anon1.ui64;
1904 else if(op2->kind == 23 && op2->type->isSigned)
1905 *value2 = (uint64)op2->__anon1.i64;
1906 else if(op2->kind == 23)
1907 *value2 = op2->__anon1.ui64;
1908 else if(op2->kind == 22 && op2->type->isSigned)
1909 *value2 = (uint64)op2->__anon1.i64;
1910 else if(op2->kind == 22)
1911 *value2 = op2->__anon1.ui64;
1912 else if(op2->kind == 2 && op2->type->isSigned)
1913 *value2 = (uint64)op2->__anon1.s;
1914 else if(op2->kind == 2)
1915 *value2 = (uint64)op2->__anon1.us;
1916 else if(op2->kind == 1 && op2->type->isSigned)
1917 *value2 = (uint64)op2->__anon1.c;
1918 else if(op2->kind == 24 || op2->kind == 1)
1919 *value2 = (uint64)op2->__anon1.uc;
1920 else if(op2->kind == 6)
1921 *value2 = (uint64)op2->__anon1.f;
1922 else if(op2->kind == 7)
1923 *value2 = (uint64)op2->__anon1.d;
1924 else if(op2->kind == 13)
1925 *value2 = op2->__anon1.ui64;
1926 else
1927 return 0;
1928 return 1;
1929 }
1930
1931 unsigned int GetUInt64(struct Expression * exp, uint64 * value2)
1932 {
1933 struct Operand op2 = GetOperand(exp);
1934
1935 return GetOpUInt64(&op2, value2);
1936 }
1937
1938 unsigned int GetOpIntPtr(struct Operand * op2, intptr_t * value2)
1939 {
1940 if(op2->kind == 3 && op2->type->isSigned)
1941 *value2 = (intptr_t)op2->__anon1.i;
1942 else if(op2->kind == 3)
1943 *value2 = (intptr_t)op2->__anon1.ui;
1944 else if(op2->kind == 4 && op2->type->isSigned)
1945 *value2 = (intptr_t)op2->__anon1.i64;
1946 else if(op2->kind == 4)
1947 *value2 = (intptr_t)op2->__anon1.ui64;
1948 else if(op2->kind == 23 && op2->type->isSigned)
1949 *value2 = (intptr_t)op2->__anon1.i64;
1950 else if(op2->kind == 23)
1951 *value2 = (intptr_t)op2->__anon1.ui64;
1952 else if(op2->kind == 22 && op2->type->isSigned)
1953 *value2 = (intptr_t)op2->__anon1.i64;
1954 else if(op2->kind == 22)
1955 *value2 = (intptr_t)op2->__anon1.ui64;
1956 else if(op2->kind == 2 && op2->type->isSigned)
1957 *value2 = (intptr_t)op2->__anon1.s;
1958 else if(op2->kind == 2)
1959 *value2 = (intptr_t)op2->__anon1.us;
1960 else if(op2->kind == 1 && op2->type->isSigned)
1961 *value2 = (intptr_t)op2->__anon1.c;
1962 else if(op2->kind == 24 || op2->kind == 1)
1963 *value2 = (intptr_t)op2->__anon1.uc;
1964 else if(op2->kind == 6)
1965 *value2 = (intptr_t)op2->__anon1.f;
1966 else if(op2->kind == 7)
1967 *value2 = (intptr_t)op2->__anon1.d;
1968 else if(op2->kind == 13)
1969 *value2 = (intptr_t)op2->__anon1.ui64;
1970 else
1971 return 0;
1972 return 1;
1973 }
1974
1975 unsigned int GetIntPtr(struct Expression * exp, intptr_t * value2)
1976 {
1977 struct Operand op2 = GetOperand(exp);
1978
1979 return GetOpIntPtr(&op2, value2);
1980 }
1981
1982 unsigned int GetOpUIntPtr(struct Operand * op2, uintptr_t * value2)
1983 {
1984 if(op2->kind == 3 && op2->type->isSigned)
1985 *value2 = (uintptr_t)op2->__anon1.i;
1986 else if(op2->kind == 3)
1987 *value2 = (uintptr_t)op2->__anon1.ui;
1988 else if(op2->kind == 4 && op2->type->isSigned)
1989 *value2 = (uintptr_t)op2->__anon1.i64;
1990 else if(op2->kind == 4)
1991 *value2 = (uintptr_t)op2->__anon1.ui64;
1992 else if(op2->kind == 23 && op2->type->isSigned)
1993 *value2 = (uintptr_t)op2->__anon1.i64;
1994 else if(op2->kind == 23)
1995 *value2 = (uintptr_t)op2->__anon1.ui64;
1996 else if(op2->kind == 22 && op2->type->isSigned)
1997 *value2 = (uintptr_t)op2->__anon1.i64;
1998 else if(op2->kind == 22)
1999 *value2 = (uintptr_t)op2->__anon1.ui64;
2000 else if(op2->kind == 2 && op2->type->isSigned)
2001 *value2 = (uintptr_t)op2->__anon1.s;
2002 else if(op2->kind == 2)
2003 *value2 = (uintptr_t)op2->__anon1.us;
2004 else if(op2->kind == 1 && op2->type->isSigned)
2005 *value2 = (uintptr_t)op2->__anon1.c;
2006 else if(op2->kind == 24 || op2->kind == 1)
2007 *value2 = (uintptr_t)op2->__anon1.uc;
2008 else if(op2->kind == 6)
2009 *value2 = (uintptr_t)op2->__anon1.f;
2010 else if(op2->kind == 7)
2011 *value2 = (uintptr_t)op2->__anon1.d;
2012 else if(op2->kind == 13)
2013 *value2 = (uintptr_t)op2->__anon1.ui64;
2014 else
2015 return 0;
2016 return 1;
2017 }
2018
2019 unsigned int GetUIntPtr(struct Expression * exp, uintptr_t * value2)
2020 {
2021 struct Operand op2 = GetOperand(exp);
2022
2023 return GetOpUIntPtr(&op2, value2);
2024 }
2025
2026 unsigned int GetOpIntSize(struct Operand * op2, ssize_t * value2)
2027 {
2028 if(op2->kind == 3 && op2->type->isSigned)
2029 *value2 = (ssize_t)op2->__anon1.i;
2030 else if(op2->kind == 3)
2031 *value2 = (ssize_t)op2->__anon1.ui;
2032 else if(op2->kind == 4 && op2->type->isSigned)
2033 *value2 = (ssize_t)op2->__anon1.i64;
2034 else if(op2->kind == 4)
2035 *value2 = (ssize_t)op2->__anon1.ui64;
2036 else if(op2->kind == 23 && op2->type->isSigned)
2037 *value2 = (ssize_t)op2->__anon1.i64;
2038 else if(op2->kind == 23)
2039 *value2 = (ssize_t)op2->__anon1.ui64;
2040 else if(op2->kind == 22 && op2->type->isSigned)
2041 *value2 = (ssize_t)op2->__anon1.i64;
2042 else if(op2->kind == 22)
2043 *value2 = (ssize_t)op2->__anon1.ui64;
2044 else if(op2->kind == 2 && op2->type->isSigned)
2045 *value2 = (ssize_t)op2->__anon1.s;
2046 else if(op2->kind == 2)
2047 *value2 = (ssize_t)op2->__anon1.us;
2048 else if(op2->kind == 1 && op2->type->isSigned)
2049 *value2 = (ssize_t)op2->__anon1.c;
2050 else if(op2->kind == 24 || op2->kind == 1)
2051 *value2 = (ssize_t)op2->__anon1.uc;
2052 else if(op2->kind == 6)
2053 *value2 = (ssize_t)op2->__anon1.f;
2054 else if(op2->kind == 7)
2055 *value2 = (ssize_t)op2->__anon1.d;
2056 else if(op2->kind == 13)
2057 *value2 = (ssize_t)op2->__anon1.ui64;
2058 else
2059 return 0;
2060 return 1;
2061 }
2062
2063 unsigned int GetIntSize(struct Expression * exp, ssize_t * value2)
2064 {
2065 struct Operand op2 = GetOperand(exp);
2066
2067 return GetOpIntSize(&op2, value2);
2068 }
2069
2070 unsigned int GetOpUIntSize(struct Operand * op2, size_t * value2)
2071 {
2072 if(op2->kind == 3 && op2->type->isSigned)
2073 *value2 = (size_t)op2->__anon1.i;
2074 else if(op2->kind == 3)
2075 *value2 = (size_t)op2->__anon1.ui;
2076 else if(op2->kind == 4 && op2->type->isSigned)
2077 *value2 = (size_t)op2->__anon1.i64;
2078 else if(op2->kind == 4)
2079 *value2 = (size_t)op2->__anon1.ui64;
2080 else if(op2->kind == 23 && op2->type->isSigned)
2081 *value2 = (size_t)op2->__anon1.i64;
2082 else if(op2->kind == 23)
2083 *value2 = (size_t)op2->__anon1.ui64;
2084 else if(op2->kind == 22 && op2->type->isSigned)
2085 *value2 = (size_t)op2->__anon1.i64;
2086 else if(op2->kind == 22)
2087 *value2 = (size_t)op2->__anon1.ui64;
2088 else if(op2->kind == 2 && op2->type->isSigned)
2089 *value2 = (size_t)op2->__anon1.s;
2090 else if(op2->kind == 2)
2091 *value2 = (size_t)op2->__anon1.us;
2092 else if(op2->kind == 1 && op2->type->isSigned)
2093 *value2 = (size_t)op2->__anon1.c;
2094 else if(op2->kind == 24 || op2->kind == 1)
2095 *value2 = (size_t)op2->__anon1.uc;
2096 else if(op2->kind == 6)
2097 *value2 = (size_t)op2->__anon1.f;
2098 else if(op2->kind == 7)
2099 *value2 = (size_t)op2->__anon1.d;
2100 else if(op2->kind == 13)
2101 *value2 = (size_t)op2->__anon1.ui64;
2102 else
2103 return 0;
2104 return 1;
2105 }
2106
2107 unsigned int GetUIntSize(struct Expression * exp, size_t * value2)
2108 {
2109 struct Operand op2 = GetOperand(exp);
2110
2111 return GetOpUIntSize(&op2, value2);
2112 }
2113
2114 unsigned int GetOpShort(struct Operand * op2, short * value2)
2115 {
2116 if(op2->kind == 3 && op2->type->isSigned)
2117 *value2 = (short)op2->__anon1.i;
2118 else if(op2->kind == 3)
2119 *value2 = (short)op2->__anon1.ui;
2120 else if(op2->kind == 4 && op2->type->isSigned)
2121 *value2 = (short)op2->__anon1.i64;
2122 else if(op2->kind == 4)
2123 *value2 = (short)op2->__anon1.ui64;
2124 else if(op2->kind == 23 && op2->type->isSigned)
2125 *value2 = (short)op2->__anon1.i64;
2126 else if(op2->kind == 23)
2127 *value2 = (short)op2->__anon1.ui64;
2128 else if(op2->kind == 22 && op2->type->isSigned)
2129 *value2 = (short)op2->__anon1.i64;
2130 else if(op2->kind == 22)
2131 *value2 = (short)op2->__anon1.ui64;
2132 else if(op2->kind == 2 && op2->type->isSigned)
2133 *value2 = op2->__anon1.s;
2134 else if(op2->kind == 2)
2135 *value2 = (short)op2->__anon1.us;
2136 else if(op2->kind == 1 && op2->type->isSigned)
2137 *value2 = (short)op2->__anon1.c;
2138 else if(op2->kind == 24 || op2->kind == 1)
2139 *value2 = (short)op2->__anon1.uc;
2140 else if(op2->kind == 6)
2141 *value2 = (short)op2->__anon1.f;
2142 else if(op2->kind == 7)
2143 *value2 = (short)op2->__anon1.d;
2144 else if(op2->kind == 13)
2145 *value2 = (short)op2->__anon1.ui64;
2146 else
2147 return 0;
2148 return 1;
2149 }
2150
2151 unsigned int GetShort(struct Expression * exp, short * value2)
2152 {
2153 struct Operand op2 = GetOperand(exp);
2154
2155 return GetOpShort(&op2, value2);
2156 }
2157
2158 unsigned int GetOpUShort(struct Operand * op2, unsigned short * value2)
2159 {
2160 if(op2->kind == 3 && op2->type->isSigned)
2161 *value2 = (unsigned short)op2->__anon1.i;
2162 else if(op2->kind == 3)
2163 *value2 = (unsigned short)op2->__anon1.ui;
2164 else if(op2->kind == 4 && op2->type->isSigned)
2165 *value2 = (unsigned short)op2->__anon1.i64;
2166 else if(op2->kind == 4)
2167 *value2 = (unsigned short)op2->__anon1.ui64;
2168 else if(op2->kind == 23 && op2->type->isSigned)
2169 *value2 = (unsigned short)op2->__anon1.i64;
2170 else if(op2->kind == 23)
2171 *value2 = (unsigned short)op2->__anon1.ui64;
2172 else if(op2->kind == 22 && op2->type->isSigned)
2173 *value2 = (unsigned short)op2->__anon1.i64;
2174 else if(op2->kind == 22)
2175 *value2 = (unsigned short)op2->__anon1.ui64;
2176 else if(op2->kind == 2 && op2->type->isSigned)
2177 *value2 = (unsigned short)op2->__anon1.s;
2178 else if(op2->kind == 2)
2179 *value2 = op2->__anon1.us;
2180 else if(op2->kind == 1 && op2->type->isSigned)
2181 *value2 = (unsigned short)op2->__anon1.c;
2182 else if(op2->kind == 24 || op2->kind == 1)
2183 *value2 = (unsigned short)op2->__anon1.uc;
2184 else if(op2->kind == 6)
2185 *value2 = (unsigned short)op2->__anon1.f;
2186 else if(op2->kind == 7)
2187 *value2 = (unsigned short)op2->__anon1.d;
2188 else if(op2->kind == 13)
2189 *value2 = (unsigned short)op2->__anon1.ui64;
2190 else
2191 return 0;
2192 return 1;
2193 }
2194
2195 unsigned int GetUShort(struct Expression * exp, unsigned short * value2)
2196 {
2197 struct Operand op2 = GetOperand(exp);
2198
2199 return GetOpUShort(&op2, value2);
2200 }
2201
2202 unsigned int GetOpChar(struct Operand * op2, char * value2)
2203 {
2204 if(op2->kind == 3 && op2->type->isSigned)
2205 *value2 = (char)op2->__anon1.i;
2206 else if(op2->kind == 3)
2207 *value2 = (char)op2->__anon1.ui;
2208 else if(op2->kind == 4 && op2->type->isSigned)
2209 *value2 = (char)op2->__anon1.i64;
2210 else if(op2->kind == 4)
2211 *value2 = (char)op2->__anon1.ui64;
2212 else if(op2->kind == 23 && op2->type->isSigned)
2213 *value2 = (char)op2->__anon1.i64;
2214 else if(op2->kind == 23)
2215 *value2 = (char)op2->__anon1.ui64;
2216 else if(op2->kind == 22 && op2->type->isSigned)
2217 *value2 = (char)op2->__anon1.i64;
2218 else if(op2->kind == 22)
2219 *value2 = (char)op2->__anon1.ui64;
2220 else if(op2->kind == 2 && op2->type->isSigned)
2221 *value2 = (char)op2->__anon1.s;
2222 else if(op2->kind == 2)
2223 *value2 = (char)op2->__anon1.us;
2224 else if(op2->kind == 1 && op2->type->isSigned)
2225 *value2 = op2->__anon1.c;
2226 else if(op2->kind == 24 || op2->kind == 1)
2227 *value2 = (char)op2->__anon1.uc;
2228 else if(op2->kind == 6)
2229 *value2 = (char)op2->__anon1.f;
2230 else if(op2->kind == 7)
2231 *value2 = (char)op2->__anon1.d;
2232 else if(op2->kind == 13)
2233 *value2 = (char)op2->__anon1.ui64;
2234 else
2235 return 0;
2236 return 1;
2237 }
2238
2239 unsigned int GetChar(struct Expression * exp, char * value2)
2240 {
2241 struct Operand op2 = GetOperand(exp);
2242
2243 return GetOpChar(&op2, value2);
2244 }
2245
2246 unsigned int GetOpUChar(struct Operand * op2, unsigned char * value2)
2247 {
2248 if(op2->kind == 3 && op2->type->isSigned)
2249 *value2 = (unsigned char)op2->__anon1.i;
2250 else if(op2->kind == 3)
2251 *value2 = (unsigned char)op2->__anon1.ui;
2252 else if(op2->kind == 4 && op2->type->isSigned)
2253 *value2 = (unsigned char)op2->__anon1.i64;
2254 else if(op2->kind == 4)
2255 *value2 = (unsigned char)op2->__anon1.ui64;
2256 else if(op2->kind == 23 && op2->type->isSigned)
2257 *value2 = (unsigned char)op2->__anon1.i64;
2258 else if(op2->kind == 23)
2259 *value2 = (unsigned char)op2->__anon1.ui64;
2260 else if(op2->kind == 22 && op2->type->isSigned)
2261 *value2 = (unsigned char)op2->__anon1.i64;
2262 else if(op2->kind == 22)
2263 *value2 = (unsigned char)op2->__anon1.ui64;
2264 else if(op2->kind == 2 && op2->type->isSigned)
2265 *value2 = (unsigned char)op2->__anon1.s;
2266 else if(op2->kind == 2)
2267 *value2 = (unsigned char)op2->__anon1.us;
2268 else if(op2->kind == 1 && op2->type->isSigned)
2269 *value2 = (unsigned char)op2->__anon1.c;
2270 else if(op2->kind == 24 || op2->kind == 1)
2271 *value2 = op2->__anon1.uc;
2272 else if(op2->kind == 6)
2273 *value2 = (unsigned char)op2->__anon1.f;
2274 else if(op2->kind == 7)
2275 *value2 = (unsigned char)op2->__anon1.d;
2276 else if(op2->kind == 13)
2277 *value2 = (unsigned char)op2->__anon1.ui64;
2278 else
2279 return 0;
2280 return 1;
2281 }
2282
2283 unsigned int GetUChar(struct Expression * exp, unsigned char * value2)
2284 {
2285 struct Operand op2 = GetOperand(exp);
2286
2287 return GetOpUChar(&op2, value2);
2288 }
2289
2290 unsigned int GetOpFloat(struct Operand * op2, float * value2)
2291 {
2292 if(op2->kind == 3 && op2->type->isSigned)
2293 *value2 = (float)(float)op2->__anon1.i;
2294 else if(op2->kind == 3)
2295 *value2 = (float)(float)op2->__anon1.ui;
2296 else if(op2->kind == 4 && op2->type->isSigned)
2297 *value2 = (float)(float)op2->__anon1.i64;
2298 else if(op2->kind == 4)
2299 *value2 = (float)(float)op2->__anon1.ui64;
2300 else if(op2->kind == 23 && op2->type->isSigned)
2301 *value2 = (float)(float)op2->__anon1.i64;
2302 else if(op2->kind == 23)
2303 *value2 = (float)(float)op2->__anon1.ui64;
2304 else if(op2->kind == 22 && op2->type->isSigned)
2305 *value2 = (float)(float)op2->__anon1.i64;
2306 else if(op2->kind == 22)
2307 *value2 = (float)(float)op2->__anon1.ui64;
2308 else if(op2->kind == 2 && op2->type->isSigned)
2309 *value2 = (float)(float)op2->__anon1.s;
2310 else if(op2->kind == 2)
2311 *value2 = (float)(float)op2->__anon1.us;
2312 else if(op2->kind == 1 && op2->type->isSigned)
2313 *value2 = (float)(float)op2->__anon1.c;
2314 else if(op2->kind == 24 || op2->kind == 1)
2315 *value2 = (float)(float)op2->__anon1.uc;
2316 else if(op2->kind == 6)
2317 *value2 = (float)op2->__anon1.f;
2318 else if(op2->kind == 7)
2319 *value2 = (float)op2->__anon1.d;
2320 else if(op2->kind == 13)
2321 *value2 = (float)(float)op2->__anon1.ui64;
2322 else
2323 return 0;
2324 return 1;
2325 }
2326
2327 unsigned int GetFloat(struct Expression * exp, float * value2)
2328 {
2329 struct Operand op2 = GetOperand(exp);
2330
2331 return GetOpFloat(&op2, value2);
2332 }
2333
2334 unsigned int GetOpDouble(struct Operand * op2, double * value2)
2335 {
2336 if(op2->kind == 3 && op2->type->isSigned)
2337 *value2 = (double)(double)op2->__anon1.i;
2338 else if(op2->kind == 3)
2339 *value2 = (double)(double)op2->__anon1.ui;
2340 else if(op2->kind == 4 && op2->type->isSigned)
2341 *value2 = (double)(double)op2->__anon1.i64;
2342 else if(op2->kind == 4)
2343 *value2 = (double)(double)op2->__anon1.ui64;
2344 else if(op2->kind == 23 && op2->type->isSigned)
2345 *value2 = (double)(double)op2->__anon1.i64;
2346 else if(op2->kind == 23)
2347 *value2 = (double)(double)op2->__anon1.ui64;
2348 else if(op2->kind == 22 && op2->type->isSigned)
2349 *value2 = (double)(double)op2->__anon1.i64;
2350 else if(op2->kind == 22)
2351 *value2 = (double)(double)op2->__anon1.ui64;
2352 else if(op2->kind == 2 && op2->type->isSigned)
2353 *value2 = (double)(double)op2->__anon1.s;
2354 else if(op2->kind == 2)
2355 *value2 = (double)(double)op2->__anon1.us;
2356 else if(op2->kind == 1 && op2->type->isSigned)
2357 *value2 = (double)(double)op2->__anon1.c;
2358 else if(op2->kind == 24 || op2->kind == 1)
2359 *value2 = (double)(double)op2->__anon1.uc;
2360 else if(op2->kind == 6)
2361 *value2 = (double)op2->__anon1.f;
2362 else if(op2->kind == 7)
2363 *value2 = (double)op2->__anon1.d;
2364 else if(op2->kind == 13)
2365 *value2 = (double)(double)op2->__anon1.ui64;
2366 else
2367 return 0;
2368 return 1;
2369 }
2370
2371 unsigned int GetDouble(struct Expression * exp, double * value2)
2372 {
2373 struct Operand op2 = GetOperand(exp);
2374
2375 return GetOpDouble(&op2, value2);
2376 }
2377
2378 void ComputeExpression(struct Expression * exp);
2379
2380 struct Context * SetupTemplatesContext(struct __ecereNameSpace__ecere__com__Class * _class);
2381
2382 extern int targetBits;
2383
2384 int ComputeTypeSize(struct Type * type);
2385
2386 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
2387
2388 struct __ecereNameSpace__ecere__com__BitMember
2389 {
2390 struct __ecereNameSpace__ecere__com__BitMember * prev;
2391 struct __ecereNameSpace__ecere__com__BitMember * next;
2392 const char *  name;
2393 unsigned int isProperty;
2394 int memberAccess;
2395 int id;
2396 struct __ecereNameSpace__ecere__com__Class * _class;
2397 const char *  dataTypeString;
2398 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
2399 struct Type * dataType;
2400 int type;
2401 int size;
2402 int pos;
2403 uint64 mask;
2404 } __attribute__ ((gcc_struct));
2405
2406 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldLink;
2407
2408 struct __ecereNameSpace__ecere__sys__OldLink
2409 {
2410 struct __ecereNameSpace__ecere__sys__OldLink * prev;
2411 struct __ecereNameSpace__ecere__sys__OldLink * next;
2412 void *  data;
2413 } __attribute__ ((gcc_struct));
2414
2415 void FinishTemplatesContext(struct Context * context);
2416
2417 void ComputeClassMembers(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int isMember)
2418 {
2419 struct __ecereNameSpace__ecere__com__DataMember * member = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)_class : (((void *)0));
2420 struct Context * context = isMember ? (((void *)0)) : SetupTemplatesContext(_class);
2421
2422 if(member || ((_class->type == 2 || _class->type == 0 || _class->type == 1 || _class->type == 5) && (_class->type == 2 || (!_class->structSize || _class->structSize == _class->offset)) && _class->computeSize))
2423 {
2424 int unionMemberOffset = 0;
2425 int bitFields = 0;
2426
2427 if(member)
2428 {
2429 member->memberOffset = 0;
2430 if(targetBits < sizeof(void *) * 8)
2431 member->structAlignment = 0;
2432 }
2433 else if(targetBits < sizeof(void *) * 8)
2434 _class->structAlignment = 0;
2435 if(!member && ((_class->type == 0 || _class->type == 5) || (_class->type == 1 && _class->memberOffset && _class->memberOffset > _class->base->structSize)))
2436 _class->memberOffset = (_class->base && _class->type == 1) ? _class->base->structSize : 0;
2437 if(!member && _class->destructionWatchOffset)
2438 _class->memberOffset += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
2439 {
2440 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
2441
2442 for(dataMember = member ? member->members.first : _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
2443 {
2444 if(!dataMember->isProperty)
2445 {
2446 if(dataMember->type == 0 && dataMember->dataTypeString && !dataMember->dataType)
2447 {
2448 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
2449 }
2450 }
2451 }
2452 }
2453 {
2454 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
2455
2456 for(dataMember = member ? member->members.first : _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
2457 {
2458 if(!dataMember->isProperty && (dataMember->type != 0 || dataMember->dataTypeString))
2459 {
2460 if(!isMember && _class->type == 2 && dataMember->dataType)
2461 {
2462 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)dataMember;
2463 uint64 mask = 0;
2464 int d;
2465
2466 ComputeTypeSize(dataMember->dataType);
2467 if(bitMember->pos == -1)
2468 bitMember->pos = _class->memberOffset;
2469 if(!bitMember->size)
2470 bitMember->size = dataMember->dataType->size * 8;
2471 _class->memberOffset = bitMember->pos + bitMember->size;
2472 for(d = 0; d < bitMember->size; d++)
2473 {
2474 if(d)
2475 mask <<= 1;
2476 mask |= 1;
2477 }
2478 bitMember->mask = mask << bitMember->pos;
2479 }
2480 else if(dataMember->type == 0 && dataMember->dataType)
2481 {
2482 int size;
2483 int alignment = 0;
2484
2485 if(dataMember->dataType->kind != 8 || ((!dataMember->dataType->__anon1._class || !dataMember->dataType->__anon1._class->__anon1.registered || dataMember->dataType->__anon1._class->__anon1.registered != _class || _class->type != 1)))
2486 ComputeTypeSize(dataMember->dataType);
2487 if(dataMember->dataType->bitFieldCount)
2488 {
2489 bitFields += dataMember->dataType->bitFieldCount;
2490 size = 0;
2491 }
2492 else
2493 {
2494 if(bitFields)
2495 {
2496 int size = (bitFields + 7) / 8;
2497
2498 if(isMember)
2499 {
2500 int __simpleStruct0;
2501
2502 if(alignment)
2503 {
2504 int __simpleStruct0;
2505
2506 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2507 if(member->memberOffset % alignment)
2508 member->memberOffset += alignment - (member->memberOffset % alignment);
2509 }
2510 dataMember->offset = member->memberOffset;
2511 if(member->type == 1)
2512 unionMemberOffset = (__simpleStruct0 = dataMember->dataType->size, (unionMemberOffset > __simpleStruct0) ? unionMemberOffset : __simpleStruct0);
2513 else
2514 {
2515 member->memberOffset += size;
2516 }
2517 }
2518 else
2519 {
2520 if(alignment)
2521 {
2522 int __simpleStruct0;
2523
2524 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2525 if(_class->memberOffset % alignment)
2526 _class->memberOffset += alignment - (_class->memberOffset % alignment);
2527 }
2528 dataMember->offset = _class->memberOffset;
2529 _class->memberOffset += size;
2530 }
2531 bitFields = 0;
2532 }
2533 size = dataMember->dataType->size;
2534 alignment = dataMember->dataType->alignment;
2535 }
2536 if(isMember)
2537 {
2538 int __simpleStruct0;
2539
2540 if(alignment)
2541 {
2542 int __simpleStruct0;
2543
2544 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2545 if(member->memberOffset % alignment)
2546 member->memberOffset += alignment - (member->memberOffset % alignment);
2547 }
2548 dataMember->offset = member->memberOffset;
2549 if(member->type == 1)
2550 unionMemberOffset = (__simpleStruct0 = dataMember->dataType->size, (unionMemberOffset > __simpleStruct0) ? unionMemberOffset : __simpleStruct0);
2551 else
2552 {
2553 member->memberOffset += size;
2554 }
2555 }
2556 else
2557 {
2558 if(alignment)
2559 {
2560 int __simpleStruct0;
2561
2562 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2563 if(_class->memberOffset % alignment)
2564 _class->memberOffset += alignment - (_class->memberOffset % alignment);
2565 }
2566 dataMember->offset = _class->memberOffset;
2567 _class->memberOffset += size;
2568 }
2569 }
2570 else
2571 {
2572 int alignment;
2573
2574 ComputeClassMembers((struct __ecereNameSpace__ecere__com__Class *)dataMember, 1);
2575 alignment = dataMember->structAlignment;
2576 if(isMember)
2577 {
2578 int __simpleStruct0;
2579
2580 if(alignment)
2581 {
2582 int __simpleStruct0;
2583
2584 if(member->memberOffset % alignment)
2585 member->memberOffset += alignment - (member->memberOffset % alignment);
2586 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2587 }
2588 dataMember->offset = member->memberOffset;
2589 if(member->type == 1)
2590 unionMemberOffset = (__simpleStruct0 = dataMember->memberOffset, (unionMemberOffset > __simpleStruct0) ? unionMemberOffset : __simpleStruct0);
2591 else
2592 member->memberOffset += dataMember->memberOffset;
2593 }
2594 else
2595 {
2596 if(alignment)
2597 {
2598 int __simpleStruct0;
2599
2600 if(_class->memberOffset % alignment)
2601 _class->memberOffset += alignment - (_class->memberOffset % alignment);
2602 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2603 }
2604 dataMember->offset = _class->memberOffset;
2605 _class->memberOffset += dataMember->memberOffset;
2606 }
2607 }
2608 }
2609 }
2610 if(bitFields)
2611 {
2612 int alignment = 0;
2613 int size = (bitFields + 7) / 8;
2614
2615 if(isMember)
2616 {
2617 int __simpleStruct0;
2618
2619 if(alignment)
2620 {
2621 int __simpleStruct0;
2622
2623 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2624 if(member->memberOffset % alignment)
2625 member->memberOffset += alignment - (member->memberOffset % alignment);
2626 }
2627 if(member->type == 1)
2628 unionMemberOffset = (__simpleStruct0 = dataMember->dataType->size, (unionMemberOffset > __simpleStruct0) ? unionMemberOffset : __simpleStruct0);
2629 else
2630 {
2631 member->memberOffset += size;
2632 }
2633 }
2634 else
2635 {
2636 if(alignment)
2637 {
2638 int __simpleStruct0;
2639
2640 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
2641 if(_class->memberOffset % alignment)
2642 _class->memberOffset += alignment - (_class->memberOffset % alignment);
2643 }
2644 _class->memberOffset += size;
2645 }
2646 bitFields = 0;
2647 }
2648 }
2649 if(member && member->type == 1)
2650 {
2651 member->memberOffset = unionMemberOffset;
2652 }
2653 if(!isMember)
2654 {
2655 if(_class->type != 2)
2656 {
2657 int extra = 0;
2658
2659 if(_class->structAlignment)
2660 {
2661 if(_class->memberOffset % _class->structAlignment)
2662 extra += _class->structAlignment - (_class->memberOffset % _class->structAlignment);
2663 }
2664 _class->structSize = (_class->base ? (_class->base->templateClass ? _class->base->templateClass->structSize : _class->base->structSize) : 0) + _class->memberOffset + extra;
2665 if(!member)
2666 {
2667 struct __ecereNameSpace__ecere__com__Property * prop;
2668
2669 for(prop = _class->membersAndProperties.first; prop; prop = prop->next)
2670 {
2671 if(prop->isProperty && prop->isWatchable)
2672 {
2673 prop->watcherOffset = _class->structSize;
2674 _class->structSize += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
2675 }
2676 }
2677 }
2678 {
2679 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
2680
2681 for(derivative = _class->derivatives.first; derivative; derivative = derivative->next)
2682 {
2683 struct __ecereNameSpace__ecere__com__Class * deriv = derivative->data;
2684
2685 if(deriv->computeSize)
2686 {
2687 deriv->offset = _class->structSize;
2688 deriv->memberOffset = 0;
2689 deriv->structSize = deriv->offset;
2690 ComputeClassMembers(deriv, 0);
2691 }
2692 }
2693 }
2694 }
2695 }
2696 }
2697 if(context)
2698 FinishTemplatesContext(context);
2699 }
2700
2701 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
2702
2703 struct __ecereNameSpace__ecere__com__NameSpace
2704 {
2705 const char *  name;
2706 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
2707 struct __ecereNameSpace__ecere__com__NameSpace *  left;
2708 struct __ecereNameSpace__ecere__com__NameSpace *  right;
2709 int depth;
2710 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
2711 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
2712 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
2713 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
2714 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
2715 } __attribute__ ((gcc_struct));
2716
2717 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
2718
2719 struct __ecereNameSpace__ecere__com__Module
2720 {
2721 struct __ecereNameSpace__ecere__com__Instance * application;
2722 struct __ecereNameSpace__ecere__sys__OldList classes;
2723 struct __ecereNameSpace__ecere__sys__OldList defines;
2724 struct __ecereNameSpace__ecere__sys__OldList functions;
2725 struct __ecereNameSpace__ecere__sys__OldList modules;
2726 struct __ecereNameSpace__ecere__com__Instance * prev;
2727 struct __ecereNameSpace__ecere__com__Instance * next;
2728 const char *  name;
2729 void *  library;
2730 void *  Unload;
2731 int importType;
2732 int origImportType;
2733 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
2734 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
2735 } __attribute__ ((gcc_struct));
2736
2737 void ComputeModuleClasses(struct __ecereNameSpace__ecere__com__Instance * module)
2738 {
2739 struct __ecereNameSpace__ecere__com__Class * _class;
2740 struct __ecereNameSpace__ecere__sys__OldLink * subModule;
2741
2742 for(subModule = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules.first; subModule; subModule = subModule->next)
2743 ComputeModuleClasses(subModule->data);
2744 for(_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes.first; _class; _class = _class->next)
2745 ComputeClassMembers(_class, 0);
2746 }
2747
2748 extern unsigned int inCompiler;
2749
2750 extern void Compiler_Error(const char *  format, ...);
2751
2752 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
2753
2754 extern struct Symbol * FindStruct(struct Context * ctx, const char *  name);
2755
2756 int ComputeTypeSize(struct Type * type)
2757 {
2758 unsigned int size = type ? type->size : 0;
2759
2760 if(!size && type && !type->computing)
2761 {
2762 type->computing = 1;
2763 switch(type->kind)
2764 {
2765 case 24:
2766 type->alignment = size = sizeof(char);
2767 break;
2768 case 1:
2769 type->alignment = size = sizeof(char);
2770 break;
2771 case 3:
2772 type->alignment = size = sizeof(int);
2773 break;
2774 case 4:
2775 type->alignment = size = sizeof(long long);
2776 break;
2777 case 22:
2778 type->alignment = size = targetBits / 8;
2779 break;
2780 case 23:
2781 type->alignment = size = targetBits / 8;
2782 break;
2783 case 5:
2784 type->alignment = size = sizeof(long);
2785 break;
2786 case 2:
2787 type->alignment = size = sizeof(short);
2788 break;
2789 case 6:
2790 type->alignment = size = sizeof(float);
2791 break;
2792 case 7:
2793 type->alignment = size = sizeof(double);
2794 break;
2795 case 8:
2796 {
2797 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class ? type->__anon1._class->__anon1.registered : (((void *)0));
2798
2799 if(_class && _class->type == 1)
2800 {
2801 ComputeClassMembers(_class, 0);
2802 type->alignment = _class->structAlignment;
2803 size = _class->structSize;
2804 if(type->alignment && size % type->alignment)
2805 size += type->alignment - (size % type->alignment);
2806 }
2807 else if(_class && (_class->type == 3 || _class->type == 4 || _class->type == 2))
2808 {
2809 if(!_class->dataType)
2810 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
2811 size = type->alignment = ComputeTypeSize(_class->dataType);
2812 }
2813 else
2814 size = type->alignment = targetBits / 8;
2815 break;
2816 }
2817 case 13:
2818 case 19:
2819 size = type->alignment = targetBits / 8;
2820 break;
2821 case 12:
2822 if(type->__anon1.__anon4.arraySizeExp)
2823 {
2824 ProcessExpressionType(type->__anon1.__anon4.arraySizeExp);
2825 ComputeExpression(type->__anon1.__anon4.arraySizeExp);
2826 if(!type->__anon1.__anon4.arraySizeExp->isConstant || (type->__anon1.__anon4.arraySizeExp->expType->kind != 3 && type->__anon1.__anon4.arraySizeExp->expType->kind != 2 && type->__anon1.__anon4.arraySizeExp->expType->kind != 1 && type->__anon1.__anon4.arraySizeExp->expType->kind != 5 && type->__anon1.__anon4.arraySizeExp->expType->kind != 4 && type->__anon1.__anon4.arraySizeExp->expType->kind != 23 && type->__anon1.__anon4.arraySizeExp->expType->kind != 22 && type->__anon1.__anon4.arraySizeExp->expType->kind != 15 && (type->__anon1.__anon4.arraySizeExp->expType->kind != 8 || !type->__anon1.__anon4.arraySizeExp->expType->__anon1._class->__anon1.registered || type->__anon1.__anon4.arraySizeExp->expType->__anon1._class->__anon1.registered->type != 4)))
2827 {
2828 struct Location oldLoc = yylloc;
2829 char expression[10240];
2830
2831 expression[0] = '\0';
2832 type->__anon1.__anon4.arraySizeExp->expType = (((void *)0));
2833 yylloc = type->__anon1.__anon4.arraySizeExp->loc;
2834 if(inCompiler)
2835 PrintExpression(type->__anon1.__anon4.arraySizeExp, expression);
2836 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Array size not constant int (%s)\n", (((void *)0))), expression);
2837 yylloc = oldLoc;
2838 }
2839 GetInt(type->__anon1.__anon4.arraySizeExp, &type->__anon1.__anon4.arraySize);
2840 }
2841 else if(type->__anon1.__anon4.enumClass)
2842 {
2843 if(type->__anon1.__anon4.enumClass && type->__anon1.__anon4.enumClass->__anon1.registered && type->__anon1.__anon4.enumClass->__anon1.registered->type == 4)
2844 {
2845 type->__anon1.__anon4.arraySize = (int)__ecereNameSpace__ecere__com__eClass_GetProperty(type->__anon1.__anon4.enumClass->__anon1.registered, "enumSize");
2846 }
2847 else
2848 type->__anon1.__anon4.arraySize = 0;
2849 }
2850 else
2851 {
2852 type->__anon1.__anon4.arraySize = 0;
2853 }
2854 size = ComputeTypeSize(type->__anon1.type) * type->__anon1.__anon4.arraySize;
2855 if(type->__anon1.type)
2856 type->alignment = type->__anon1.type->alignment;
2857 break;
2858 case 9:
2859 {
2860 if(!type->__anon1.__anon1.members.first && type->__anon1.__anon1.enumName)
2861 {
2862 struct Symbol * symbol = FindStruct(curContext, type->__anon1.__anon1.enumName);
2863
2864 if(symbol && symbol->type)
2865 {
2866 ComputeTypeSize(symbol->type);
2867 size = symbol->type->size;
2868 }
2869 }
2870 else
2871 {
2872 struct Type * member;
2873
2874 for(member = type->__anon1.__anon1.members.first; member; member = member->next)
2875 {
2876 int __simpleStruct0, __simpleStruct1;
2877 unsigned int addSize = ComputeTypeSize(member);
2878
2879 member->offset = size;
2880 if(member->alignment && size % member->alignment)
2881 member->offset += member->alignment - (size % member->alignment);
2882 size = member->offset;
2883 type->alignment = (__simpleStruct0 = type->alignment, __simpleStruct1 = member->alignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2884 size += addSize;
2885 }
2886 if(type->alignment && size % type->alignment)
2887 size += type->alignment - (size % type->alignment);
2888 }
2889 break;
2890 }
2891 case 10:
2892 {
2893 if(!type->__anon1.__anon1.members.first && type->__anon1.__anon1.enumName)
2894 {
2895 struct Symbol * symbol = FindStruct(curContext, type->__anon1.__anon1.enumName);
2896
2897 if(symbol && symbol->type)
2898 {
2899 ComputeTypeSize(symbol->type);
2900 size = symbol->type->size;
2901 }
2902 }
2903 else
2904 {
2905 struct Type * member;
2906
2907 for(member = type->__anon1.__anon1.members.first; member; member = member->next)
2908 {
2909 int __simpleStruct0, __simpleStruct1;
2910 unsigned int addSize = ComputeTypeSize(member);
2911
2912 member->offset = size;
2913 if(member->alignment && size % member->alignment)
2914 member->offset += member->alignment - (size % member->alignment);
2915 size = member->offset;
2916 type->alignment = (__simpleStruct0 = type->alignment, __simpleStruct1 = member->alignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2917 size = ((size > addSize) ? size : addSize);
2918 }
2919 if(type->alignment && size % type->alignment)
2920 size += type->alignment - (size % type->alignment);
2921 }
2922 break;
2923 }
2924 case 20:
2925 {
2926 struct TemplateParameter * param = type->__anon1.templateParameter;
2927 struct Type * baseType = ProcessTemplateParameterType(param);
2928
2929 if(baseType)
2930 {
2931 size = ComputeTypeSize(baseType);
2932 type->alignment = baseType->alignment;
2933 }
2934 else
2935 type->alignment = size = sizeof(uint64);
2936 break;
2937 }
2938 case 15:
2939 {
2940 type->alignment = size = sizeof(enum
2941 {
2942 test
2943 });
2944 break;
2945 }
2946 case 21:
2947 {
2948 type->alignment = size = targetBits / 8;
2949 break;
2950 }
2951 }
2952 type->size = size;
2953 type->computing = 0;
2954 }
2955 return size;
2956 }
2957
2958 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
2959
2960 extern struct Identifier * MkIdentifier(const char *  string);
2961
2962 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
2963
2964 extern struct Declarator * MkStructDeclarator(struct Declarator * declarator, struct Expression * exp);
2965
2966 extern struct ClassDef * MkClassDefDeclaration(struct Declaration * decl);
2967
2968 extern struct Declaration * MkStructDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * declarators, struct Specifier * extStorage);
2969
2970 void ReplaceThisClassSpecifiers(struct __ecereNameSpace__ecere__sys__OldList * specs, struct __ecereNameSpace__ecere__com__Class * _class);
2971
2972 static void DeclareType(struct Type * type, unsigned int declarePointers, unsigned int declareParams);
2973
2974 extern void FreeType(struct Type * type);
2975
2976 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
2977
2978 extern struct Specifier * MkSpecifier(int specifier);
2979
2980 extern struct Declarator * MkDeclaratorArray(struct Declarator * declarator, struct Expression * exp);
2981
2982 extern struct Expression * MkExpConstant(const char *  string);
2983
2984 int AddMembers(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__com__Class * _class, unsigned int isMember, unsigned int * retSize, struct __ecereNameSpace__ecere__com__Class * topClass, unsigned int * addedPadding)
2985 {
2986 struct __ecereNameSpace__ecere__com__DataMember * topMember = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)_class : (((void *)0));
2987 unsigned int totalSize = 0;
2988 unsigned int maxSize = 0;
2989 int alignment;
2990 unsigned int size;
2991 struct __ecereNameSpace__ecere__com__DataMember * member;
2992 int anonID = 1;
2993 struct Context * context = isMember ? (((void *)0)) : SetupTemplatesContext(_class);
2994
2995 if(addedPadding)
2996 *addedPadding = 0;
2997 if(!isMember && _class->base)
2998 {
2999 maxSize = _class->structSize;
3000 {
3001 if(_class->type == 1 || _class->type == 5)
3002 AddMembers(declarations, _class->base, 0, &totalSize, topClass, (((void *)0)));
3003 else
3004 {
3005 unsigned int baseSize = _class->base->templateClass ? _class->base->templateClass->structSize : _class->base->structSize;
3006
3007 if(maxSize > baseSize)
3008 maxSize -= baseSize;
3009 else
3010 maxSize = 0;
3011 }
3012 }
3013 }
3014 for(member = isMember ? topMember->members.first : _class->membersAndProperties.first; member; member = member->next)
3015 {
3016 if(!member->isProperty)
3017 {
3018 switch(member->type)
3019 {
3020 case 0:
3021 {
3022 if(member->dataTypeString)
3023 {
3024 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * decls = MkList();
3025 struct Declarator * decl;
3026
3027 decl = SpecDeclFromString(member->dataTypeString, specs, MkDeclaratorIdentifier(MkIdentifier(member->name)));
3028 ListAdd(decls, MkStructDeclarator(decl, (((void *)0))));
3029 ListAdd(declarations, MkClassDefDeclaration(MkStructDeclaration(specs, decls, (((void *)0)))));
3030 if(!member->dataType)
3031 member->dataType = ProcessType(specs, decl);
3032 ReplaceThisClassSpecifiers(specs, topClass);
3033 {
3034 struct Type * type = ProcessType(specs, decl);
3035
3036 DeclareType(member->dataType, 0, 0);
3037 FreeType(type);
3038 }
3039 ComputeTypeSize(member->dataType);
3040 size = member->dataType->size;
3041 alignment = member->dataType->alignment;
3042 if(alignment)
3043 {
3044 if(totalSize % alignment)
3045 totalSize += alignment - (totalSize % alignment);
3046 }
3047 totalSize += size;
3048 }
3049 break;
3050 }
3051 case 1:
3052 case 2:
3053 {
3054 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * list = MkList();
3055 char id[100];
3056
3057 sprintf(id, "__anon%d", anonID++);
3058 size = 0;
3059 AddMembers(list, (struct __ecereNameSpace__ecere__com__Class *)member, 1, &size, topClass, (((void *)0)));
3060 ListAdd(specs, MkStructOrUnion((member->type == 1) ? 4 : 3, (((void *)0)), list));
3061 ListAdd(declarations, MkClassDefDeclaration(MkStructDeclaration(specs, MkListOne(MkDeclaratorIdentifier(MkIdentifier(id))), (((void *)0)))));
3062 alignment = member->structAlignment;
3063 if(alignment)
3064 {
3065 if(totalSize % alignment)
3066 totalSize += alignment - (totalSize % alignment);
3067 }
3068 totalSize += size;
3069 break;
3070 }
3071 }
3072 }
3073 }
3074 if(retSize)
3075 {
3076 unsigned int __simpleStruct0;
3077
3078 if(topMember && topMember->type == 1)
3079 *retSize = (__simpleStruct0 = *retSize, (__simpleStruct0 > totalSize) ? __simpleStruct0 : totalSize);
3080 else
3081 *retSize += totalSize;
3082 }
3083 else if(totalSize < maxSize && _class->type != 1000)
3084 {
3085 int autoPadding = 0;
3086
3087 if(!isMember && _class->structAlignment && totalSize % _class->structAlignment)
3088 autoPadding = _class->structAlignment - (totalSize % _class->structAlignment);
3089 if(totalSize + autoPadding < maxSize)
3090 {
3091 char sizeString[50];
3092
3093 sprintf(sizeString, "%d", maxSize - totalSize);
3094 ListAdd(declarations, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifier(CHAR)), MkListOne(MkDeclaratorArray(MkDeclaratorIdentifier(MkIdentifier("__ecere_padding")), MkExpConstant(sizeString))), (((void *)0)))));
3095 if(addedPadding)
3096 *addedPadding = 1;
3097 }
3098 }
3099 if(context)
3100 FinishTemplatesContext(context);
3101 return topMember ? topMember->memberID : _class->memberID;
3102 }
3103
3104 static int DeclareMembers(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int isMember)
3105 {
3106 struct __ecereNameSpace__ecere__com__DataMember * topMember = isMember ? (struct __ecereNameSpace__ecere__com__DataMember *)_class : (((void *)0));
3107 struct __ecereNameSpace__ecere__com__DataMember * member;
3108 struct Context * context = isMember ? (((void *)0)) : SetupTemplatesContext(_class);
3109
3110 if(!isMember && (_class->type == 1 || _class->type == 5) && _class->base->type != 1000)
3111 DeclareMembers(_class->base, 0);
3112 for(member = isMember ? topMember->members.first : _class->membersAndProperties.first; member; member = member->next)
3113 {
3114 if(!member->isProperty)
3115 {
3116 switch(member->type)
3117 {
3118 case 0:
3119 {
3120 if(!member->dataType && member->dataTypeString)
3121 member->dataType = ProcessTypeString(member->dataTypeString, 0);
3122 if(member->dataType)
3123 DeclareType(member->dataType, 0, 0);
3124 break;
3125 }
3126 case 1:
3127 case 2:
3128 {
3129 DeclareMembers((struct __ecereNameSpace__ecere__com__Class *)member, 1);
3130 break;
3131 }
3132 }
3133 }
3134 }
3135 if(context)
3136 FinishTemplatesContext(context);
3137 return topMember ? topMember->memberID : _class->memberID;
3138 }
3139
3140 extern struct Identifier * GetDeclId(struct Declarator * decl);
3141
3142 static void IdentifyAnonStructs(struct __ecereNameSpace__ecere__sys__OldList * definitions)
3143 {
3144 struct ClassDef * def;
3145 int anonID = 1;
3146
3147 for(def = (*definitions).first; def; def = def->next)
3148 {
3149 if(def->type == 2)
3150 {
3151 struct Declaration * decl = def->__anon1.decl;
3152
3153 if(decl && decl->__anon1.__anon1.specifiers)
3154 {
3155 struct Specifier * spec;
3156 unsigned int isStruct = 0;
3157
3158 for(spec = (*decl->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
3159 {
3160 if(spec->type == 3 || spec->type == 4)
3161 {
3162 if(spec->__anon1.__anon2.definitions)
3163 IdentifyAnonStructs(spec->__anon1.__anon2.definitions);
3164 isStruct = 1;
3165 }
3166 }
3167 if(isStruct)
3168 {
3169 struct Declarator * d = (((void *)0));
3170
3171 if(decl->__anon1.__anon1.declarators)
3172 {
3173 for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
3174 {
3175 struct Identifier * idDecl = GetDeclId(d);
3176
3177 if(idDecl)
3178 break;
3179 }
3180 }
3181 if(!d)
3182 {
3183 char id[100];
3184
3185 sprintf(id, "__anon%d", anonID++);
3186 if(!decl->__anon1.__anon1.declarators)
3187 decl->__anon1.__anon1.declarators = MkList();
3188 ListAdd(decl->__anon1.__anon1.declarators, MkDeclaratorIdentifier(MkIdentifier(id)));
3189 }
3190 }
3191 }
3192 }
3193 }
3194 }
3195
3196 extern struct Symbol * FindClass(const char *  name);
3197
3198 extern char *  strchr(const char * , int);
3199
3200 extern void FullClassNameCat(char *  output, const char *  className, unsigned int includeTemplateParams);
3201
3202 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (*  FreeFunction)(void * ));
3203
3204 extern void FreeClassDef(struct ClassDef * def);
3205
3206 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
3207
3208 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
3209
3210 extern void DeclareClass(struct Symbol * classSym, const char *  className);
3211
3212 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item, void *  prevItem);
3213
3214 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
3215
3216 void DeclareStruct(const char * name, unsigned int skipNoHead)
3217 {
3218 struct External * external = (((void *)0));
3219 struct Symbol * classSym = FindClass(name);
3220
3221 if(!inCompiler || !classSym)
3222 return ;
3223 if(classSym->__anon1.registered && (classSym->__anon1.registered->type == 2 || classSym->__anon1.registered->type == 3 || classSym->__anon1.registered->type == 4))
3224 return ;
3225 if(classSym->__anon1.registered && classSym->imported && !classSym->declaredStructSym)
3226 {
3227 struct Declaration * decl;
3228 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
3229 struct __ecereNameSpace__ecere__sys__OldList * declarations = (((void *)0));
3230 char structName[1024];
3231 struct Specifier * spec = (((void *)0));
3232
3233 external = (classSym->__anon1.registered && classSym->__anon1.registered->type == 1) ? classSym->__anon2.__anon1.pointerExternal : classSym->__anon2.__anon1.structExternal;
3234 classSym->declaring++;
3235 if(strchr(classSym->string, '<'))
3236 {
3237 if(classSym->__anon1.registered->templateClass)
3238 {
3239 DeclareStruct(classSym->__anon1.registered->templateClass->fullName, skipNoHead);
3240 classSym->declaring--;
3241 }
3242 return ;
3243 }
3244 DeclareMembers(classSym->__anon1.registered, 0);
3245 structName[0] = (char)0;
3246 FullClassNameCat(structName, name, 0);
3247 if(external && external->__anon1.declaration && external->__anon1.declaration->__anon1.__anon1.specifiers)
3248 {
3249 for(spec = (*external->__anon1.declaration->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
3250 {
3251 if(spec->type == 3 || spec->type == 4)
3252 break;
3253 }
3254 }
3255 if(!skipNoHead && (!spec || !spec->__anon1.__anon2.definitions))
3256 {
3257 unsigned int addedPadding = 0;
3258
3259 classSym->declaredStructSym = 1;
3260 declarations = MkList();
3261 AddMembers(declarations, classSym->__anon1.registered, 0, (((void *)0)), classSym->__anon1.registered, &addedPadding);
3262 if(!(*declarations).count || ((*declarations).count == 1 && addedPadding))
3263 {
3264 FreeList(declarations, (void *)(FreeClassDef));
3265 declarations = (((void *)0));
3266 }
3267 }
3268 if(skipNoHead || declarations)
3269 {
3270 if(spec)
3271 {
3272 if(declarations)
3273 spec->__anon1.__anon2.definitions = declarations;
3274 if(curExternal && curExternal->symbol && curExternal->symbol->idCode < classSym->id)
3275 {
3276 if(classSym->__anon2.__anon1.structExternal)
3277 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->__anon2.__anon1.structExternal, curExternal->prev);
3278 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->__anon2.__anon1.pointerExternal, curExternal->prev);
3279 classSym->id = curExternal->symbol->idCode;
3280 classSym->idCode = curExternal->symbol->idCode;
3281 }
3282 }
3283 else
3284 {
3285 if(!external)
3286 external = MkExternalDeclaration((((void *)0)));
3287 specifiers = MkList();
3288 declarators = MkList();
3289 ListAdd(specifiers, MkStructOrUnion(3, MkIdentifier(structName), declarations));
3290 external->__anon1.declaration = decl = MkDeclaration(specifiers, declarators);
3291 if(decl->symbol && !decl->symbol->__anon2.__anon1.pointerExternal)
3292 decl->symbol->__anon2.__anon1.pointerExternal = external;
3293 if(classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3294 {
3295 char className[1024];
3296
3297 strcpy(className, "__ecereClass_");
3298 FullClassNameCat(className, classSym->string, 1);
3299 DeclareClass(classSym, className);
3300 external->symbol = classSym;
3301 classSym->__anon2.__anon1.pointerExternal = external;
3302 classSym->id = (curExternal && curExternal->symbol) ? curExternal->symbol->idCode : 0;
3303 classSym->idCode = (curExternal && curExternal->symbol) ? curExternal->symbol->idCode : 0;
3304 }
3305 else
3306 {
3307 char className[1024];
3308
3309 strcpy(className, "__ecereClass_");
3310 FullClassNameCat(className, classSym->string, 1);
3311 classSym->__anon2.__anon1.structExternal = external;
3312 DeclareClass(classSym, className);
3313 external->symbol = classSym;
3314 }
3315 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal ? curExternal->prev : (((void *)0)), external);
3316 }
3317 }
3318 classSym->declaring--;
3319 }
3320 else
3321 {
3322 if(classSym->__anon2.__anon1.structExternal && classSym->__anon2.__anon1.structExternal->__anon1.declaration && classSym->__anon2.__anon1.structExternal->__anon1.declaration->__anon1.__anon1.specifiers)
3323 {
3324 struct Specifier * spec;
3325
3326 for(spec = (*classSym->__anon2.__anon1.structExternal->__anon1.declaration->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
3327 {
3328 IdentifyAnonStructs(spec->__anon1.__anon2.definitions);
3329 }
3330 }
3331 if(curExternal && curExternal->symbol && curExternal->symbol->idCode < classSym->id)
3332 {
3333 classSym->declaring++;
3334 {
3335 if(classSym->__anon1.registered)
3336 DeclareMembers(classSym->__anon1.registered, 0);
3337 }
3338 if(classSym->__anon1.registered && (classSym->__anon1.registered->type == 1 || classSym->__anon1.registered->type == 5))
3339 {
3340 if(classSym->__anon2.__anon1.structExternal)
3341 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->__anon2.__anon1.structExternal, curExternal->prev);
3342 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->__anon2.__anon1.pointerExternal, curExternal->prev);
3343 classSym->id = curExternal->symbol->idCode;
3344 classSym->idCode = curExternal->symbol->idCode;
3345 }
3346 classSym->declaring--;
3347 }
3348 }
3349 }
3350
3351 extern struct ModuleImport * FindModule(struct __ecereNameSpace__ecere__com__Instance * moduleToFind);
3352
3353 extern struct ModuleImport * mainModule;
3354
3355 extern struct Specifier * MkSpecifierName(const char *  name);
3356
3357 extern struct Declarator * MkDeclaratorBrackets(struct Declarator * declarator);
3358
3359 extern struct Declarator * PlugDeclarator(struct Declarator * decl, struct Declarator * baseDecl);
3360
3361 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
3362
3363 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
3364
3365 extern void FreeDeclarator(struct Declarator * decl);
3366
3367 extern struct Specifier * MkSpecifierExtended(struct ExtDecl * extDecl);
3368
3369 extern struct ExtDecl * MkExtDeclAttrib(struct Attrib * attr);
3370
3371 extern struct Attrib * MkAttrib(int type, struct __ecereNameSpace__ecere__sys__OldList *  attribs);
3372
3373 extern struct Attribute * MkAttribute(char * attr, struct Expression * exp);
3374
3375 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyImport;
3376
3377 struct PropertyImport
3378 {
3379 struct PropertyImport * prev;
3380 struct PropertyImport * next;
3381 char *  name;
3382 unsigned int isVirtual;
3383 unsigned int hasSet;
3384 unsigned int hasGet;
3385 } __attribute__ ((gcc_struct));
3386
3387 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
3388
3389 void DeclareProperty(struct __ecereNameSpace__ecere__com__Property * prop, char * setName, char * getName)
3390 {
3391 struct Symbol * symbol = prop->symbol;
3392
3393 strcpy(setName, "__ecereProp_");
3394 FullClassNameCat(setName, prop->_class->fullName, 0);
3395 strcat(setName, "_Set_");
3396 FullClassNameCat(setName, prop->name, 1);
3397 strcpy(getName, "__ecereProp_");
3398 FullClassNameCat(getName, prop->_class->fullName, 0);
3399 strcat(getName, "_Get_");
3400 FullClassNameCat(getName, prop->name, 1);
3401 if(prop->_class->type == 1)
3402 DeclareStruct(prop->_class->fullName, 0);
3403 if(!symbol || curExternal->symbol->idCode < symbol->id)
3404 {
3405 unsigned int imported = 0;
3406 unsigned int dllImport = 0;
3407
3408 if(!symbol || symbol->_import)
3409 {
3410 if(!symbol)
3411 {
3412 struct Symbol * classSym;
3413
3414 if(!prop->_class->symbol)
3415 prop->_class->symbol = FindClass(prop->_class->fullName);
3416 classSym = prop->_class->symbol;
3417 if(classSym && !classSym->_import)
3418 {
3419 struct ModuleImport * module;
3420
3421 if(prop->_class->module)
3422 module = FindModule(prop->_class->module);
3423 else
3424 module = mainModule;
3425 classSym->_import = __extension__ ({
3426 struct ClassImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassImport);
3427
3428 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(prop->_class->fullName), __ecereInstance1->isRemote = prop->_class->isRemote, __ecereInstance1;
3429 });
3430 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&module->classes, classSym->_import);
3431 }
3432 symbol = prop->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
3433 symbol->_import = (struct ClassImport *)__extension__ ({
3434 struct PropertyImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyImport);
3435
3436 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(prop->name), __ecereInstance1->isVirtual = 0, __ecereInstance1->hasSet = prop->Set ? 1 : 0, __ecereInstance1->hasGet = prop->Get ? 1 : 0, __ecereInstance1;
3437 });
3438 if(classSym)
3439 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classSym->_import->properties, symbol->_import);
3440 }
3441 imported = 1;
3442 if((prop->_class->module != privateModule || !strcmp(prop->_class->name, "float") || !strcmp(prop->_class->name, "double")) && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)prop->_class->module + structSize_Instance)))->importType != 1)
3443 dllImport = 1;
3444 }
3445 if(!symbol->type)
3446 {
3447 struct Context * context = SetupTemplatesContext(prop->_class);
3448
3449 symbol->type = ProcessTypeString(prop->dataTypeString, 0);
3450 FinishTemplatesContext(context);
3451 }
3452 if(prop->Get)
3453 {
3454 if(!symbol->__anon2.__anon2.externalGet || symbol->__anon2.__anon2.externalGet->type == 0)
3455 {
3456 struct Declaration * decl;
3457 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
3458 struct Declarator * d;
3459 struct __ecereNameSpace__ecere__sys__OldList * params;
3460 struct Specifier * spec;
3461 struct External * external;
3462 struct Declarator * typeDecl;
3463 unsigned int simple = 0;
3464
3465 specifiers = MkList();
3466 declarators = MkList();
3467 params = MkList();
3468 ListAdd(params, MkTypeName(MkListOne(MkSpecifierName(prop->_class->fullName)), MkDeclaratorIdentifier(MkIdentifier("this"))));
3469 d = MkDeclaratorIdentifier(MkIdentifier(getName));
3470 if(dllImport)
3471 d = MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d));
3472 {
3473 struct Context * context = SetupTemplatesContext(prop->_class);
3474
3475 typeDecl = SpecDeclFromString(prop->dataTypeString, specifiers, (((void *)0)));
3476 FinishTemplatesContext(context);
3477 }
3478 for(spec = (*specifiers).first; spec; spec = spec->next)
3479 {
3480 if(spec->type == 1)
3481 {
3482 if((!typeDecl || typeDecl->type == 1))
3483 {
3484 struct Symbol * classSym = spec->__anon1.__anon1.symbol;
3485
3486 symbol->_class = classSym->__anon1.registered;
3487 if(classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3488 {
3489 DeclareStruct(spec->__anon1.__anon1.name, 0);
3490 simple = 1;
3491 }
3492 }
3493 }
3494 }
3495 if(!simple)
3496 d = PlugDeclarator(typeDecl, d);
3497 else
3498 {
3499 ListAdd(params, MkTypeName(specifiers, PlugDeclarator(typeDecl, MkDeclaratorIdentifier(MkIdentifier("value")))));
3500 specifiers = MkList();
3501 }
3502 d = MkDeclaratorFunction(d, params);
3503 if(dllImport)
3504 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(EXTERN));
3505 else if(prop->_class->symbol && ((struct Symbol *)prop->_class->symbol)->isStatic)
3506 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(STATIC));
3507 if(simple)
3508 ListAdd(specifiers, MkSpecifier(VOID));
3509 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
3510 decl = MkDeclaration(specifiers, declarators);
3511 external = MkExternalDeclaration(decl);
3512 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, external);
3513 external->symbol = symbol;
3514 symbol->__anon2.__anon2.externalGet = external;
3515 ReplaceThisClassSpecifiers(specifiers, prop->_class);
3516 if(typeDecl)
3517 FreeDeclarator(typeDecl);
3518 }
3519 else
3520 {
3521 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon2.externalGet, curExternal->prev);
3522 }
3523 }
3524 if(prop->Set)
3525 {
3526 if(!symbol->__anon2.__anon2.externalSet || symbol->__anon2.__anon2.externalSet->type == 0)
3527 {
3528 struct Declaration * decl;
3529 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
3530 struct Declarator * d;
3531 struct __ecereNameSpace__ecere__sys__OldList * params;
3532 struct Specifier * spec;
3533 struct External * external;
3534 struct Declarator * typeDecl;
3535
3536 declarators = MkList();
3537 params = MkList();
3538 if(!prop->conversion || prop->_class->type == 1)
3539 {
3540 ListAdd(params, MkTypeName(MkListOne(MkSpecifierName(prop->_class->fullName)), MkDeclaratorIdentifier(MkIdentifier("this"))));
3541 }
3542 specifiers = MkList();
3543 {
3544 struct Context * context = SetupTemplatesContext(prop->_class);
3545
3546 typeDecl = d = SpecDeclFromString(prop->dataTypeString, specifiers, MkDeclaratorIdentifier(MkIdentifier("value")));
3547 FinishTemplatesContext(context);
3548 }
3549 if(!strcmp(prop->_class->base->fullName, "eda::Row") || !strcmp(prop->_class->base->fullName, "eda::Id"))
3550 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(CONST));
3551 ListAdd(params, MkTypeName(specifiers, d));
3552 d = MkDeclaratorIdentifier(MkIdentifier(setName));
3553 if(dllImport)
3554 d = MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d));
3555 d = MkDeclaratorFunction(d, params);
3556 for(spec = (*specifiers).first; spec; spec = spec->next)
3557 {
3558 if(spec->type == 1)
3559 {
3560 if((!typeDecl || typeDecl->type == 1))
3561 {
3562 struct Symbol * classSym = spec->__anon1.__anon1.symbol;
3563
3564 symbol->_class = classSym->__anon1.registered;
3565 if(classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3566 DeclareStruct(spec->__anon1.__anon1.name, 0);
3567 }
3568 }
3569 }
3570 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
3571 specifiers = MkList();
3572 if(dllImport)
3573 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(EXTERN));
3574 else if(prop->_class->symbol && ((struct Symbol *)prop->_class->symbol)->isStatic)
3575 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(STATIC));
3576 if(!prop->conversion || prop->_class->type == 1)
3577 ListAdd(specifiers, MkSpecifier(VOID));
3578 else
3579 ListAdd(specifiers, MkSpecifierName(prop->_class->fullName));
3580 decl = MkDeclaration(specifiers, declarators);
3581 external = MkExternalDeclaration(decl);
3582 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, external);
3583 external->symbol = symbol;
3584 symbol->__anon2.__anon2.externalSet = external;
3585 ReplaceThisClassSpecifiers(specifiers, prop->_class);
3586 }
3587 else
3588 {
3589 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon2.externalSet, curExternal->prev);
3590 }
3591 }
3592 if(!symbol->__anon2.__anon2.externalPtr)
3593 {
3594 struct Declaration * decl;
3595 struct External * external;
3596 struct __ecereNameSpace__ecere__sys__OldList * specifiers = MkList();
3597 char propName[1024];
3598
3599 if(imported)
3600 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(EXTERN));
3601 else
3602 {
3603 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*specifiers), (((void *)0)), MkSpecifier(STATIC));
3604 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*specifiers), MkSpecifierExtended(MkExtDeclAttrib(MkAttrib(ATTRIB, MkListOne(MkAttribute(__ecereNameSpace__ecere__sys__CopyString("unused"), (((void *)0))))))));
3605 }
3606 ListAdd(specifiers, MkSpecifierName("Property"));
3607 strcpy(propName, "__ecereProp_");
3608 FullClassNameCat(propName, prop->_class->fullName, 0);
3609 strcat(propName, "_");
3610 FullClassNameCat(propName, prop->name, 1);
3611 {
3612 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3613
3614 ListAdd(list, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(propName)), (((void *)0))));
3615 if(!imported)
3616 {
3617 strcpy(propName, "__ecerePropM_");
3618 FullClassNameCat(propName, prop->_class->fullName, 0);
3619 strcat(propName, "_");
3620 FullClassNameCat(propName, prop->name, 1);
3621 ListAdd(list, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(propName)), (((void *)0))));
3622 }
3623 decl = MkDeclaration(specifiers, list);
3624 }
3625 external = MkExternalDeclaration(decl);
3626 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, external);
3627 external->symbol = symbol;
3628 symbol->__anon2.__anon2.externalPtr = external;
3629 }
3630 else
3631 {
3632 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon2.externalPtr, curExternal->prev);
3633 }
3634 symbol->id = curExternal->symbol->idCode;
3635 }
3636 }
3637
3638 struct Type * Dereference(struct Type * source)
3639 {
3640 struct Type * type = (((void *)0));
3641
3642 if(source)
3643 {
3644 if(source->kind == 13 || source->kind == 12)
3645 {
3646 type = source->__anon1.type;
3647 source->__anon1.type->refCount++;
3648 }
3649 else if(source->kind == 8 && !strcmp(source->__anon1._class->string, "String"))
3650 {
3651 type = __extension__ ({
3652 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
3653
3654 __ecereInstance1->kind = 1, __ecereInstance1->refCount = 1, __ecereInstance1;
3655 });
3656 }
3657 else if(source->kind == 8 && source->__anon1._class && source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered->type == 5)
3658 {
3659 type = source;
3660 source->refCount++;
3661 }
3662 else
3663 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot dereference type\n", (((void *)0))));
3664 }
3665 return type;
3666 }
3667
3668 static struct Type * Reference(struct Type * source)
3669 {
3670 struct Type * type = (((void *)0));
3671
3672 if(source)
3673 {
3674 type = __extension__ ({
3675 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
3676
3677 __ecereInstance1->kind = 13, __ecereInstance1->__anon1.type = source, __ecereInstance1->refCount = 1, __ecereInstance1;
3678 });
3679 source->refCount++;
3680 }
3681 return type;
3682 }
3683
3684 extern void __ecereNameSpace__ecere__com__eClass_FindNextMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class **  curClass, struct __ecereNameSpace__ecere__com__DataMember **  curMember, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
3685
3686 extern void *  memcpy(void * , const void * , size_t size);
3687
3688 void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
3689
3690 extern void FreeExpression(struct Expression * exp);
3691
3692 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
3693
3694 unsigned int MatchTypes(struct Type * source, struct Type * dest, struct __ecereNameSpace__ecere__sys__OldList * conversions, struct __ecereNameSpace__ecere__com__Class * owningClassSource, struct __ecereNameSpace__ecere__com__Class * owningClassDest, unsigned int doConversion, unsigned int enumBaseType, unsigned int acceptReversedParams, unsigned int isConversionExploration, unsigned int warnConst);
3695
3696 static void ProcessInitializer(struct Initializer * init, struct Type * type);
3697
3698 extern struct Type * MkClassType(const char *  name);
3699
3700 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  type, unsigned int size, unsigned int alignment, int declMode);
3701
3702 void ProcessMemberInitData(struct MemberInit * member, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class ** curClass, struct __ecereNameSpace__ecere__com__DataMember ** curMember, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3703 {
3704 struct Identifier * ident = member->identifiers ? (*member->identifiers).first : (((void *)0));
3705 unsigned int found = 0;
3706 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3707 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
3708 unsigned int freeType = 0;
3709
3710 yylloc = member->loc;
3711 if(!ident)
3712 {
3713 if(curMember)
3714 {
3715 __ecereNameSpace__ecere__com__eClass_FindNextMember(_class, curClass, curMember, subMemberStack, subMemberStackPos);
3716 if(*curMember)
3717 {
3718 found = 1;
3719 dataMember = *curMember;
3720 }
3721 }
3722 }
3723 else
3724 {
3725 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, ident->string, privateModule);
3726 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
3727 int _subMemberStackPos = 0;
3728
3729 if(!thisMember)
3730 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, ident->string, privateModule, _subMemberStack, &_subMemberStackPos);
3731 if(thisMember)
3732 {
3733 dataMember = thisMember;
3734 if(curMember && thisMember->memberAccess == 1)
3735 {
3736 *curMember = thisMember;
3737 *curClass = thisMember->_class;
3738 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
3739 *subMemberStackPos = _subMemberStackPos;
3740 }
3741 found = 1;
3742 }
3743 else
3744 {
3745 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, ident->string, privateModule);
3746 if(method && method->type == 1)
3747 found = 1;
3748 else
3749 method = (((void *)0));
3750 }
3751 }
3752 if(found)
3753 {
3754 struct Type * type = (((void *)0));
3755
3756 if(dataMember)
3757 {
3758 if(!dataMember->dataType && dataMember->dataTypeString)
3759 {
3760 struct Context * context = SetupTemplatesContext(_class);
3761
3762 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
3763 FinishTemplatesContext(context);
3764 }
3765 type = dataMember->dataType;
3766 }
3767 else if(method)
3768 {
3769 if(!method->dataType)
3770 ProcessMethodType(method);
3771 type = method->dataType;
3772 }
3773 if(ident && ident->next)
3774 {
3775 for(ident = ident->next; ident && type; ident = ident->next)
3776 {
3777 if(type->kind == 8)
3778 {
3779 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(type->__anon1._class->__anon1.registered, ident->string, privateModule);
3780 if(!dataMember)
3781 dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(type->__anon1._class->__anon1.registered, ident->string, privateModule, (((void *)0)), (((void *)0)));
3782 if(dataMember)
3783 type = dataMember->dataType;
3784 }
3785 else if(type->kind == 9 || type->kind == 10)
3786 {
3787 struct Type * memberType;
3788
3789 for(memberType = type->__anon1.__anon1.members.first; memberType; memberType = memberType->next)
3790 {
3791 if(!strcmp(memberType->name, ident->string))
3792 {
3793 type = memberType;
3794 break;
3795 }
3796 }
3797 }
3798 }
3799 }
3800 if(type && type->kind == 20 && type->__anon1.templateParameter->type == 0 && _class->templateArgs)
3801 {
3802 int id = 0;
3803 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
3804 struct __ecereNameSpace__ecere__com__Class * sClass;
3805
3806 for(sClass = _class; sClass; sClass = sClass->base)
3807 {
3808 id = 0;
3809 if(sClass->templateClass)
3810 sClass = sClass->templateClass;
3811 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
3812 {
3813 if(curParam->type == 0 && !strcmp(type->__anon1.templateParameter->identifier->string, curParam->name))
3814 {
3815 for(sClass = sClass->base; sClass; sClass = sClass->base)
3816 {
3817 if(sClass->templateClass)
3818 sClass = sClass->templateClass;
3819 id += sClass->templateParams.count;
3820 }
3821 break;
3822 }
3823 id++;
3824 }
3825 if(curParam)
3826 break;
3827 }
3828 if(curParam)
3829 {
3830 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg = _class->templateArgs[id];
3831
3832 if(arg.__anon1.__anon1.dataTypeString)
3833 {
3834 unsigned int constant = type->constant;
3835
3836 type = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
3837 if(type->kind == 8 && constant)
3838 type->constant = 1;
3839 else if(type->kind == 13)
3840 {
3841 struct Type * t = type->__anon1.type;
3842
3843 while(t->kind == 13)
3844 t = t->__anon1.type;
3845 if(constant)
3846 t->constant = constant;
3847 }
3848 freeType = 1;
3849 if(type && _class->templateClass)
3850 type->passAsTemplate = 1;
3851 if(type)
3852 {
3853 }
3854 }
3855 }
3856 }
3857 if(type && type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered && strchr(type->__anon1._class->__anon1.registered->fullName, '<'))
3858 {
3859 struct __ecereNameSpace__ecere__com__Class * expClass = type->__anon1._class->__anon1.registered;
3860 struct __ecereNameSpace__ecere__com__Class * cClass = (((void *)0));
3861 int paramCount = 0;
3862 int lastParam = -1;
3863 char templateString[1024];
3864 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
3865
3866 sprintf(templateString, "%s<", expClass->templateClass->fullName);
3867 for(cClass = expClass; cClass; cClass = cClass->base)
3868 {
3869 int p = 0;
3870
3871 if(cClass->templateClass)
3872 cClass = cClass->templateClass;
3873 for(param = cClass->templateParams.first; param; param = param->next)
3874 {
3875 int id = p;
3876 struct __ecereNameSpace__ecere__com__Class * sClass;
3877 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg;
3878
3879 for(sClass = cClass->base; sClass; sClass = sClass->base)
3880 {
3881 if(sClass->templateClass)
3882 sClass = sClass->templateClass;
3883 id += sClass->templateParams.count;
3884 }
3885 arg = expClass->templateArgs[id];
3886 for(sClass = _class; sClass; sClass = sClass->base)
3887 {
3888 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
3889 int p = 0;
3890 struct __ecereNameSpace__ecere__com__Class * nextClass;
3891
3892 if(sClass->templateClass)
3893 sClass = sClass->templateClass;
3894 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
3895 {
3896 if(nextClass->templateClass)
3897 nextClass = nextClass->templateClass;
3898 p += nextClass->templateParams.count;
3899 }
3900 for(cParam = sClass->templateParams.first; cParam; cParam = cParam->next, p++)
3901 {
3902 if(cParam->type == 0 && arg.__anon1.__anon1.dataTypeString && !strcmp(cParam->name, arg.__anon1.__anon1.dataTypeString))
3903 {
3904 if(_class->templateArgs && arg.__anon1.__anon1.dataTypeString && (!param->defaultArg.__anon1.__anon1.dataTypeString || strcmp(arg.__anon1.__anon1.dataTypeString, param->defaultArg.__anon1.__anon1.dataTypeString)))
3905 {
3906 arg.__anon1.__anon1.dataTypeString = _class->templateArgs[p].__anon1.__anon1.dataTypeString;
3907 arg.__anon1.__anon1.dataTypeClass = _class->templateArgs[p].__anon1.__anon1.dataTypeClass;
3908 break;
3909 }
3910 }
3911 }
3912 }
3913 {
3914 char argument[256];
3915
3916 argument[0] = '\0';
3917 switch(param->type)
3918 {
3919 case 2:
3920 {
3921 char expString[1024];
3922 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
3923 struct Declarator * decl = SpecDeclFromString(param->__anon1.dataTypeString, specs, (((void *)0)));
3924 struct Expression * exp;
3925 char * string = PrintHexUInt64(arg.__anon1.expression.__anon1.ui64);
3926
3927 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
3928 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3929 ProcessExpressionType(exp);
3930 ComputeExpression(exp);
3931 expString[0] = '\0';
3932 PrintExpression(exp, expString);
3933 strcat(argument, expString);
3934 FreeExpression(exp);
3935 break;
3936 }
3937 case 1:
3938 {
3939 strcat(argument, arg.__anon1.__anon2.__anon1.member->name);
3940 break;
3941 }
3942 case 0:
3943 {
3944 if(arg.__anon1.__anon1.dataTypeString && (!param->defaultArg.__anon1.__anon1.dataTypeString || strcmp(arg.__anon1.__anon1.dataTypeString, param->defaultArg.__anon1.__anon1.dataTypeString)))
3945 strcat(argument, arg.__anon1.__anon1.dataTypeString);
3946 break;
3947 }
3948 }
3949 if(argument[0])
3950 {
3951 if(paramCount)
3952 strcat(templateString, ", ");
3953 if(lastParam != p - 1)
3954 {
3955 strcat(templateString, param->name);
3956 strcat(templateString, " = ");
3957 }
3958 strcat(templateString, argument);
3959 paramCount++;
3960 lastParam = p;
3961 }
3962 p++;
3963 }
3964 }
3965 }
3966 {
3967 int len = strlen(templateString);
3968
3969 if(templateString[len - 1] == '<')
3970 len--;
3971 else
3972 {
3973 if(templateString[len - 1] == '>')
3974 templateString[len++] = ' ';
3975 templateString[len++] = '>';
3976 }
3977 templateString[len++] = '\0';
3978 }
3979 {
3980 struct Context * context = SetupTemplatesContext(_class);
3981
3982 if(freeType)
3983 FreeType(type);
3984 type = ProcessTypeString(templateString, 0);
3985 freeType = 1;
3986 FinishTemplatesContext(context);
3987 }
3988 }
3989 if(method && member->initializer && member->initializer->type == 0 && member->initializer->__anon1.exp)
3990 {
3991 ProcessExpressionType(member->initializer->__anon1.exp);
3992 if(!member->initializer->__anon1.exp->expType)
3993 {
3994 if(inCompiler)
3995 {
3996 char expString[10240];
3997
3998 expString[0] = '\0';
3999 PrintExpression(member->initializer->__anon1.exp, expString);
4000 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
4001 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved symbol used as an instance method %s\n", (((void *)0))), expString);
4002 }
4003 }
4004 else if(!MatchTypes(member->initializer->__anon1.exp->expType, type, (((void *)0)), (((void *)0)), _class, 1, 1, 0, 0, 1))
4005 {
4006 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible instance method %s\n", (((void *)0))), ident->string);
4007 }
4008 }
4009 else if(member->initializer)
4010 {
4011 ProcessInitializer(member->initializer, type);
4012 }
4013 if(freeType)
4014 FreeType(type);
4015 }
4016 else
4017 {
4018 if(_class && _class->type == 3)
4019 {
4020 if(member->initializer)
4021 {
4022 struct Type * type = MkClassType(_class->fullName);
4023
4024 ProcessInitializer(member->initializer, type);
4025 FreeType(type);
4026 }
4027 }
4028 else
4029 {
4030 if(member->initializer)
4031 {
4032 ProcessInitializer(member->initializer, (((void *)0)));
4033 }
4034 if(ident)
4035 {
4036 if(method)
4037 {
4038 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find virtual method %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
4039 }
4040 else if(_class)
4041 {
4042 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find member %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
4043 if(inCompiler)
4044 __ecereNameSpace__ecere__com__eClass_AddDataMember(_class, ident->string, "int", 0, 0, 1);
4045 }
4046 }
4047 else if(_class)
4048 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many initializers for instantiation of class %s\n", (((void *)0))), _class->fullName);
4049 }
4050 }
4051 }
4052
4053 extern struct External * ProcessClassFunction(struct __ecereNameSpace__ecere__com__Class * owningClass, struct ClassFunction * func, struct __ecereNameSpace__ecere__sys__OldList * defs, struct External * after, unsigned int makeStatic);
4054
4055 extern void FreeSpecifier(struct Specifier * spec);
4056
4057 static void ProcessFunction(struct FunctionDefinition * function);
4058
4059 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
4060
4061 extern struct Specifier * CopySpecifier(struct Specifier * spec);
4062
4063 extern struct Declarator * CopyDeclarator(struct Declarator * declarator);
4064
4065 extern void FreeClassFunction(struct ClassFunction * func);
4066
4067 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
4068
4069 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
4070
4071 void ProcessInstantiationType(struct Instantiation * inst)
4072 {
4073 yylloc = inst->loc;
4074 if(inst->_class)
4075 {
4076 struct MembersInit * members;
4077 struct Symbol * classSym;
4078 struct __ecereNameSpace__ecere__com__Class * _class;
4079
4080 classSym = inst->_class->__anon1.__anon1.symbol;
4081 _class = classSym ? classSym->__anon1.registered : (((void *)0));
4082 if(!_class || _class->type != 5)
4083 DeclareStruct(inst->_class->__anon1.__anon1.name, 0);
4084 afterExternal = afterExternal ? afterExternal : curExternal;
4085 if(inst->exp)
4086 ProcessExpressionType(inst->exp);
4087 inst->isConstant = 1;
4088 if(inst->members)
4089 {
4090 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
4091 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
4092 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
4093 int subMemberStackPos = 0;
4094
4095 for(members = (*inst->members).first; members; members = members->next)
4096 {
4097 switch(members->type)
4098 {
4099 case 1:
4100 {
4101 char name[1024];
4102 static unsigned int instMethodID = 0;
4103 struct External * external = curExternal;
4104 struct Context * context = curContext;
4105 struct Declarator * declarator = members->__anon1.function->declarator;
4106 struct Identifier * nameID = GetDeclId(declarator);
4107 char * unmangled = nameID ? nameID->string : (((void *)0));
4108 struct Expression * exp;
4109 struct External * createdExternal = (((void *)0));
4110
4111 if(inCompiler)
4112 {
4113 char number[16];
4114
4115 strcpy(name, "__ecereInstMeth_");
4116 FullClassNameCat(name, _class ? _class->fullName : "_UNKNOWNCLASS", 0);
4117 strcat(name, "_");
4118 strcat(name, nameID->string);
4119 strcat(name, "_");
4120 sprintf(number, "_%08d", instMethodID++);
4121 strcat(name, number);
4122 nameID->string = __ecereNameSpace__ecere__sys__CopyString(name);
4123 }
4124 if(declarator)
4125 {
4126 struct Symbol * symbol = declarator->symbol;
4127 struct __ecereNameSpace__ecere__com__Method * method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, unmangled, privateModule);
4128
4129 if(method && method->type == 1)
4130 {
4131 symbol->__anon1.method = method;
4132 ProcessMethodType(method);
4133 if(!symbol->type->__anon1.__anon2.thisClass)
4134 {
4135 if(method->dataType->__anon1.__anon2.thisClass && currentClass && __ecereNameSpace__ecere__com__eClass_IsDerived(currentClass, method->dataType->__anon1.__anon2.thisClass->__anon1.registered))
4136 {
4137 if(!currentClass->symbol)
4138 currentClass->symbol = FindClass(currentClass->fullName);
4139 symbol->type->__anon1.__anon2.thisClass = currentClass->symbol;
4140 }
4141 else
4142 {
4143 if(!_class->symbol)
4144 _class->symbol = FindClass(_class->fullName);
4145 symbol->type->__anon1.__anon2.thisClass = _class->symbol;
4146 }
4147 }
4148 DeclareType(symbol->type, 1, 1);
4149 }
4150 else if(classSym)
4151 {
4152 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find virtual method %s in class %s\n", (((void *)0))), unmangled, classSym->string);
4153 }
4154 }
4155 createdExternal = ProcessClassFunction(classSym ? classSym->__anon1.registered : (((void *)0)), members->__anon1.function, ast, afterExternal, 1);
4156 if(nameID)
4157 {
4158 FreeSpecifier(nameID->_class);
4159 nameID->_class = (((void *)0));
4160 }
4161 if(inCompiler)
4162 {
4163 struct External * oldExternal = curExternal;
4164
4165 declarator->symbol->id = declarator->symbol->idCode = curExternal->symbol->idCode;
4166 {
4167 struct External * externalDecl;
4168
4169 externalDecl = MkExternalDeclaration((((void *)0)));
4170 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), oldExternal->prev, externalDecl);
4171 if(createdExternal->__anon1.function)
4172 {
4173 ProcessFunction(createdExternal->__anon1.function);
4174 {
4175 struct Declaration * decl = MkDeclaration(CopyList(createdExternal->__anon1.function->specifiers, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(CopyDeclarator(declarator), (((void *)0)))));
4176
4177 externalDecl->__anon1.declaration = decl;
4178 if(decl->symbol && !decl->symbol->__anon2.__anon1.pointerExternal)
4179 decl->symbol->__anon2.__anon1.pointerExternal = externalDecl;
4180 declarator->symbol->__anon2.__anon1.pointerExternal = externalDecl;
4181 }
4182 }
4183 }
4184 }
4185 else if(declarator)
4186 {
4187 curExternal = declarator->symbol->__anon2.__anon1.pointerExternal;
4188 ProcessFunction((struct FunctionDefinition *)members->__anon1.function);
4189 }
4190 curExternal = external;
4191 curContext = context;
4192 if(inCompiler)
4193 {
4194 FreeClassFunction(members->__anon1.function);
4195 exp = QMkExpId(name);
4196 members->type = 0;
4197 members->__anon1.dataMembers = MkListOne(MkMemberInit(MkListOne(MkIdentifier(unmangled)), MkInitializerAssignment(exp)));
4198 (__ecereNameSpace__ecere__com__eSystem_Delete(unmangled), unmangled = 0);
4199 }
4200 break;
4201 }
4202 case 0:
4203 {
4204 if(members->__anon1.dataMembers && classSym)
4205 {
4206 struct MemberInit * member;
4207 struct Location oldyyloc = yylloc;
4208
4209 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
4210 {
4211 ProcessMemberInitData(member, classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
4212 if(member->initializer && !member->initializer->isConstant)
4213 inst->isConstant = 0;
4214 }
4215 yylloc = oldyyloc;
4216 }
4217 break;
4218 }
4219 }
4220 }
4221 }
4222 }
4223 }
4224
4225 static void DeclareType(struct Type * type, unsigned int declarePointers, unsigned int declareParams)
4226 {
4227 if(inCompiler)
4228 {
4229 if(type->kind == 11)
4230 {
4231 struct Type * param;
4232
4233 if(declareParams)
4234 {
4235 for(param = type->__anon1.__anon2.params.first; param; param = param->next)
4236 DeclareType(param, declarePointers, 1);
4237 }
4238 DeclareType(type->__anon1.__anon2.returnType, declarePointers, 1);
4239 }
4240 else if(type->kind == 13 && declarePointers)
4241 DeclareType(type->__anon1.type, declarePointers, 0);
4242 else if(type->kind == 8)
4243 {
4244 if(type->__anon1._class->__anon1.registered && (type->__anon1._class->__anon1.registered->type == 1 || type->__anon1._class->__anon1.registered->type == 5) && !type->__anon1._class->declaring)
4245 DeclareStruct(type->__anon1._class->__anon1.registered->fullName, type->__anon1._class->__anon1.registered->type == 5);
4246 }
4247 else if(type->kind == 9 || type->kind == 10)
4248 {
4249 struct Type * member;
4250
4251 for(member = type->__anon1.__anon1.members.first; member; member = member->next)
4252 DeclareType(member, 0, 0);
4253 }
4254 else if(type->kind == 12)
4255 DeclareType(type->__anon1.__anon4.arrayType, declarePointers, 0);
4256 }
4257 }
4258
4259 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
4260
4261 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * FindTemplateArg(struct __ecereNameSpace__ecere__com__Class * _class, struct TemplateParameter * param)
4262 {
4263 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = (((void *)0));
4264 int id = 0;
4265 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
4266 struct __ecereNameSpace__ecere__com__Class * sClass;
4267
4268 for(sClass = _class; sClass; sClass = sClass->base)
4269 {
4270 id = 0;
4271 if(sClass->templateClass)
4272 sClass = sClass->templateClass;
4273 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
4274 {
4275 if(curParam->type == 0 && !strcmp(param->identifier->string, curParam->name))
4276 {
4277 for(sClass = sClass->base; sClass; sClass = sClass->base)
4278 {
4279 if(sClass->templateClass)
4280 sClass = sClass->templateClass;
4281 id += sClass->templateParams.count;
4282 }
4283 break;
4284 }
4285 id++;
4286 }
4287 if(curParam)
4288 break;
4289 }
4290 if(curParam)
4291 {
4292 arg = &_class->templateArgs[id];
4293 if(arg && param->type == 0)
4294 (*arg).__anon1.__anon1.dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, (*arg).__anon1.__anon1.dataTypeString);
4295 }
4296 return arg;
4297 }
4298
4299 extern struct Context * PushContext(void);
4300
4301 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplatedType;
4302
4303 struct TemplatedType
4304 {
4305 uintptr_t key;
4306 struct __ecereNameSpace__ecere__sys__BTNode * parent;
4307 struct __ecereNameSpace__ecere__sys__BTNode * left;
4308 struct __ecereNameSpace__ecere__sys__BTNode * right;
4309 int depth;
4310 struct TemplateParameter * param;
4311 } __attribute__ ((gcc_struct));
4312
4313 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
4314
4315 struct Context * SetupTemplatesContext(struct __ecereNameSpace__ecere__com__Class * _class)
4316 {
4317 struct Context * context = PushContext();
4318
4319 context->templateTypesOnly = 1;
4320 if(_class->symbol && ((struct Symbol *)_class->symbol)->templateParams)
4321 {
4322 struct TemplateParameter * param = (*((struct Symbol *)_class->symbol)->templateParams).first;
4323
4324 for(; param; param = param->next)
4325 {
4326 if(param->type == 0 && param->identifier)
4327 {
4328 struct TemplatedType * type = (type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TemplatedType), type->key = (uintptr_t)param->identifier->string, type->param = param, type);
4329
4330 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&curContext->templateTypes, (struct __ecereNameSpace__ecere__sys__BTNode *)type);
4331 }
4332 }
4333 }
4334 else if(_class)
4335 {
4336 struct __ecereNameSpace__ecere__com__Class * sClass;
4337
4338 for(sClass = _class; sClass; sClass = sClass->base)
4339 {
4340 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * p;
4341
4342 for(p = sClass->templateParams.first; p; p = p->next)
4343 {
4344 if(p->type == 0)
4345 {
4346 struct TemplateParameter * param = p->param;
4347 struct TemplatedType * type;
4348
4349 if(!param)
4350 {
4351 p->param = param = __extension__ ({
4352 struct TemplateParameter * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TemplateParameter);
4353
4354 __ecereInstance1->identifier = MkIdentifier(p->name), __ecereInstance1->type = p->type, __ecereInstance1->dataTypeString = p->__anon1.dataTypeString, __ecereInstance1;
4355 });
4356 }
4357 type = __extension__ ({
4358 struct TemplatedType * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TemplatedType);
4359
4360 __ecereInstance1->key = (uintptr_t)p->name, __ecereInstance1->param = param, __ecereInstance1;
4361 });
4362 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&curContext->templateTypes, (struct __ecereNameSpace__ecere__sys__BTNode *)type);
4363 }
4364 }
4365 }
4366 }
4367 return context;
4368 }
4369
4370 extern void PopContext(struct Context * ctx);
4371
4372 extern void FreeContext(struct Context * context);
4373
4374 void FinishTemplatesContext(struct Context * context)
4375 {
4376 PopContext(context);
4377 FreeContext(context);
4378 ((context ? (__ecereClass_Context->Destructor ? __ecereClass_Context->Destructor((void *)context) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(context)) : 0), context = 0);
4379 }
4380
4381 void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method)
4382 {
4383 if(!method->dataType)
4384 {
4385 struct Context * context = SetupTemplatesContext(method->_class);
4386
4387 method->dataType = ProcessTypeString(method->dataTypeString, 0);
4388 FinishTemplatesContext(context);
4389 if(method->type != 1 && method->dataType)
4390 {
4391 if(!method->dataType->__anon1.__anon2.thisClass && !method->dataType->__anon1.__anon2.staticMethod)
4392 {
4393 if(!method->_class->symbol)
4394 method->_class->symbol = FindClass(method->_class->fullName);
4395 method->dataType->__anon1.__anon2.thisClass = method->_class->symbol;
4396 }
4397 }
4398 }
4399 }
4400
4401 void ProcessPropertyType(struct __ecereNameSpace__ecere__com__Property * prop)
4402 {
4403 if(!prop->dataType)
4404 {
4405 struct Context * context = SetupTemplatesContext(prop->_class);
4406
4407 prop->dataType = ProcessTypeString(prop->dataTypeString, 0);
4408 FinishTemplatesContext(context);
4409 }
4410 }
4411
4412 extern struct Declarator * GetFuncDecl(struct Declarator * decl);
4413
4414 extern void FreeTypeName(struct TypeName * typeName);
4415
4416 static void ProcessDeclarator(struct Declarator * decl);
4417
4418 extern struct __ecereNameSpace__ecere__sys__OldList *  excludedSymbols;
4419
4420 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MethodImport;
4421
4422 struct MethodImport
4423 {
4424 struct MethodImport * prev;
4425 struct MethodImport * next;
4426 char *  name;
4427 unsigned int isVirtual;
4428 } __attribute__ ((gcc_struct));
4429
4430 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
4431
4432 void DeclareMethod(struct __ecereNameSpace__ecere__com__Method * method, const char * name)
4433 {
4434 struct Symbol * symbol = method->symbol;
4435
4436 if(!symbol || (!symbol->__anon2.__anon1.pointerExternal && method->type == 1) || symbol->id > (curExternal ? curExternal->symbol->idCode : -1))
4437 {
4438 unsigned int dllImport = 0;
4439
4440 if(!method->dataType)
4441 method->dataType = ProcessTypeString(method->dataTypeString, 0);
4442 if(!symbol || symbol->_import || method->type == 1)
4443 {
4444 if(!symbol || method->type == 1)
4445 {
4446 struct Symbol * classSym;
4447
4448 if(!method->_class->symbol)
4449 method->_class->symbol = FindClass(method->_class->fullName);
4450 classSym = method->_class->symbol;
4451 if(!classSym->_import)
4452 {
4453 struct ModuleImport * module;
4454
4455 if(method->_class->module && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)method->_class->module + structSize_Instance)))->name)
4456 module = FindModule(method->_class->module);
4457 else
4458 module = mainModule;
4459 classSym->_import = __extension__ ({
4460 struct ClassImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassImport);
4461
4462 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(method->_class->fullName), __ecereInstance1->isRemote = method->_class->isRemote, __ecereInstance1;
4463 });
4464 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&module->classes, classSym->_import);
4465 }
4466 if(!symbol)
4467 {
4468 symbol = method->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
4469 }
4470 if(!symbol->_import)
4471 {
4472 symbol->_import = (struct ClassImport *)__extension__ ({
4473 struct MethodImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_MethodImport);
4474
4475 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(method->name), __ecereInstance1->isVirtual = method->type == 1, __ecereInstance1;
4476 });
4477 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classSym->_import->methods, symbol->_import);
4478 }
4479 if(!symbol)
4480 {
4481 symbol->type = method->dataType;
4482 if(symbol->type)
4483 symbol->type->refCount++;
4484 }
4485 }
4486 if(!method->dataType->dllExport)
4487 {
4488 if((method->_class->module != privateModule || !strcmp(method->_class->name, "float") || !strcmp(method->_class->name, "double")) && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)method->_class->module + structSize_Instance)))->importType != 1)
4489 dllImport = 1;
4490 }
4491 }
4492 if(method->type != 1 && method->dataType)
4493 DeclareType(method->dataType, 1, 1);
4494 if(!symbol->__anon2.__anon1.pointerExternal || symbol->__anon2.__anon1.pointerExternal->type == 0)
4495 {
4496 struct Declaration * decl;
4497 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
4498 struct Declarator * d;
4499 struct Declarator * funcDecl;
4500 struct External * external;
4501
4502 specifiers = MkList();
4503 declarators = MkList();
4504 if(dllImport)
4505 ListAdd(specifiers, MkSpecifier(EXTERN));
4506 else if(method->_class->symbol && ((struct Symbol *)method->_class->symbol)->isStatic)
4507 ListAdd(specifiers, MkSpecifier(STATIC));
4508 if(method->type == 1)
4509 {
4510 ListAdd(specifiers, MkSpecifier(INT));
4511 d = MkDeclaratorIdentifier(MkIdentifier(name));
4512 }
4513 else
4514 {
4515 d = MkDeclaratorIdentifier(MkIdentifier(name));
4516 if(dllImport)
4517 d = MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d));
4518 {
4519 struct Context * context = SetupTemplatesContext(method->_class);
4520
4521 d = SpecDeclFromString(method->dataTypeString, specifiers, d);
4522 FinishTemplatesContext(context);
4523 }
4524 funcDecl = GetFuncDecl(d);
4525 if(dllImport)
4526 {
4527 struct Specifier * spec, * next;
4528
4529 for(spec = (*specifiers).first; spec; spec = next)
4530 {
4531 next = spec->next;
4532 if(spec->type == 5)
4533 {
4534 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*specifiers), spec);
4535 FreeSpecifier(spec);
4536 }
4537 }
4538 }
4539 if(method->dataType && !method->dataType->__anon1.__anon2.staticMethod)
4540 {
4541 if(funcDecl && funcDecl->__anon1.function.parameters && (*funcDecl->__anon1.function.parameters).count)
4542 {
4543 struct __ecereNameSpace__ecere__com__Class * _class = method->dataType->__anon1.__anon2.thisClass ? method->dataType->__anon1.__anon2.thisClass->__anon1.registered : method->_class;
4544 struct TypeName * thisParam = MkTypeName(MkListOne(MkSpecifierName(method->dataType->__anon1.__anon2.thisClass ? method->dataType->__anon1.__anon2.thisClass->string : method->_class->fullName)), (_class && _class->type == 1000) ? MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier("this"))) : MkDeclaratorIdentifier(MkIdentifier("this")));
4545 struct TypeName * firstParam = ((struct TypeName *)(*funcDecl->__anon1.function.parameters).first);
4546 struct Specifier * firstSpec = firstParam->qualifiers ? (*firstParam->qualifiers).first : (((void *)0));
4547
4548 if(firstSpec && firstSpec->type == 0 && firstSpec->__anon1.specifier == VOID && !firstParam->declarator)
4549 {
4550 struct TypeName * param = (*funcDecl->__anon1.function.parameters).first;
4551
4552 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*funcDecl->__anon1.function.parameters), param);
4553 FreeTypeName(param);
4554 }
4555 if(!funcDecl->__anon1.function.parameters)
4556 funcDecl->__anon1.function.parameters = MkList();
4557 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->__anon1.function.parameters), (((void *)0)), thisParam);
4558 }
4559 }
4560 }
4561 ProcessDeclarator(d);
4562 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
4563 decl = MkDeclaration(specifiers, declarators);
4564 ReplaceThisClassSpecifiers(specifiers, method->_class);
4565 if(symbol->__anon2.__anon1.pointerExternal)
4566 {
4567 struct Symbol * functionSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
4568
4569 {
4570 *functionSymbol = *symbol;
4571 functionSymbol->string = __ecereNameSpace__ecere__sys__CopyString(symbol->string);
4572 if(functionSymbol->type)
4573 functionSymbol->type->refCount++;
4574 }
4575 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), functionSymbol);
4576 symbol->__anon2.__anon1.pointerExternal->symbol = functionSymbol;
4577 }
4578 external = MkExternalDeclaration(decl);
4579 if(curExternal)
4580 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal ? curExternal->prev : (((void *)0)), external);
4581 external->symbol = symbol;
4582 symbol->__anon2.__anon1.pointerExternal = external;
4583 }
4584 else if(ast)
4585 {
4586 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon1.pointerExternal, curExternal->prev);
4587 }
4588 symbol->id = curExternal ? curExternal->symbol->idCode : (((int)0x7fffffff));
4589 }
4590 }
4591
4592 char * ReplaceThisClass(struct __ecereNameSpace__ecere__com__Class * _class)
4593 {
4594 if(thisClassParams && _class->templateParams.count && !_class->templateClass)
4595 {
4596 unsigned int first = 1;
4597 int p = 0;
4598 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
4599 int lastParam = -1;
4600 char className[1024];
4601
4602 strcpy(className, _class->fullName);
4603 for(param = _class->templateParams.first; param; param = param->next)
4604 {
4605 {
4606 if(first)
4607 strcat(className, "<");
4608 if(!first)
4609 strcat(className, ", ");
4610 if(lastParam + 1 != p)
4611 {
4612 strcat(className, param->name);
4613 strcat(className, " = ");
4614 }
4615 strcat(className, param->name);
4616 first = 0;
4617 lastParam = p;
4618 }
4619 p++;
4620 }
4621 if(!first)
4622 {
4623 int len = strlen(className);
4624
4625 if(className[len - 1] == '>')
4626 className[len++] = ' ';
4627 className[len++] = '>';
4628 className[len++] = '\0';
4629 }
4630 return __ecereNameSpace__ecere__sys__CopyString(className);
4631 }
4632 else
4633 return __ecereNameSpace__ecere__sys__CopyString(_class->fullName);
4634 }
4635
4636 struct Type * ReplaceThisClassType(struct __ecereNameSpace__ecere__com__Class * _class)
4637 {
4638 struct Type * type;
4639
4640 if(thisClassParams && _class->templateParams.count && !_class->templateClass)
4641 {
4642 unsigned int first = 1;
4643 int p = 0;
4644 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
4645 int lastParam = -1;
4646 char className[1024];
4647
4648 strcpy(className, _class->fullName);
4649 for(param = _class->templateParams.first; param; param = param->next)
4650 {
4651 {
4652 if(first)
4653 strcat(className, "<");
4654 if(!first)
4655 strcat(className, ", ");
4656 if(lastParam + 1 != p)
4657 {
4658 strcat(className, param->name);
4659 strcat(className, " = ");
4660 }
4661 strcat(className, param->name);
4662 first = 0;
4663 lastParam = p;
4664 }
4665 p++;
4666 }
4667 if(!first)
4668 {
4669 int len = strlen(className);
4670
4671 if(className[len - 1] == '>')
4672 className[len++] = ' ';
4673 className[len++] = '>';
4674 className[len++] = '\0';
4675 }
4676 type = MkClassType(className);
4677 }
4678 else
4679 {
4680 type = MkClassType(_class->fullName);
4681 }
4682 return type;
4683 }
4684
4685 void ReplaceThisClassSpecifiers(struct __ecereNameSpace__ecere__sys__OldList * specs, struct __ecereNameSpace__ecere__com__Class * _class)
4686 {
4687 if(specs != (((void *)0)) && _class)
4688 {
4689 struct Specifier * spec;
4690
4691 for(spec = specs->first; spec; spec = spec->next)
4692 {
4693 if(spec->type == 0 && spec->__anon1.specifier == THISCLASS)
4694 {
4695 spec->type = 1;
4696 spec->__anon1.__anon1.name = ReplaceThisClass(_class);
4697 spec->__anon1.__anon1.symbol = FindClass(spec->__anon1.__anon1.name);
4698 }
4699 }
4700 }
4701 }
4702
4703 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
4704
4705 struct __ecereNameSpace__ecere__com__GlobalFunction
4706 {
4707 struct __ecereNameSpace__ecere__com__GlobalFunction * prev;
4708 struct __ecereNameSpace__ecere__com__GlobalFunction * next;
4709 const char *  name;
4710 int (*  function)();
4711 struct __ecereNameSpace__ecere__com__Instance * module;
4712 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
4713 const char *  dataTypeString;
4714 struct Type * dataType;
4715 void *  symbol;
4716 } __attribute__ ((gcc_struct));
4717
4718 extern struct Context * globalContext;
4719
4720 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionImport;
4721
4722 struct FunctionImport
4723 {
4724 struct FunctionImport * prev;
4725 struct FunctionImport * next;
4726 char *  name;
4727 } __attribute__ ((gcc_struct));
4728
4729 unsigned int DeclareFunction(struct __ecereNameSpace__ecere__com__GlobalFunction * function, char * name)
4730 {
4731 struct Symbol * symbol = function->symbol;
4732
4733 if(curExternal && (!symbol || symbol->id > curExternal->symbol->idCode))
4734 {
4735 unsigned int imported = 0;
4736 unsigned int dllImport = 0;
4737
4738 if(!function->dataType)
4739 {
4740 function->dataType = ProcessTypeString(function->dataTypeString, 0);
4741 if(!function->dataType->__anon1.__anon2.thisClass)
4742 function->dataType->__anon1.__anon2.staticMethod = 1;
4743 }
4744 if(inCompiler)
4745 {
4746 if(!symbol)
4747 {
4748 struct ModuleImport * module = FindModule(function->module);
4749
4750 symbol = function->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
4751 if(module->name)
4752 {
4753 if(!function->dataType->dllExport)
4754 {
4755 symbol->_import = (struct ClassImport *)__extension__ ({
4756 struct FunctionImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_FunctionImport);
4757
4758 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(function->name), __ecereInstance1;
4759 });
4760 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&module->functions, symbol->_import);
4761 }
4762 }
4763 {
4764 symbol->type = ProcessTypeString(function->dataTypeString, 0);
4765 if(!symbol->type->__anon1.__anon2.thisClass)
4766 symbol->type->__anon1.__anon2.staticMethod = 1;
4767 }
4768 }
4769 imported = symbol->_import ? 1 : 0;
4770 if(imported && function->module != privateModule && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)function->module + structSize_Instance)))->importType != 1)
4771 dllImport = 1;
4772 }
4773 DeclareType(function->dataType, 1, 1);
4774 if(inCompiler)
4775 {
4776 if(!symbol->__anon2.__anon1.pointerExternal || symbol->__anon2.__anon1.pointerExternal->type == 0)
4777 {
4778 struct Declaration * decl;
4779 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
4780 struct Declarator * d;
4781 struct Declarator * funcDecl;
4782 struct External * external;
4783
4784 specifiers = MkList();
4785 declarators = MkList();
4786 ListAdd(specifiers, MkSpecifier(EXTERN));
4787 d = MkDeclaratorIdentifier(MkIdentifier(imported ? name : function->name));
4788 if(dllImport)
4789 d = MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d));
4790 d = SpecDeclFromString(function->dataTypeString, specifiers, d);
4791 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)function->module + structSize_Instance)))->importType == 1)
4792 {
4793 struct Specifier * spec;
4794
4795 for(spec = (*specifiers).first; spec; spec = spec->next)
4796 if(spec->type == 5 && spec->__anon1.__anon1.extDecl && spec->__anon1.__anon1.extDecl->type == 0 && !strcmp(spec->__anon1.__anon1.extDecl->__anon1.s, "dllexport"))
4797 {
4798 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*specifiers), spec);
4799 FreeSpecifier(spec);
4800 break;
4801 }
4802 }
4803 funcDecl = GetFuncDecl(d);
4804 if(funcDecl && !funcDecl->__anon1.function.parameters)
4805 {
4806 funcDecl->__anon1.function.parameters = MkList();
4807 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->__anon1.function.parameters), (((void *)0)), MkTypeName(MkListOne(MkSpecifier(VOID)), (((void *)0))));
4808 }
4809 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
4810 {
4811 struct Context * oldCtx = curContext;
4812
4813 curContext = globalContext;
4814 decl = MkDeclaration(specifiers, declarators);
4815 curContext = oldCtx;
4816 }
4817 if(symbol->__anon2.__anon1.pointerExternal)
4818 {
4819 struct Symbol * functionSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
4820
4821 {
4822 *functionSymbol = *symbol;
4823 functionSymbol->string = __ecereNameSpace__ecere__sys__CopyString(symbol->string);
4824 if(functionSymbol->type)
4825 functionSymbol->type->refCount++;
4826 }
4827 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*excludedSymbols), functionSymbol);
4828 symbol->__anon2.__anon1.pointerExternal->symbol = functionSymbol;
4829 }
4830 external = MkExternalDeclaration(decl);
4831 if(curExternal)
4832 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, external);
4833 external->symbol = symbol;
4834 symbol->__anon2.__anon1.pointerExternal = external;
4835 }
4836 else
4837 {
4838 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon1.pointerExternal, curExternal->prev);
4839 }
4840 if(curExternal)
4841 symbol->id = curExternal->symbol->idCode;
4842 }
4843 }
4844 return (symbol && symbol->_import && function->module != privateModule && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)function->module + structSize_Instance)))->importType != 1) ? 1 : 0;
4845 }
4846
4847 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_GlobalData;
4848
4849 struct GlobalData
4850 {
4851 uintptr_t key;
4852 struct __ecereNameSpace__ecere__sys__BTNode * parent;
4853 struct __ecereNameSpace__ecere__sys__BTNode * left;
4854 struct __ecereNameSpace__ecere__sys__BTNode * right;
4855 int depth;
4856 struct __ecereNameSpace__ecere__com__Instance * module;
4857 char *  dataTypeString;
4858 struct Type * dataType;
4859 void *  symbol;
4860 char *  fullName;
4861 } __attribute__ ((gcc_struct));
4862
4863 void DeclareGlobalData(struct GlobalData * data)
4864 {
4865 struct Symbol * symbol = data->symbol;
4866
4867 if(curExternal && (!symbol || symbol->id > curExternal->symbol->idCode))
4868 {
4869 if(inCompiler)
4870 {
4871 if(!symbol)
4872 symbol = data->symbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
4873 }
4874 if(!data->dataType)
4875 data->dataType = ProcessTypeString(data->dataTypeString, 0);
4876 DeclareType(data->dataType, 1, 1);
4877 if(inCompiler)
4878 {
4879 if(!symbol->__anon2.__anon1.pointerExternal)
4880 {
4881 struct Declaration * decl;
4882 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
4883 struct Declarator * d;
4884 struct External * external;
4885
4886 specifiers = MkList();
4887 declarators = MkList();
4888 ListAdd(specifiers, MkSpecifier(EXTERN));
4889 d = MkDeclaratorIdentifier(MkIdentifier(data->fullName));
4890 d = SpecDeclFromString(data->dataTypeString, specifiers, d);
4891 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
4892 decl = MkDeclaration(specifiers, declarators);
4893 external = MkExternalDeclaration(decl);
4894 if(curExternal)
4895 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, external);
4896 external->symbol = symbol;
4897 symbol->__anon2.__anon1.pointerExternal = external;
4898 }
4899 else
4900 {
4901 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon1.pointerExternal, curExternal->prev);
4902 }
4903 if(curExternal)
4904 symbol->id = curExternal->symbol->idCode;
4905 }
4906 }
4907 }
4908
4909 struct Conversion
4910 {
4911 struct Conversion * prev, * next;
4912 struct __ecereNameSpace__ecere__com__Property * convert;
4913 unsigned int isGet;
4914 struct Type * resultType;
4915 } __attribute__ ((gcc_struct));
4916
4917 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_Conversion;
4918
4919 extern void Compiler_Warning(const char *  format, ...);
4920
4921 static unsigned int CheckConstCompatibility(struct Type * source, struct Type * dest, unsigned int warn)
4922 {
4923 unsigned int status = 1;
4924
4925 if(((source->kind == 8 && source->__anon1._class && source->__anon1._class->__anon1.registered) || source->kind == 12 || source->kind == 13) && ((dest->kind == 8 && dest->__anon1._class && dest->__anon1._class->__anon1.registered) || dest->kind == 13))
4926 {
4927 struct __ecereNameSpace__ecere__com__Class * sourceClass = source->kind == 8 ? source->__anon1._class->__anon1.registered : (((void *)0));
4928 struct __ecereNameSpace__ecere__com__Class * destClass = dest->kind == 8 ? dest->__anon1._class->__anon1.registered : (((void *)0));
4929
4930 if((!sourceClass || (sourceClass && sourceClass->type == 0 && !sourceClass->structSize)) && (!destClass || (destClass && destClass->type == 0 && !destClass->structSize)))
4931 {
4932 struct Type * sourceType = source, * destType = dest;
4933
4934 while((sourceType->kind == 13 || sourceType->kind == 12) && sourceType->__anon1.type)
4935 sourceType = sourceType->__anon1.type;
4936 while((destType->kind == 13 || destType->kind == 12) && destType->__anon1.type)
4937 destType = destType->__anon1.type;
4938 if(!destType->constant && sourceType->constant)
4939 {
4940 status = 0;
4941 if(warn)
4942 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "discarding const qualifier\n", (((void *)0))));
4943 }
4944 }
4945 }
4946 return status;
4947 }
4948
4949 extern void CopyTypeInto(struct Type * type, struct Type * src);
4950
4951 void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
4952
4953 unsigned int MatchTypes(struct Type * source, struct Type * dest, struct __ecereNameSpace__ecere__sys__OldList * conversions, struct __ecereNameSpace__ecere__com__Class * owningClassSource, struct __ecereNameSpace__ecere__com__Class * owningClassDest, unsigned int doConversion, unsigned int enumBaseType, unsigned int acceptReversedParams, unsigned int isConversionExploration, unsigned int warnConst)
4954 {
4955 if(source && dest)
4956 {
4957 if(warnConst)
4958 CheckConstCompatibility(source, dest, 1);
4959 if(source->kind == 20 && dest->kind != 20)
4960 {
4961 struct Type * type = ProcessTemplateParameterType(source->__anon1.templateParameter);
4962
4963 if(type)
4964 source = type;
4965 }
4966 if(dest->kind == 20 && source->kind != 20)
4967 {
4968 struct Type * type = ProcessTemplateParameterType(dest->__anon1.templateParameter);
4969
4970 if(type)
4971 dest = type;
4972 }
4973 if(dest->classObjectType == 2 && dest->kind != 11)
4974 {
4975 if(source->classObjectType != 3)
4976 return 1;
4977 else
4978 {
4979 if((dest->__anon1._class && strcmp(dest->__anon1._class->string, "class")) || (source->__anon1._class && strcmp(source->__anon1._class->string, "class")))
4980 {
4981 return 1;
4982 }
4983 }
4984 }
4985 else
4986 {
4987 if(source->kind != 11 && source->classObjectType == 3)
4988 return 1;
4989 if(dest->kind != 11 && dest->classObjectType == 3 && source->classObjectType != 2)
4990 return 1;
4991 }
4992 if((dest->kind == 9 && source->kind == 9) || (dest->kind == 10 && source->kind == 10))
4993 {
4994 if((dest->__anon1.__anon1.enumName && source->__anon1.__anon1.enumName && !strcmp(dest->__anon1.__anon1.enumName, source->__anon1.__anon1.enumName)) || (source->__anon1.__anon1.members.first && source->__anon1.__anon1.members.first == dest->__anon1.__anon1.members.first))
4995 return 1;
4996 }
4997 if(dest->kind == 14 && source->kind != 0)
4998 return 1;
4999 if(dest->kind == 13 && dest->__anon1.type->kind == 0 && ((source->kind == 8 && (!source->__anon1._class || !source->__anon1._class->__anon1.registered || source->__anon1._class->__anon1.registered->type == 1 || source->__anon1._class->__anon1.registered->type == 0 || source->__anon1._class->__anon1.registered->type == 5 || source->__anon1._class->__anon1.registered->type == 1000)) || source->kind == 19 || source->kind == 13 || source->kind == 12 || source->kind == 11 || source->kind == 21))
5000 return 1;
5001 if(!isConversionExploration && source->kind == 13 && source->__anon1.type->kind == 0 && ((dest->kind == 8 && (!dest->__anon1._class || !dest->__anon1._class->__anon1.registered || dest->__anon1._class->__anon1.registered->type == 1 || dest->__anon1._class->__anon1.registered->type == 0 || dest->__anon1._class->__anon1.registered->type == 5 || dest->__anon1._class->__anon1.registered->type == 1000)) || dest->kind == 19 || dest->kind == 13 || dest->kind == 12 || dest->kind == 11 || dest->kind == 21))
5002 return 1;
5003 if(((source->kind == 8 && dest->kind == 8) || (source->kind == 19 && dest->kind == 19)) && source->__anon1._class)
5004 {
5005 if(source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered->type == 3)
5006 {
5007 if(conversions != (((void *)0)))
5008 {
5009 if(source->__anon1._class->__anon1.registered == dest->__anon1._class->__anon1.registered)
5010 return 1;
5011 }
5012 else
5013 {
5014 struct __ecereNameSpace__ecere__com__Class * sourceBase, * destBase;
5015
5016 for(sourceBase = source->__anon1._class->__anon1.registered; sourceBase && sourceBase->base->type != 1000; sourceBase = sourceBase->base)
5017 ;
5018 for(destBase = dest->__anon1._class->__anon1.registered; destBase && destBase->base->type != 1000; destBase = destBase->base)
5019 ;
5020 if(sourceBase == destBase)
5021 return 1;
5022 }
5023 }
5024 else if(source->__anon1._class && dest->__anon1._class && (dest->classObjectType == source->classObjectType || !dest->classObjectType) && (enumBaseType || (!source->__anon1._class->__anon1.registered || source->__anon1._class->__anon1.registered->type != 4) || (!dest->__anon1._class->__anon1.registered || dest->__anon1._class->__anon1.registered->type != 4)) && __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, dest->__anon1._class->__anon1.registered))
5025 return 1;
5026 else
5027 {
5028 if(enumBaseType && dest->__anon1._class && dest->__anon1._class->__anon1.registered && dest->__anon1._class->__anon1.registered->type == 4 && ((source->__anon1._class && source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered->type != 4) || source->kind == 8))
5029 {
5030 if(__ecereNameSpace__ecere__com__eClass_IsDerived(dest->__anon1._class->__anon1.registered, source->__anon1._class->__anon1.registered))
5031 {
5032 return 1;
5033 }
5034 }
5035 }
5036 }
5037 if(source->kind == 19 && dest->kind == 8 && dest->__anon1._class && !strcmp(dest->__anon1._class->string, "ecere::com::Class"))
5038 return 1;
5039 if(doConversion)
5040 {
5041 if(source->kind == 8)
5042 {
5043 struct __ecereNameSpace__ecere__com__Class * _class;
5044
5045 for(_class = source->__anon1._class ? source->__anon1._class->__anon1.registered : (((void *)0)); _class; _class = _class->base)
5046 {
5047 struct __ecereNameSpace__ecere__com__Property * convert;
5048
5049 for(convert = _class->conversions.first; convert; convert = convert->next)
5050 {
5051 if(convert->memberAccess == 1 || _class->module == privateModule)
5052 {
5053 struct Conversion * after = (conversions != (((void *)0))) ? conversions->last : (((void *)0));
5054
5055 if(!convert->dataType)
5056 convert->dataType = ProcessTypeString(convert->dataTypeString, 0);
5057 if((!isConversionExploration || convert->dataType->kind == 8 || !strcmp(_class->name, "String")) && MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), (convert->dataType->kind == 8 && !strcmp(convert->dataTypeString, "String")) ? 1 : 0, convert->dataType->kind == 8, 0, 1, warnConst))
5058 {
5059 if(!conversions && !convert->Get)
5060 return 1;
5061 else if(conversions != (((void *)0)))
5062 {
5063 if(_class->type == 3 && convert->dataType->kind == 8 && convert->dataType->__anon1._class && convert->dataType->__anon1._class->__anon1.registered && _class->base == convert->dataType->__anon1._class->__anon1.registered->base && (dest->kind != 8 || dest->__anon1._class->__anon1.registered != _class->base))
5064 return 1;
5065 else
5066 {
5067 struct Conversion * conv = (conv = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Conversion), conv->convert = convert, conv->isGet = 1, conv);
5068
5069 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(conversions, after, conv);
5070 return 1;
5071 }
5072 }
5073 }
5074 }
5075 }
5076 }
5077 }
5078 if(dest->kind == 8)
5079 {
5080 struct __ecereNameSpace__ecere__com__Class * _class;
5081
5082 for(_class = dest->__anon1._class ? dest->__anon1._class->__anon1.registered : (((void *)0)); _class; _class = _class->base)
5083 {
5084 struct __ecereNameSpace__ecere__com__Property * convert;
5085
5086 for(convert = _class->conversions.first; convert; convert = convert->next)
5087 {
5088 if(convert->memberAccess == 1 || _class->module == privateModule)
5089 {
5090 struct Type * constType = (((void *)0));
5091 unsigned int success = 0;
5092
5093 if(!convert->dataType)
5094 convert->dataType = ProcessTypeString(convert->dataTypeString, 0);
5095 if(warnConst && convert->dataType->kind == 13 && convert->dataType->__anon1.type && dest->constant)
5096 {
5097 struct Type * ptrType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5098
5099 constType = __extension__ ({
5100 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5101
5102 __ecereInstance1->kind = 13, __ecereInstance1->refCount = 1, __ecereInstance1->__anon1.type = ptrType, __ecereInstance1;
5103 });
5104 CopyTypeInto(ptrType, convert->dataType->__anon1.type);
5105 ptrType->constant = 1;
5106 }
5107 if((constType || convert->dataType != dest) && MatchTypes(source, constType ? constType : convert->dataType, conversions, (((void *)0)), (((void *)0)), 1, 0, 0, 1, warnConst))
5108 {
5109 if(!conversions && !convert->Set)
5110 success = 1;
5111 else if(conversions != (((void *)0)))
5112 {
5113 if(_class->type == 3 && convert->dataType->kind == 8 && convert->dataType->__anon1._class && convert->dataType->__anon1._class->__anon1.registered && _class->base == convert->dataType->__anon1._class->__anon1.registered->base && (source->kind != 8 || source->__anon1._class->__anon1.registered != _class->base))
5114 success = 1;
5115 else
5116 {
5117 struct Conversion * conv = (conv = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Conversion), conv->convert = convert, conv);
5118
5119 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(conversions, conv);
5120 success = 1;
5121 }
5122 }
5123 }
5124 if(constType)
5125 FreeType(constType);
5126 if(success)
5127 return 1;
5128 }
5129 }
5130 }
5131 if(enumBaseType && dest->__anon1._class && dest->__anon1._class->__anon1.registered && dest->__anon1._class->__anon1.registered->type == 4)
5132 {
5133 if(!dest->__anon1._class->__anon1.registered->dataType)
5134 dest->__anon1._class->__anon1.registered->dataType = ProcessTypeString(dest->__anon1._class->__anon1.registered->dataTypeString, 0);
5135 if(dest->__anon1._class->__anon1.registered->dataType->kind == 8 || source->truth || dest->truth)
5136 {
5137 if(MatchTypes(source, dest->__anon1._class->__anon1.registered->dataType, conversions, (((void *)0)), (((void *)0)), 1, dest->__anon1._class->__anon1.registered->dataType->kind == 8, 0, 0, warnConst))
5138 {
5139 return 1;
5140 }
5141 }
5142 }
5143 }
5144 if(source->kind == 8)
5145 {
5146 struct __ecereNameSpace__ecere__com__Class * _class;
5147
5148 for(_class = source->__anon1._class ? source->__anon1._class->__anon1.registered : (((void *)0)); _class; _class = _class->base)
5149 {
5150 struct __ecereNameSpace__ecere__com__Property * convert;
5151
5152 for(convert = _class->conversions.first; convert; convert = convert->next)
5153 {
5154 if(convert->memberAccess == 1 || _class->module == privateModule)
5155 {
5156 struct Conversion * after = (conversions != (((void *)0))) ? conversions->last : (((void *)0));
5157
5158 if(!convert->dataType)
5159 convert->dataType = ProcessTypeString(convert->dataTypeString, 0);
5160 if(convert->dataType != source && (!isConversionExploration || convert->dataType->kind == 8 || !strcmp(_class->name, "String")) && MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), convert->dataType->kind == 8, convert->dataType->kind == 8, 0, 1, warnConst))
5161 {
5162 if(!conversions && !convert->Get)
5163 return 1;
5164 else if(conversions != (((void *)0)))
5165 {
5166 if(_class->type == 3 && convert->dataType->kind == 8 && convert->dataType->__anon1._class && convert->dataType->__anon1._class->__anon1.registered && _class->base == convert->dataType->__anon1._class->__anon1.registered->base && (dest->kind != 8 || dest->__anon1._class->__anon1.registered != _class->base))
5167 return 1;
5168 else
5169 {
5170 struct Conversion * conv = (conv = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Conversion), conv->convert = convert, conv->isGet = 1, conv);
5171
5172 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(conversions, after, conv);
5173 return 1;
5174 }
5175 }
5176 }
5177 }
5178 }
5179 }
5180 if(enumBaseType && source->__anon1._class && source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered->type == 4)
5181 {
5182 if(!source->__anon1._class->__anon1.registered->dataType)
5183 source->__anon1._class->__anon1.registered->dataType = ProcessTypeString(source->__anon1._class->__anon1.registered->dataTypeString, 0);
5184 if(!isConversionExploration || source->__anon1._class->__anon1.registered->dataType->kind == 8 || !strcmp(source->__anon1._class->__anon1.registered->name, "String"))
5185 {
5186 if(MatchTypes(source->__anon1._class->__anon1.registered->dataType, dest, conversions, (((void *)0)), (((void *)0)), source->__anon1._class->__anon1.registered->dataType->kind == 8, source->__anon1._class->__anon1.registered->dataType->kind == 8, 0, 0, warnConst))
5187 return 1;
5188 else if(MatchTypes(dest, source->__anon1._class->__anon1.registered->dataType, (((void *)0)), (((void *)0)), (((void *)0)), 0, 0, 0, 0, warnConst))
5189 return 1;
5190 }
5191 }
5192 }
5193 }
5194 if(source->kind == 8 || source->kind == 19)
5195 ;
5196 else if(dest->kind == source->kind && (dest->kind != 9 && dest->kind != 10 && dest->kind != 11 && dest->kind != 12 && dest->kind != 13 && dest->kind != 16))
5197 return 1;
5198 else if(dest->kind == 7 && source->kind == 6)
5199 return 1;
5200 else if(dest->kind == 2 && (source->kind == 1 || source->kind == 24))
5201 return 1;
5202 else if(dest->kind == 3 && (source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 23))
5203 return 1;
5204 else if(dest->kind == 4 && (source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 3 || source->kind == 22 || source->kind == 23))
5205 return 1;
5206 else if(dest->kind == 22 && (source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 3 || source->kind == 23 || source->kind == 4))
5207 return 1;
5208 else if(dest->kind == 23 && (source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 3 || source->kind == 4 || source->kind == 22))
5209 return 1;
5210 else if(source->kind == 15 && (dest->kind == 3 || dest->kind == 2 || dest->kind == 1 || source->kind == 24 || dest->kind == 5 || dest->kind == 4 || dest->kind == 22 || dest->kind == 23))
5211 return 1;
5212 else if(dest->kind == 15 && !isConversionExploration && (source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 5 || source->kind == 4 || source->kind == 22 || source->kind == 23))
5213 return 1;
5214 else if((dest->kind == 11 || (dest->kind == 13 && dest->__anon1.type->kind == 11) || dest->kind == 16) && ((source->kind == 11 || (source->kind == 13 && source->__anon1.type->kind == 11) || source->kind == 16)))
5215 {
5216 struct Type * paramSource, * paramDest;
5217
5218 if(dest->kind == 16)
5219 owningClassDest = dest->__anon1.__anon3.methodClass ? dest->__anon1.__anon3.methodClass : dest->__anon1.__anon3.method->_class;
5220 if(source->kind == 16)
5221 owningClassSource = source->__anon1.__anon3.methodClass ? source->__anon1.__anon3.methodClass : source->__anon1.__anon3.method->_class;
5222 if(dest->kind == 13 && dest->__anon1.type->kind == 11)
5223 dest = dest->__anon1.type;
5224 if(source->kind == 13 && source->__anon1.type->kind == 11)
5225 source = source->__anon1.type;
5226 if(dest->kind == 16)
5227 dest = dest->__anon1.__anon3.method->dataType;
5228 if(source->kind == 16)
5229 source = source->__anon1.__anon3.method->dataType;
5230 paramSource = source->__anon1.__anon2.params.first;
5231 if(paramSource && paramSource->kind == 0)
5232 paramSource = (((void *)0));
5233 paramDest = dest->__anon1.__anon2.params.first;
5234 if(paramDest && paramDest->kind == 0)
5235 paramDest = (((void *)0));
5236 if((dest->__anon1.__anon2.staticMethod || (!dest->__anon1.__anon2.thisClass && !owningClassDest)) && !(source->__anon1.__anon2.staticMethod || (!source->__anon1.__anon2.thisClass && !owningClassSource)))
5237 {
5238 if(!paramDest || (!(paramDest->kind == 13 && paramDest->__anon1.type && paramDest->__anon1.type->kind == 0) && (paramDest->kind != 8 || !__ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1.__anon2.thisClass ? source->__anon1.__anon2.thisClass->__anon1.registered : owningClassSource, paramDest->__anon1._class->__anon1.registered))))
5239 {
5240 if(paramDest && paramDest->kind == 8)
5241 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), paramDest->__anon1._class->string);
5242 else
5243 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class should not take an object\n", (((void *)0))));
5244 return 0;
5245 }
5246 paramDest = paramDest->next;
5247 }
5248 else if(!dest->__anon1.__anon2.staticMethod && (dest->__anon1.__anon2.thisClass || owningClassDest))
5249 {
5250 if((source->__anon1.__anon2.staticMethod || (!source->__anon1.__anon2.thisClass && !owningClassSource)))
5251 {
5252 if(dest->__anon1.__anon2.thisClass)
5253 {
5254 if(!paramSource || paramSource->kind != 8 || !__ecereNameSpace__ecere__com__eClass_IsDerived(paramSource->__anon1._class->__anon1.registered, dest->__anon1.__anon2.thisClass->__anon1.registered))
5255 {
5256 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), dest->__anon1.__anon2.thisClass->string);
5257 return 0;
5258 }
5259 }
5260 else
5261 {
5262 if(!paramSource || paramSource->kind != 8 || (owningClassDest && !__ecereNameSpace__ecere__com__eClass_IsDerived(paramSource->__anon1._class->__anon1.registered, owningClassDest)))
5263 {
5264 if(owningClassDest)
5265 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s expected to be derived from method class\n", (((void *)0))), owningClassDest->fullName);
5266 else
5267 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "overriding class expected to be derived from method class\n", (((void *)0))));
5268 return 0;
5269 }
5270 }
5271 paramSource = paramSource->next;
5272 }
5273 else
5274 {
5275 if(dest->__anon1.__anon2.thisClass)
5276 {
5277 if(!__ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1.__anon2.thisClass ? source->__anon1.__anon2.thisClass->__anon1.registered : owningClassSource, dest->__anon1.__anon2.thisClass->__anon1.registered))
5278 {
5279 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), dest->__anon1.__anon2.thisClass->string);
5280 return 0;
5281 }
5282 }
5283 else
5284 {
5285 if(source->__anon1.__anon2.thisClass && source->__anon1.__anon2.thisClass->__anon1.registered && owningClassDest && !__ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1.__anon2.thisClass->__anon1.registered, owningClassDest))
5286 {
5287 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s expected to be derived from method class\n", (((void *)0))), source->__anon1.__anon2.thisClass->__anon1.registered->fullName);
5288 return 0;
5289 }
5290 }
5291 }
5292 }
5293 if(!MatchTypes(source->__anon1.__anon2.returnType, dest->__anon1.__anon2.returnType, (((void *)0)), (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst))
5294 {
5295 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible return type for function\n", (((void *)0))));
5296 return 0;
5297 }
5298 else
5299 CheckConstCompatibility(dest->__anon1.__anon2.returnType, source->__anon1.__anon2.returnType, 1);
5300 for(; paramDest; paramDest = paramDest->next)
5301 {
5302 if(!paramSource)
5303 {
5304 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough parameters\n", (((void *)0))));
5305 return 0;
5306 }
5307 {
5308 struct Type * paramDestType = paramDest;
5309 struct Type * paramSourceType = paramSource;
5310 struct Type * type = paramDestType;
5311
5312 if(paramDest->kind == 20 && paramDest->__anon1.templateParameter->type == 0 && owningClassSource && paramSource->kind != 20)
5313 {
5314 int id = 0;
5315 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
5316 struct __ecereNameSpace__ecere__com__Class * sClass;
5317
5318 for(sClass = owningClassSource; sClass; sClass = sClass->base)
5319 {
5320 id = 0;
5321 if(sClass->templateClass)
5322 sClass = sClass->templateClass;
5323 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
5324 {
5325 if(curParam->type == 0 && !strcmp(type->__anon1.templateParameter->identifier->string, curParam->name))
5326 {
5327 for(sClass = sClass->base; sClass; sClass = sClass->base)
5328 {
5329 if(sClass->templateClass)
5330 sClass = sClass->templateClass;
5331 id += sClass->templateParams.count;
5332 }
5333 break;
5334 }
5335 id++;
5336 }
5337 if(curParam)
5338 break;
5339 }
5340 if(curParam)
5341 {
5342 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg = owningClassSource->templateArgs[id];
5343
5344 paramDestType = type = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
5345 }
5346 }
5347 if(!MatchTypes(paramDestType, paramSourceType, (((void *)0)), (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst) && (!acceptReversedParams || !MatchTypes(paramSourceType, paramDestType, (((void *)0)), (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst)))
5348 {
5349 char type[1024];
5350
5351 type[0] = (char)0;
5352 PrintType(paramDest, type, 0, 1);
5353 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible parameter %s (expected %s)\n", (((void *)0))), paramSource->name, type);
5354 if(paramDestType != paramDest)
5355 FreeType(paramDestType);
5356 return 0;
5357 }
5358 if(paramDestType != paramDest)
5359 FreeType(paramDestType);
5360 }
5361 paramSource = paramSource->next;
5362 }
5363 if(paramSource)
5364 {
5365 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many parameters\n", (((void *)0))));
5366 return 0;
5367 }
5368 return 1;
5369 }
5370 else if((dest->kind == 11 || (dest->kind == 13 && dest->__anon1.type->kind == 11) || dest->kind == 16) && (source->kind == 13 && source->__anon1.type->kind == 0))
5371 {
5372 return 1;
5373 }
5374 else if((dest->kind == 13 || dest->kind == 12) && (source->kind == 12 || source->kind == 13))
5375 {
5376 if(!(dest->__anon1.type && dest->__anon1.type->kind == 13 && source->__anon1.type->kind == 8 && source->__anon1.type->__anon1._class && source->__anon1.type->__anon1._class->__anon1.registered && (source->__anon1.type->__anon1._class->__anon1.registered->type != 0 && source->__anon1.type->__anon1._class->__anon1.registered->type != 5) && !source->__anon1.type->byReference))
5377 {
5378 ComputeTypeSize(source->__anon1.type);
5379 ComputeTypeSize(dest->__anon1.type);
5380 if(source->__anon1.type->size == dest->__anon1.type->size && MatchTypes(source->__anon1.type, dest->__anon1.type, (((void *)0)), (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst))
5381 return 1;
5382 }
5383 }
5384 }
5385 return 0;
5386 }
5387
5388 static void FreeConvert(struct Conversion * convert)
5389 {
5390 if(convert->resultType)
5391 FreeType(convert->resultType);
5392 }
5393
5394 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BTNamedLink;
5395
5396 struct __ecereNameSpace__ecere__com__BTNamedLink
5397 {
5398 const char *  name;
5399 struct __ecereNameSpace__ecere__com__BTNamedLink * parent;
5400 struct __ecereNameSpace__ecere__com__BTNamedLink * left;
5401 struct __ecereNameSpace__ecere__com__BTNamedLink * right;
5402 int depth;
5403 void *  data;
5404 } __attribute__ ((gcc_struct));
5405
5406 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
5407
5408 struct __ecereNameSpace__ecere__com__EnumClassData
5409 {
5410 struct __ecereNameSpace__ecere__sys__OldList values;
5411 long long largest;
5412 } __attribute__ ((gcc_struct));
5413
5414 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink64;
5415
5416 struct __ecereNameSpace__ecere__sys__NamedLink64
5417 {
5418 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
5419 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
5420 char *  name;
5421 long long data;
5422 } __attribute__ ((gcc_struct));
5423
5424 extern void FreeExpContents(struct Expression * exp);
5425
5426 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(struct __ecereNameSpace__ecere__sys__BinaryTree * this);
5427
5428 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_first;
5429
5430 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(struct __ecereNameSpace__ecere__sys__BTNode * this);
5431
5432 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__sys__BTNode_next;
5433
5434 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
5435
5436 unsigned int MatchWithEnums_NameSpace(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace, struct Expression * sourceExp, struct Type * dest, char * string, struct __ecereNameSpace__ecere__sys__OldList * conversions)
5437 {
5438 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
5439
5440 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&nameSpace->classes); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
5441 {
5442 struct __ecereNameSpace__ecere__com__Class * _class = link->data;
5443
5444 if(_class->type == 4)
5445 {
5446 struct __ecereNameSpace__ecere__sys__OldList converts =
5447 {
5448 0, 0, 0, 0, 0
5449 };
5450 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5451
5452 type->kind = 8;
5453 if(!_class->symbol)
5454 _class->symbol = FindClass(_class->fullName);
5455 type->__anon1._class = _class->symbol;
5456 if(MatchTypes(type, dest, &converts, (((void *)0)), (((void *)0)), dest->kind != 8 || !dest->__anon1._class || strcmp(dest->__anon1._class->string, "bool"), 0, 0, 0, 0))
5457 {
5458 struct __ecereNameSpace__ecere__sys__NamedLink64 * value;
5459 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
5460
5461 if(enumClass)
5462 {
5463 struct __ecereNameSpace__ecere__com__Class * baseClass;
5464
5465 for(baseClass = _class; baseClass && baseClass->type == 4; baseClass = baseClass->base)
5466 {
5467 struct __ecereNameSpace__ecere__com__EnumClassData * e = (baseClass ? ((void *)(((char *)baseClass->data) + enumClass->offsetClass)) : (((void *)0)));
5468
5469 for(value = e->values.first; value; value = value->next)
5470 {
5471 if(!strcmp(value->name, string))
5472 break;
5473 }
5474 if(value)
5475 {
5476 FreeExpContents(sourceExp);
5477 FreeType(sourceExp->expType);
5478 sourceExp->isConstant = 1;
5479 sourceExp->expType = MkClassType(baseClass->fullName);
5480 {
5481 char constant[256];
5482
5483 sourceExp->type = 2;
5484 if(!strcmp(baseClass->dataTypeString, "int") || !strcmp(baseClass->dataTypeString, "int64") || !strcmp(baseClass->dataTypeString, "short") || !strcmp(baseClass->dataTypeString, "char"))
5485 sprintf(constant, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), value->data);
5486 else
5487 sprintf(constant, ((__runtimePlatform == 1) ? "0x%I64XLL" : "0x%llXLL"), value->data);
5488 sourceExp->__anon1.__anon1.constant = __ecereNameSpace__ecere__sys__CopyString(constant);
5489 }
5490 while(converts.first)
5491 {
5492 struct Conversion * convert = converts.first;
5493
5494 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&converts, convert);
5495 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(conversions, convert);
5496 }
5497 ((type ? (__ecereClass_Type->Destructor ? __ecereClass_Type->Destructor((void *)type) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(type)) : 0), type = 0);
5498 return 1;
5499 }
5500 }
5501 }
5502 }
5503 if(converts.first)
5504 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&converts, (void *)(FreeConvert));
5505 ((type ? (__ecereClass_Type->Destructor ? __ecereClass_Type->Destructor((void *)type) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(type)) : 0), type = 0);
5506 }
5507 }
5508 for(nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&nameSpace->nameSpaces); nameSpace != (((void *)0)); nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace)))
5509 if(MatchWithEnums_NameSpace(nameSpace, sourceExp, dest, string, conversions))
5510 return 1;
5511 return 0;
5512 }
5513
5514 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SubModule;
5515
5516 struct __ecereNameSpace__ecere__com__SubModule
5517 {
5518 struct __ecereNameSpace__ecere__com__SubModule * prev;
5519 struct __ecereNameSpace__ecere__com__SubModule * next;
5520 struct __ecereNameSpace__ecere__com__Instance * module;
5521 int importMode;
5522 } __attribute__ ((gcc_struct));
5523
5524 unsigned int ModuleVisibility(struct __ecereNameSpace__ecere__com__Instance * searchIn, struct __ecereNameSpace__ecere__com__Instance * searchFor)
5525 {
5526 struct __ecereNameSpace__ecere__com__SubModule * subModule;
5527
5528 if(searchFor == searchIn)
5529 return 1;
5530 for(subModule = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)searchIn + structSize_Instance)))->modules.first; subModule; subModule = subModule->next)
5531 {
5532 if(subModule->importMode == 1 || searchIn == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)searchIn + structSize_Instance)))->application)
5533 {
5534 if(ModuleVisibility(subModule->module, searchFor))
5535 return 1;
5536 }
5537 }
5538 return 0;
5539 }
5540
5541 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Application;
5542
5543 struct __ecereNameSpace__ecere__com__Application
5544 {
5545 int argc;
5546 const char * *  argv;
5547 int exitCode;
5548 unsigned int isGUIApp;
5549 struct __ecereNameSpace__ecere__sys__OldList allModules;
5550 char *  parsedCommand;
5551 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
5552 } __attribute__ ((gcc_struct));
5553
5554 unsigned int MatchWithEnums_Module(struct __ecereNameSpace__ecere__com__Instance * mainModule, struct Expression * sourceExp, struct Type * dest, char * string, struct __ecereNameSpace__ecere__sys__OldList * conversions)
5555 {
5556 struct __ecereNameSpace__ecere__com__Instance * module;
5557
5558 if(MatchWithEnums_NameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)mainModule + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, sourceExp, dest, string, conversions))
5559 return 1;
5560 if(MatchWithEnums_NameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)mainModule + structSize_Instance)))->application + structSize_Instance)))->privateNameSpace, sourceExp, dest, string, conversions))
5561 return 1;
5562 if(MatchWithEnums_NameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)mainModule + structSize_Instance)))->application + structSize_Instance)))->publicNameSpace, sourceExp, dest, string, conversions))
5563 return 1;
5564 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)mainModule + structSize_Instance)))->application + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
5565 {
5566 if(ModuleVisibility(mainModule, module) && MatchWithEnums_NameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace, sourceExp, dest, string, conversions))
5567 return 1;
5568 }
5569 return 0;
5570 }
5571
5572 extern struct Expression * CopyExpression(struct Expression * exp);
5573
5574 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
5575
5576 void ReadString(char *  output, char *  string);
5577
5578 extern struct Specifier * MkEnum(struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * list);
5579
5580 extern struct TypeName * QMkClass(const char *  spec, struct Declarator * decl);
5581
5582 extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__OldList * expressions);
5583
5584 unsigned int MatchTypeExpression(struct Expression * sourceExp, struct Type * dest, struct __ecereNameSpace__ecere__sys__OldList * conversions, unsigned int skipUnitBla, unsigned int warnConst)
5585 {
5586 struct Type * source;
5587 struct Type * realDest = dest;
5588 struct Type * backupSourceExpType = (((void *)0));
5589 struct Expression * computedExp = sourceExp;
5590
5591 dest->refCount++;
5592 if(sourceExp->isConstant && sourceExp->type != 2 && sourceExp->type != 0 && sourceExp->type != 11 && dest->kind == 8 && dest->__anon1._class && dest->__anon1._class->__anon1.registered && dest->__anon1._class->__anon1.registered->type == 4)
5593 {
5594 computedExp = CopyExpression(sourceExp);
5595 ComputeExpression(computedExp);
5596 }
5597 source = sourceExp->expType;
5598 if(dest->kind == 13 && sourceExp->type == 2 && !strtoul(sourceExp->__anon1.__anon1.constant, (((void *)0)), 0))
5599 {
5600 if(computedExp != sourceExp)
5601 {
5602 FreeExpression(computedExp);
5603 computedExp = sourceExp;
5604 }
5605 FreeType(dest);
5606 return 1;
5607 }
5608 if(!skipUnitBla && source && dest && source->kind == 8 && dest->kind == 8)
5609 {
5610 if(source->__anon1._class && source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered->type == 3)
5611 {
5612 struct __ecereNameSpace__ecere__com__Class * sourceBase, * destBase;
5613
5614 for(sourceBase = source->__anon1._class->__anon1.registered; sourceBase && sourceBase->base && sourceBase->base->type != 1000; sourceBase = sourceBase->base)
5615 ;
5616 for(destBase = dest->__anon1._class->__anon1.registered; destBase && destBase->base && destBase->base->type != 1000; destBase = destBase->base)
5617 ;
5618 if(sourceBase == destBase)
5619 {
5620 if(computedExp != sourceExp)
5621 {
5622 FreeExpression(computedExp);
5623 computedExp = sourceExp;
5624 }
5625 FreeType(dest);
5626 return 1;
5627 }
5628 }
5629 }
5630 if(source)
5631 {
5632 struct __ecereNameSpace__ecere__sys__OldList * specs;
5633 unsigned int flag = 0;
5634 long long value = (((int)0x7fffffff));
5635
5636 source->refCount++;
5637 if(computedExp->type == 2)
5638 {
5639 if(source->isSigned)
5640 value = strtoll(computedExp->__anon1.__anon1.constant, (((void *)0)), 0);
5641 else
5642 value = strtoull(computedExp->__anon1.__anon1.constant, (((void *)0)), 0);
5643 }
5644 else if(computedExp->type == 4 && sourceExp->__anon1.op.op == '-' && !computedExp->__anon1.op.exp1 && computedExp->__anon1.op.exp2 && computedExp->__anon1.op.exp2->type == 2)
5645 {
5646 if(source->isSigned)
5647 value = -strtoll(computedExp->__anon1.op.exp2->__anon1.__anon1.constant, (((void *)0)), 0);
5648 else
5649 value = -strtoull(computedExp->__anon1.op.exp2->__anon1.__anon1.constant, (((void *)0)), 0);
5650 }
5651 if(computedExp != sourceExp)
5652 {
5653 FreeExpression(computedExp);
5654 computedExp = sourceExp;
5655 }
5656 if(dest->kind != 8 && source->kind == 8 && source->__anon1._class && source->__anon1._class->__anon1.registered && !strcmp(source->__anon1._class->__anon1.registered->fullName, "ecere::com::unichar"))
5657 {
5658 FreeType(source);
5659 source = __extension__ ({
5660 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5661
5662 __ecereInstance1->kind = 3, __ecereInstance1->isSigned = 0, __ecereInstance1->refCount = 1, __ecereInstance1;
5663 });
5664 }
5665 if(dest->kind == 8)
5666 {
5667 struct __ecereNameSpace__ecere__com__Class * _class = dest->__anon1._class ? dest->__anon1._class->__anon1.registered : (((void *)0));
5668
5669 if(_class && _class->type == 3)
5670 {
5671 if(source->kind != 8)
5672 {
5673 struct Type * tempType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5674 struct Type * tempDest, * tempSource;
5675
5676 for(; _class->base->type != 1000; _class = _class->base)
5677 ;
5678 tempSource = dest;
5679 tempDest = tempType;
5680 tempType->kind = 8;
5681 if(!_class->symbol)
5682 _class->symbol = FindClass(_class->fullName);
5683 tempType->__anon1._class = _class->symbol;
5684 tempType->truth = dest->truth;
5685 if(tempType->__anon1._class)
5686 MatchTypes(tempSource, tempDest, conversions, (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst);
5687 backupSourceExpType = sourceExp->expType;
5688 sourceExp->expType = dest;
5689 dest->refCount++;
5690 flag = 1;
5691 ((tempType ? (__ecereClass_Type->Destructor ? __ecereClass_Type->Destructor((void *)tempType) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(tempType)) : 0), tempType = 0);
5692 }
5693 }
5694 if(_class && _class->type == 2 && source->kind != 8)
5695 {
5696 if(!dest->__anon1._class->__anon1.registered->dataType)
5697 dest->__anon1._class->__anon1.registered->dataType = ProcessTypeString(dest->__anon1._class->__anon1.registered->dataTypeString, 0);
5698 if(MatchTypes(source, dest->__anon1._class->__anon1.registered->dataType, conversions, (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst))
5699 {
5700 FreeType(source);
5701 FreeType(sourceExp->expType);
5702 source = sourceExp->expType = MkClassType(dest->__anon1._class->string);
5703 source->refCount++;
5704 }
5705 }
5706 if(_class && !strcmp(_class->fullName, "ecere::com::Class") && source->kind == 13 && source->__anon1.type && source->__anon1.type->kind == 1 && sourceExp->type == 3)
5707 {
5708 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
5709 struct Declarator * decl;
5710 char string[1024];
5711
5712 ReadString(string, sourceExp->__anon1.__anon2.string);
5713 decl = SpecDeclFromString(string, specs, (((void *)0)));
5714 FreeExpContents(sourceExp);
5715 FreeType(sourceExp->expType);
5716 sourceExp->type = 24;
5717 sourceExp->__anon1._classExp.specifiers = specs;
5718 sourceExp->__anon1._classExp.decl = decl;
5719 sourceExp->expType = dest;
5720 dest->refCount++;
5721 FreeType(source);
5722 FreeType(dest);
5723 if(backupSourceExpType)
5724 FreeType(backupSourceExpType);
5725 return 1;
5726 }
5727 }
5728 else if(source->kind == 8)
5729 {
5730 struct __ecereNameSpace__ecere__com__Class * _class = source->__anon1._class ? source->__anon1._class->__anon1.registered : (((void *)0));
5731
5732 if(_class && (_class->type == 3 || _class->type == 2))
5733 {
5734 if(dest->kind != 8)
5735 {
5736 struct Type * tempType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
5737 struct Type * tempDest, * tempSource;
5738
5739 if(!source->__anon1._class->__anon1.registered->dataType)
5740 source->__anon1._class->__anon1.registered->dataType = ProcessTypeString(source->__anon1._class->__anon1.registered->dataTypeString, 0);
5741 for(; _class->base->type != 1000; _class = _class->base)
5742 ;
5743 tempDest = source;
5744 tempSource = tempType;
5745 tempType->kind = 8;
5746 tempType->__anon1._class = FindClass(_class->fullName);
5747 tempType->truth = source->truth;
5748 tempType->classObjectType = source->classObjectType;
5749 if(tempType->__anon1._class)
5750 MatchTypes(tempSource, tempDest, conversions, (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst);
5751 if(conversions && conversions->last)
5752 {
5753 ((struct Conversion *)conversions->last)->resultType = dest;
5754 dest->refCount++;
5755 }
5756 FreeType(sourceExp->expType);
5757 sourceExp->expType = MkClassType(_class->fullName);
5758 sourceExp->expType->truth = source->truth;
5759 sourceExp->expType->classObjectType = source->classObjectType;
5760 if(!sourceExp->destType)
5761 {
5762 FreeType(sourceExp->destType);
5763 sourceExp->destType = sourceExp->expType;
5764 if(sourceExp->expType)
5765 sourceExp->expType->refCount++;
5766 }
5767 if(!_class->dataType)
5768 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
5769 FreeType(dest);
5770 dest = MkClassType(source->__anon1._class->string);
5771 dest->truth = source->truth;
5772 dest->classObjectType = source->classObjectType;
5773 FreeType(source);
5774 source = _class->dataType;
5775 source->refCount++;
5776 ((tempType ? (__ecereClass_Type->Destructor ? __ecereClass_Type->Destructor((void *)tempType) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(tempType)) : 0), tempType = 0);
5777 }
5778 }
5779 }
5780 if(!flag)
5781 {
5782 if(MatchTypes(source, dest, conversions, (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst))
5783 {
5784 FreeType(source);
5785 FreeType(dest);
5786 return 1;
5787 }
5788 }
5789 if(dest->kind == 8)
5790 {
5791 struct __ecereNameSpace__ecere__com__Class * _class = dest->__anon1._class ? dest->__anon1._class->__anon1.registered : (((void *)0));
5792 unsigned int fittingValue = 0;
5793
5794 if(_class && _class->type == 4)
5795 {
5796 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
5797 struct __ecereNameSpace__ecere__com__EnumClassData * c = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
5798
5799 if(c && value >= 0 && value <= c->largest)
5800 fittingValue = 1;
5801 }
5802 if(_class && !dest->truth && (_class->type == 3 || fittingValue || (_class->type != 1 && !value && source->kind == 3) || _class->type == 2))
5803 {
5804 if(_class->type == 0 || _class->type == 5)
5805 {
5806 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
5807
5808 *newExp = *sourceExp;
5809 if(sourceExp->destType)
5810 sourceExp->destType->refCount++;
5811 if(sourceExp->expType)
5812 sourceExp->expType->refCount++;
5813 sourceExp->type = 11;
5814 sourceExp->__anon1.cast.typeName = MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0))));
5815 sourceExp->__anon1.cast.exp = newExp;
5816 FreeType(sourceExp->expType);
5817 sourceExp->expType = (((void *)0));
5818 ProcessExpressionType(sourceExp);
5819 if(!inCompiler)
5820 {
5821 FreeType(sourceExp->expType);
5822 sourceExp->expType = dest;
5823 }
5824 FreeType(source);
5825 if(inCompiler)
5826 FreeType(dest);
5827 if(backupSourceExpType)
5828 FreeType(backupSourceExpType);
5829 return 1;
5830 }
5831 if(!_class->dataType)
5832 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
5833 FreeType(dest);
5834 dest = _class->dataType;
5835 dest->refCount++;
5836 }
5837 if(dest->kind == 7 && (source->kind == 7 || source->kind == 6 || dest->kind == 4 || source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24))
5838 {
5839 specs = MkListOne(MkSpecifier(DOUBLE));
5840 }
5841 else if(dest->kind == 6 && (source->kind == 6 || dest->kind == 4 || source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 7))
5842 {
5843 specs = MkListOne(MkSpecifier(FLOAT));
5844 }
5845 else if(dest->kind == 4 && (source->kind == 4 || source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 6 || source->kind == 7))
5846 {
5847 specs = MkList();
5848 if(!dest->isSigned)
5849 ListAdd(specs, MkSpecifier(UNSIGNED));
5850 ListAdd(specs, MkSpecifier(INT64));
5851 }
5852 else if(dest->kind == 3 && (source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 6 || source->kind == 7))
5853 {
5854 specs = MkList();
5855 if(!dest->isSigned)
5856 ListAdd(specs, MkSpecifier(UNSIGNED));
5857 ListAdd(specs, MkSpecifier(INT));
5858 }
5859 else if(dest->kind == 2 && (source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 3 || source->kind == 6 || source->kind == 7))
5860 {
5861 specs = MkList();
5862 if(!dest->isSigned)
5863 ListAdd(specs, MkSpecifier(UNSIGNED));
5864 ListAdd(specs, MkSpecifier(SHORT));
5865 }
5866 else if(dest->kind == 1 && (source->kind == 1 || source->kind == 24 || source->kind == 2 || source->kind == 3 || source->kind == 6 || source->kind == 7))
5867 {
5868 specs = MkList();
5869 if(!dest->isSigned)
5870 ListAdd(specs, MkSpecifier(UNSIGNED));
5871 ListAdd(specs, MkSpecifier(CHAR));
5872 }
5873 else
5874 {
5875 FreeType(source);
5876 FreeType(dest);
5877 if(backupSourceExpType)
5878 {
5879 if(sourceExp->expType)
5880 FreeType(sourceExp->expType);
5881 sourceExp->expType = backupSourceExpType;
5882 }
5883 return 0;
5884 }
5885 }
5886 else if(dest->kind == 7 && (source->kind == 7 || source->kind == 6 || source->kind == 4 || source->kind == 3 || source->kind == 15 || source->kind == 2 || source->kind == 24 || source->kind == 1))
5887 {
5888 specs = MkListOne(MkSpecifier(DOUBLE));
5889 }
5890 else if(dest->kind == 6 && (source->kind == 6 || source->kind == 15 || source->kind == 4 || source->kind == 3 || source->kind == 2 || source->kind == 24 || source->kind == 1))
5891 {
5892 specs = MkListOne(MkSpecifier(FLOAT));
5893 }
5894 else if(dest->kind == 24 && (source->kind == 24 || source->kind == 1 || source->kind == 15 || source->kind == 2 || source->kind == 3) && (value == 1 || value == 0))
5895 {
5896 specs = MkList();
5897 ListAdd(specs, MkSpecifier(BOOL));
5898 }
5899 else if(dest->kind == 1 && (source->kind == 24 || source->kind == 1 || source->kind == 15 || source->kind == 2 || source->kind == 3) && (dest->isSigned ? (value >= -128 && value <= 127) : (value >= 0 && value <= 255)))
5900 {
5901 specs = MkList();
5902 if(!dest->isSigned)
5903 ListAdd(specs, MkSpecifier(UNSIGNED));
5904 ListAdd(specs, MkSpecifier(CHAR));
5905 }
5906 else if(dest->kind == 2 && (source->kind == 15 || source->kind == 24 || source->kind == 1 || source->kind == 2 || (source->kind == 3 && (dest->isSigned ? (value >= -32768 && value <= 32767) : (value >= 0 && value <= 65535)))))
5907 {
5908 specs = MkList();
5909 if(!dest->isSigned)
5910 ListAdd(specs, MkSpecifier(UNSIGNED));
5911 ListAdd(specs, MkSpecifier(SHORT));
5912 }
5913 else if(dest->kind == 3 && (source->kind == 15 || source->kind == 2 || source->kind == 24 || source->kind == 1 || source->kind == 3))
5914 {
5915 specs = MkList();
5916 if(!dest->isSigned)
5917 ListAdd(specs, MkSpecifier(UNSIGNED));
5918 ListAdd(specs, MkSpecifier(INT));
5919 }
5920 else if(dest->kind == 4 && (source->kind == 15 || source->kind == 2 || source->kind == 24 || source->kind == 1 || source->kind == 3 || source->kind == 4))
5921 {
5922 specs = MkList();
5923 if(!dest->isSigned)
5924 ListAdd(specs, MkSpecifier(UNSIGNED));
5925 ListAdd(specs, MkSpecifier(INT64));
5926 }
5927 else if(dest->kind == 15 && (source->kind == 4 || source->kind == 3 || source->kind == 2 || source->kind == 24 || source->kind == 1))
5928 {
5929 specs = MkListOne(MkEnum(MkIdentifier(dest->__anon1.__anon1.enumName), (((void *)0))));
5930 }
5931 else
5932 {
5933 FreeType(source);
5934 FreeType(dest);
5935 if(backupSourceExpType)
5936 {
5937 if(sourceExp->expType)
5938 FreeType(sourceExp->expType);
5939 sourceExp->expType = backupSourceExpType;
5940 }
5941 return 0;
5942 }
5943 if(!flag && !sourceExp->opDestType)
5944 {
5945 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
5946
5947 *newExp = *sourceExp;
5948 newExp->prev = (((void *)0));
5949 newExp->next = (((void *)0));
5950 if(sourceExp->destType)
5951 sourceExp->destType->refCount++;
5952 if(sourceExp->expType)
5953 sourceExp->expType->refCount++;
5954 sourceExp->type = 11;
5955 if(realDest->kind == 8)
5956 {
5957 sourceExp->__anon1.cast.typeName = QMkClass(realDest->__anon1._class->string, (((void *)0)));
5958 FreeList(specs, (void *)(FreeSpecifier));
5959 }
5960 else
5961 sourceExp->__anon1.cast.typeName = MkTypeName(specs, (((void *)0)));
5962 if(newExp->type == 4)
5963 {
5964 sourceExp->__anon1.cast.exp = MkExpBrackets(MkListOne(newExp));
5965 }
5966 else
5967 sourceExp->__anon1.cast.exp = newExp;
5968 FreeType(sourceExp->expType);
5969 sourceExp->expType = (((void *)0));
5970 ProcessExpressionType(sourceExp);
5971 }
5972 else
5973 FreeList(specs, (void *)(FreeSpecifier));
5974 FreeType(dest);
5975 FreeType(source);
5976 if(backupSourceExpType)
5977 FreeType(backupSourceExpType);
5978 return 1;
5979 }
5980 else
5981 {
5982 if(computedExp != sourceExp)
5983 {
5984 FreeExpression(computedExp);
5985 computedExp = sourceExp;
5986 }
5987 while((sourceExp->type == 5 || sourceExp->type == 32) && sourceExp->__anon1.list)
5988 sourceExp = (*sourceExp->__anon1.list).last;
5989 if(sourceExp->type == 0)
5990 {
5991 struct Identifier * id = sourceExp->__anon1.__anon1.identifier;
5992
5993 if(dest->kind == 8)
5994 {
5995 if(dest->__anon1._class && dest->__anon1._class->__anon1.registered && dest->__anon1._class->__anon1.registered->type == 4)
5996 {
5997 struct __ecereNameSpace__ecere__com__Class * _class = dest->__anon1._class->__anon1.registered;
5998 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
5999
6000 if(enumClass)
6001 {
6002 for(; _class && _class->type == 4; _class = _class->base)
6003 {
6004 struct __ecereNameSpace__ecere__sys__NamedLink64 * value;
6005 struct __ecereNameSpace__ecere__com__EnumClassData * e = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
6006
6007 for(value = e->values.first; value; value = value->next)
6008 {
6009 if(!strcmp(value->name, id->string))
6010 break;
6011 }
6012 if(value)
6013 {
6014 FreeExpContents(sourceExp);
6015 FreeType(sourceExp->expType);
6016 sourceExp->isConstant = 1;
6017 sourceExp->expType = MkClassType(_class->fullName);
6018 {
6019 sourceExp->type = 2;
6020 if(_class->dataTypeString && (!strcmp(_class->dataTypeString, "int") || !strcmp(_class->dataTypeString, "int64") || !strcmp(_class->dataTypeString, "short") || !strcmp(_class->dataTypeString, "char")))
6021 sourceExp->__anon1.__anon1.constant = PrintInt64(value->data);
6022 else
6023 sourceExp->__anon1.__anon1.constant = PrintUInt64(value->data);
6024 }
6025 FreeType(dest);
6026 return 1;
6027 }
6028 }
6029 }
6030 }
6031 }
6032 if(dest->classObjectType != 2 && dest->kind == 8 && MatchWithEnums_Module(privateModule, sourceExp, dest, id->string, conversions))
6033 {
6034 FreeType(dest);
6035 return 1;
6036 }
6037 }
6038 FreeType(dest);
6039 }
6040 return 0;
6041 }
6042
6043 static unsigned int IntAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6044 {
6045 int value2 = op2->__anon1.i;
6046
6047 exp->type = 2;
6048 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i + value2));
6049 if(!exp->expType)
6050 {
6051 exp->expType = op1->type;
6052 if(op1->type)
6053 op1->type->refCount++;
6054 }
6055 return 1;
6056 }
6057
6058 static unsigned int UIntAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6059 {
6060 unsigned int value2 = op2->__anon1.ui;
6061
6062 exp->type = 2;
6063 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui + value2));
6064 if(!exp->expType)
6065 {
6066 exp->expType = op1->type;
6067 if(op1->type)
6068 op1->type->refCount++;
6069 }
6070 return 1;
6071 }
6072
6073 static unsigned int Int64Add(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6074 {
6075 long long value2 = op2->__anon1.i64;
6076
6077 exp->type = 2;
6078 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 + value2));
6079 if(!exp->expType)
6080 {
6081 exp->expType = op1->type;
6082 if(op1->type)
6083 op1->type->refCount++;
6084 }
6085 return 1;
6086 }
6087
6088 static unsigned int UInt64Add(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6089 {
6090 uint64 value2 = op2->__anon1.ui64;
6091
6092 exp->type = 2;
6093 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 + value2));
6094 if(!exp->expType)
6095 {
6096 exp->expType = op1->type;
6097 if(op1->type)
6098 op1->type->refCount++;
6099 }
6100 return 1;
6101 }
6102
6103 static unsigned int ShortAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6104 {
6105 short value2 = op2->__anon1.s;
6106
6107 exp->type = 2;
6108 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s + value2));
6109 if(!exp->expType)
6110 {
6111 exp->expType = op1->type;
6112 if(op1->type)
6113 op1->type->refCount++;
6114 }
6115 return 1;
6116 }
6117
6118 static unsigned int UShortAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6119 {
6120 unsigned short value2 = op2->__anon1.us;
6121
6122 exp->type = 2;
6123 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us + value2));
6124 if(!exp->expType)
6125 {
6126 exp->expType = op1->type;
6127 if(op1->type)
6128 op1->type->refCount++;
6129 }
6130 return 1;
6131 }
6132
6133 static unsigned int CharAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6134 {
6135 char value2 = op2->__anon1.c;
6136
6137 exp->type = 2;
6138 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c + value2));
6139 if(!exp->expType)
6140 {
6141 exp->expType = op1->type;
6142 if(op1->type)
6143 op1->type->refCount++;
6144 }
6145 return 1;
6146 }
6147
6148 static unsigned int UCharAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6149 {
6150 unsigned char value2 = op2->__anon1.uc;
6151
6152 exp->type = 2;
6153 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc + value2));
6154 if(!exp->expType)
6155 {
6156 exp->expType = op1->type;
6157 if(op1->type)
6158 op1->type->refCount++;
6159 }
6160 return 1;
6161 }
6162
6163 static unsigned int FloatAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6164 {
6165 float value2 = op2->__anon1.f;
6166
6167 exp->type = 2;
6168 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f + value2));
6169 if(!exp->expType)
6170 {
6171 exp->expType = op1->type;
6172 if(op1->type)
6173 op1->type->refCount++;
6174 }
6175 return 1;
6176 }
6177
6178 static unsigned int DoubleAdd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6179 {
6180 double value2 = op2->__anon1.d;
6181
6182 exp->type = 2;
6183 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d + value2));
6184 if(!exp->expType)
6185 {
6186 exp->expType = op1->type;
6187 if(op1->type)
6188 op1->type->refCount++;
6189 }
6190 return 1;
6191 }
6192
6193 static unsigned int IntSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6194 {
6195 int value2 = op2->__anon1.i;
6196
6197 exp->type = 2;
6198 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i - value2));
6199 if(!exp->expType)
6200 {
6201 exp->expType = op1->type;
6202 if(op1->type)
6203 op1->type->refCount++;
6204 }
6205 return 1;
6206 }
6207
6208 static unsigned int UIntSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6209 {
6210 unsigned int value2 = op2->__anon1.ui;
6211
6212 exp->type = 2;
6213 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui - value2));
6214 if(!exp->expType)
6215 {
6216 exp->expType = op1->type;
6217 if(op1->type)
6218 op1->type->refCount++;
6219 }
6220 return 1;
6221 }
6222
6223 static unsigned int Int64Sub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6224 {
6225 long long value2 = op2->__anon1.i64;
6226
6227 exp->type = 2;
6228 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 - value2));
6229 if(!exp->expType)
6230 {
6231 exp->expType = op1->type;
6232 if(op1->type)
6233 op1->type->refCount++;
6234 }
6235 return 1;
6236 }
6237
6238 static unsigned int UInt64Sub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6239 {
6240 uint64 value2 = op2->__anon1.ui64;
6241
6242 exp->type = 2;
6243 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 - value2));
6244 if(!exp->expType)
6245 {
6246 exp->expType = op1->type;
6247 if(op1->type)
6248 op1->type->refCount++;
6249 }
6250 return 1;
6251 }
6252
6253 static unsigned int ShortSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6254 {
6255 short value2 = op2->__anon1.s;
6256
6257 exp->type = 2;
6258 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s - value2));
6259 if(!exp->expType)
6260 {
6261 exp->expType = op1->type;
6262 if(op1->type)
6263 op1->type->refCount++;
6264 }
6265 return 1;
6266 }
6267
6268 static unsigned int UShortSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6269 {
6270 unsigned short value2 = op2->__anon1.us;
6271
6272 exp->type = 2;
6273 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us - value2));
6274 if(!exp->expType)
6275 {
6276 exp->expType = op1->type;
6277 if(op1->type)
6278 op1->type->refCount++;
6279 }
6280 return 1;
6281 }
6282
6283 static unsigned int CharSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6284 {
6285 char value2 = op2->__anon1.c;
6286
6287 exp->type = 2;
6288 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c - value2));
6289 if(!exp->expType)
6290 {
6291 exp->expType = op1->type;
6292 if(op1->type)
6293 op1->type->refCount++;
6294 }
6295 return 1;
6296 }
6297
6298 static unsigned int UCharSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6299 {
6300 unsigned char value2 = op2->__anon1.uc;
6301
6302 exp->type = 2;
6303 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc - value2));
6304 if(!exp->expType)
6305 {
6306 exp->expType = op1->type;
6307 if(op1->type)
6308 op1->type->refCount++;
6309 }
6310 return 1;
6311 }
6312
6313 static unsigned int FloatSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6314 {
6315 float value2 = op2->__anon1.f;
6316
6317 exp->type = 2;
6318 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f - value2));
6319 if(!exp->expType)
6320 {
6321 exp->expType = op1->type;
6322 if(op1->type)
6323 op1->type->refCount++;
6324 }
6325 return 1;
6326 }
6327
6328 static unsigned int DoubleSub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6329 {
6330 double value2 = op2->__anon1.d;
6331
6332 exp->type = 2;
6333 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d - value2));
6334 if(!exp->expType)
6335 {
6336 exp->expType = op1->type;
6337 if(op1->type)
6338 op1->type->refCount++;
6339 }
6340 return 1;
6341 }
6342
6343 static unsigned int IntMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6344 {
6345 int value2 = op2->__anon1.i;
6346
6347 exp->type = 2;
6348 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i * value2));
6349 if(!exp->expType)
6350 {
6351 exp->expType = op1->type;
6352 if(op1->type)
6353 op1->type->refCount++;
6354 }
6355 return 1;
6356 }
6357
6358 static unsigned int UIntMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6359 {
6360 unsigned int value2 = op2->__anon1.ui;
6361
6362 exp->type = 2;
6363 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui * value2));
6364 if(!exp->expType)
6365 {
6366 exp->expType = op1->type;
6367 if(op1->type)
6368 op1->type->refCount++;
6369 }
6370 return 1;
6371 }
6372
6373 static unsigned int Int64Mul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6374 {
6375 long long value2 = op2->__anon1.i64;
6376
6377 exp->type = 2;
6378 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 * value2));
6379 if(!exp->expType)
6380 {
6381 exp->expType = op1->type;
6382 if(op1->type)
6383 op1->type->refCount++;
6384 }
6385 return 1;
6386 }
6387
6388 static unsigned int UInt64Mul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6389 {
6390 uint64 value2 = op2->__anon1.ui64;
6391
6392 exp->type = 2;
6393 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 * value2));
6394 if(!exp->expType)
6395 {
6396 exp->expType = op1->type;
6397 if(op1->type)
6398 op1->type->refCount++;
6399 }
6400 return 1;
6401 }
6402
6403 static unsigned int ShortMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6404 {
6405 short value2 = op2->__anon1.s;
6406
6407 exp->type = 2;
6408 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s * value2));
6409 if(!exp->expType)
6410 {
6411 exp->expType = op1->type;
6412 if(op1->type)
6413 op1->type->refCount++;
6414 }
6415 return 1;
6416 }
6417
6418 static unsigned int UShortMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6419 {
6420 unsigned short value2 = op2->__anon1.us;
6421
6422 exp->type = 2;
6423 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us * value2));
6424 if(!exp->expType)
6425 {
6426 exp->expType = op1->type;
6427 if(op1->type)
6428 op1->type->refCount++;
6429 }
6430 return 1;
6431 }
6432
6433 static unsigned int CharMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6434 {
6435 char value2 = op2->__anon1.c;
6436
6437 exp->type = 2;
6438 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c * value2));
6439 if(!exp->expType)
6440 {
6441 exp->expType = op1->type;
6442 if(op1->type)
6443 op1->type->refCount++;
6444 }
6445 return 1;
6446 }
6447
6448 static unsigned int UCharMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6449 {
6450 unsigned char value2 = op2->__anon1.uc;
6451
6452 exp->type = 2;
6453 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc * value2));
6454 if(!exp->expType)
6455 {
6456 exp->expType = op1->type;
6457 if(op1->type)
6458 op1->type->refCount++;
6459 }
6460 return 1;
6461 }
6462
6463 static unsigned int FloatMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6464 {
6465 float value2 = op2->__anon1.f;
6466
6467 exp->type = 2;
6468 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f * value2));
6469 if(!exp->expType)
6470 {
6471 exp->expType = op1->type;
6472 if(op1->type)
6473 op1->type->refCount++;
6474 }
6475 return 1;
6476 }
6477
6478 static unsigned int DoubleMul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6479 {
6480 double value2 = op2->__anon1.d;
6481
6482 exp->type = 2;
6483 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d * value2));
6484 if(!exp->expType)
6485 {
6486 exp->expType = op1->type;
6487 if(op1->type)
6488 op1->type->refCount++;
6489 }
6490 return 1;
6491 }
6492
6493 static unsigned int IntDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6494 {
6495 int value2 = op2->__anon1.i;
6496
6497 exp->type = 2;
6498 exp->__anon1.__anon2.string = PrintInt(value2 ? (op1->__anon1.i / value2) : 0);
6499 if(!exp->expType)
6500 {
6501 exp->expType = op1->type;
6502 if(op1->type)
6503 op1->type->refCount++;
6504 }
6505 return 1;
6506 }
6507
6508 static unsigned int UIntDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6509 {
6510 unsigned int value2 = op2->__anon1.ui;
6511
6512 exp->type = 2;
6513 exp->__anon1.__anon2.string = PrintUInt(value2 ? (op1->__anon1.ui / value2) : 0);
6514 if(!exp->expType)
6515 {
6516 exp->expType = op1->type;
6517 if(op1->type)
6518 op1->type->refCount++;
6519 }
6520 return 1;
6521 }
6522
6523 static unsigned int Int64Div(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6524 {
6525 long long value2 = op2->__anon1.i64;
6526
6527 exp->type = 2;
6528 exp->__anon1.__anon2.string = PrintInt64(value2 ? (op1->__anon1.i64 / value2) : 0);
6529 if(!exp->expType)
6530 {
6531 exp->expType = op1->type;
6532 if(op1->type)
6533 op1->type->refCount++;
6534 }
6535 return 1;
6536 }
6537
6538 static unsigned int UInt64Div(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6539 {
6540 uint64 value2 = op2->__anon1.ui64;
6541
6542 exp->type = 2;
6543 exp->__anon1.__anon2.string = PrintUInt64(value2 ? (op1->__anon1.ui64 / value2) : 0);
6544 if(!exp->expType)
6545 {
6546 exp->expType = op1->type;
6547 if(op1->type)
6548 op1->type->refCount++;
6549 }
6550 return 1;
6551 }
6552
6553 static unsigned int ShortDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6554 {
6555 short value2 = op2->__anon1.s;
6556
6557 exp->type = 2;
6558 exp->__anon1.__anon2.string = PrintShort(value2 ? (op1->__anon1.s / value2) : (short)0);
6559 if(!exp->expType)
6560 {
6561 exp->expType = op1->type;
6562 if(op1->type)
6563 op1->type->refCount++;
6564 }
6565 return 1;
6566 }
6567
6568 static unsigned int UShortDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6569 {
6570 unsigned short value2 = op2->__anon1.us;
6571
6572 exp->type = 2;
6573 exp->__anon1.__anon2.string = PrintUShort(value2 ? (op1->__anon1.us / value2) : (unsigned short)0);
6574 if(!exp->expType)
6575 {
6576 exp->expType = op1->type;
6577 if(op1->type)
6578 op1->type->refCount++;
6579 }
6580 return 1;
6581 }
6582
6583 static unsigned int CharDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6584 {
6585 char value2 = op2->__anon1.c;
6586
6587 exp->type = 2;
6588 exp->__anon1.__anon2.string = PrintChar(value2 ? (op1->__anon1.c / value2) : (char)0);
6589 if(!exp->expType)
6590 {
6591 exp->expType = op1->type;
6592 if(op1->type)
6593 op1->type->refCount++;
6594 }
6595 return 1;
6596 }
6597
6598 static unsigned int UCharDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6599 {
6600 unsigned char value2 = op2->__anon1.uc;
6601
6602 exp->type = 2;
6603 exp->__anon1.__anon2.string = PrintUChar(value2 ? (op1->__anon1.uc / value2) : (unsigned char)0);
6604 if(!exp->expType)
6605 {
6606 exp->expType = op1->type;
6607 if(op1->type)
6608 op1->type->refCount++;
6609 }
6610 return 1;
6611 }
6612
6613 static unsigned int FloatDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6614 {
6615 float value2 = op2->__anon1.f;
6616
6617 exp->type = 2;
6618 exp->__anon1.__anon2.string = PrintFloat(op1->__anon1.f / value2);
6619 if(!exp->expType)
6620 {
6621 exp->expType = op1->type;
6622 if(op1->type)
6623 op1->type->refCount++;
6624 }
6625 return 1;
6626 }
6627
6628 static unsigned int DoubleDiv(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6629 {
6630 double value2 = op2->__anon1.d;
6631
6632 exp->type = 2;
6633 exp->__anon1.__anon2.string = PrintDouble(op1->__anon1.d / value2);
6634 if(!exp->expType)
6635 {
6636 exp->expType = op1->type;
6637 if(op1->type)
6638 op1->type->refCount++;
6639 }
6640 return 1;
6641 }
6642
6643 static unsigned int IntMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6644 {
6645 int value2 = op2->__anon1.i;
6646
6647 exp->type = 2;
6648 exp->__anon1.__anon2.string = PrintInt(value2 ? (op1->__anon1.i % value2) : 0);
6649 if(!exp->expType)
6650 {
6651 exp->expType = op1->type;
6652 if(op1->type)
6653 op1->type->refCount++;
6654 }
6655 return 1;
6656 }
6657
6658 static unsigned int UIntMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6659 {
6660 unsigned int value2 = op2->__anon1.ui;
6661
6662 exp->type = 2;
6663 exp->__anon1.__anon2.string = PrintUInt(value2 ? (op1->__anon1.ui % value2) : 0);
6664 if(!exp->expType)
6665 {
6666 exp->expType = op1->type;
6667 if(op1->type)
6668 op1->type->refCount++;
6669 }
6670 return 1;
6671 }
6672
6673 static unsigned int Int64Mod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6674 {
6675 long long value2 = op2->__anon1.i64;
6676
6677 exp->type = 2;
6678 exp->__anon1.__anon2.string = PrintInt64(value2 ? (op1->__anon1.i64 % value2) : 0);
6679 if(!exp->expType)
6680 {
6681 exp->expType = op1->type;
6682 if(op1->type)
6683 op1->type->refCount++;
6684 }
6685 return 1;
6686 }
6687
6688 static unsigned int UInt64Mod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6689 {
6690 uint64 value2 = op2->__anon1.ui64;
6691
6692 exp->type = 2;
6693 exp->__anon1.__anon2.string = PrintUInt64(value2 ? (op1->__anon1.ui64 % value2) : 0);
6694 if(!exp->expType)
6695 {
6696 exp->expType = op1->type;
6697 if(op1->type)
6698 op1->type->refCount++;
6699 }
6700 return 1;
6701 }
6702
6703 static unsigned int ShortMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6704 {
6705 short value2 = op2->__anon1.s;
6706
6707 exp->type = 2;
6708 exp->__anon1.__anon2.string = PrintShort(value2 ? (op1->__anon1.s % value2) : (short)0);
6709 if(!exp->expType)
6710 {
6711 exp->expType = op1->type;
6712 if(op1->type)
6713 op1->type->refCount++;
6714 }
6715 return 1;
6716 }
6717
6718 static unsigned int UShortMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6719 {
6720 unsigned short value2 = op2->__anon1.us;
6721
6722 exp->type = 2;
6723 exp->__anon1.__anon2.string = PrintUShort(value2 ? (op1->__anon1.us % value2) : (unsigned short)0);
6724 if(!exp->expType)
6725 {
6726 exp->expType = op1->type;
6727 if(op1->type)
6728 op1->type->refCount++;
6729 }
6730 return 1;
6731 }
6732
6733 static unsigned int CharMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6734 {
6735 char value2 = op2->__anon1.c;
6736
6737 exp->type = 2;
6738 exp->__anon1.__anon2.string = PrintChar(value2 ? (op1->__anon1.c % value2) : (char)0);
6739 if(!exp->expType)
6740 {
6741 exp->expType = op1->type;
6742 if(op1->type)
6743 op1->type->refCount++;
6744 }
6745 return 1;
6746 }
6747
6748 static unsigned int UCharMod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
6749 {
6750 unsigned char value2 = op2->__anon1.uc;
6751
6752 exp->type = 2;
6753 exp->__anon1.__anon2.string = PrintUChar(value2 ? (op1->__anon1.uc % value2) : (unsigned char)0);
6754 if(!exp->expType)
6755 {
6756 exp->expType = op1->type;
6757 if(op1->type)
6758 op1->type->refCount++;
6759 }
6760 return 1;
6761 }
6762
6763 static unsigned int IntNeg(struct Expression * exp, struct Operand * op1)
6764 {
6765 exp->type = 2;
6766 exp->__anon1.__anon2.string = PrintInt((-op1->__anon1.i));
6767 if(!exp->expType)
6768 {
6769 exp->expType = op1->type;
6770 if(op1->type)
6771 op1->type->refCount++;
6772 }
6773 return 1;
6774 }
6775
6776 static unsigned int UIntNeg(struct Expression * exp, struct Operand * op1)
6777 {
6778 exp->type = 2;
6779 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(-op1->__anon1.ui));
6780 if(!exp->expType)
6781 {
6782 exp->expType = op1->type;
6783 if(op1->type)
6784 op1->type->refCount++;
6785 }
6786 return 1;
6787 }
6788
6789 static unsigned int Int64Neg(struct Expression * exp, struct Operand * op1)
6790 {
6791 exp->type = 2;
6792 exp->__anon1.__anon2.string = PrintInt64((-op1->__anon1.i64));
6793 if(!exp->expType)
6794 {
6795 exp->expType = op1->type;
6796 if(op1->type)
6797 op1->type->refCount++;
6798 }
6799 return 1;
6800 }
6801
6802 static unsigned int UInt64Neg(struct Expression * exp, struct Operand * op1)
6803 {
6804 exp->type = 2;
6805 exp->__anon1.__anon2.string = PrintUInt64((uint64)(-op1->__anon1.ui64));
6806 if(!exp->expType)
6807 {
6808 exp->expType = op1->type;
6809 if(op1->type)
6810 op1->type->refCount++;
6811 }
6812 return 1;
6813 }
6814
6815 static unsigned int ShortNeg(struct Expression * exp, struct Operand * op1)
6816 {
6817 exp->type = 2;
6818 exp->__anon1.__anon2.string = PrintShort((-op1->__anon1.s));
6819 if(!exp->expType)
6820 {
6821 exp->expType = op1->type;
6822 if(op1->type)
6823 op1->type->refCount++;
6824 }
6825 return 1;
6826 }
6827
6828 static unsigned int UShortNeg(struct Expression * exp, struct Operand * op1)
6829 {
6830 exp->type = 2;
6831 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(-op1->__anon1.us));
6832 if(!exp->expType)
6833 {
6834 exp->expType = op1->type;
6835 if(op1->type)
6836 op1->type->refCount++;
6837 }
6838 return 1;
6839 }
6840
6841 static unsigned int CharNeg(struct Expression * exp, struct Operand * op1)
6842 {
6843 exp->type = 2;
6844 exp->__anon1.__anon2.string = PrintChar((-op1->__anon1.c));
6845 if(!exp->expType)
6846 {
6847 exp->expType = op1->type;
6848 if(op1->type)
6849 op1->type->refCount++;
6850 }
6851 return 1;
6852 }
6853
6854 static unsigned int UCharNeg(struct Expression * exp, struct Operand * op1)
6855 {
6856 exp->type = 2;
6857 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(-op1->__anon1.uc));
6858 if(!exp->expType)
6859 {
6860 exp->expType = op1->type;
6861 if(op1->type)
6862 op1->type->refCount++;
6863 }
6864 return 1;
6865 }
6866
6867 static unsigned int FloatNeg(struct Expression * exp, struct Operand * op1)
6868 {
6869 exp->type = 2;
6870 exp->__anon1.__anon2.string = PrintFloat((float)(-op1->__anon1.f));
6871 if(!exp->expType)
6872 {
6873 exp->expType = op1->type;
6874 if(op1->type)
6875 op1->type->refCount++;
6876 }
6877 return 1;
6878 }
6879
6880 static unsigned int DoubleNeg(struct Expression * exp, struct Operand * op1)
6881 {
6882 exp->type = 2;
6883 exp->__anon1.__anon2.string = PrintDouble((double)(-op1->__anon1.d));
6884 if(!exp->expType)
6885 {
6886 exp->expType = op1->type;
6887 if(op1->type)
6888 op1->type->refCount++;
6889 }
6890 return 1;
6891 }
6892
6893 static unsigned int IntInc(struct Expression * exp, struct Operand * op1)
6894 {
6895 exp->type = 2;
6896 exp->__anon1.__anon2.string = PrintInt((++op1->__anon1.i));
6897 if(!exp->expType)
6898 {
6899 exp->expType = op1->type;
6900 if(op1->type)
6901 op1->type->refCount++;
6902 }
6903 return 1;
6904 }
6905
6906 static unsigned int UIntInc(struct Expression * exp, struct Operand * op1)
6907 {
6908 exp->type = 2;
6909 exp->__anon1.__anon2.string = PrintUInt((++op1->__anon1.ui));
6910 if(!exp->expType)
6911 {
6912 exp->expType = op1->type;
6913 if(op1->type)
6914 op1->type->refCount++;
6915 }
6916 return 1;
6917 }
6918
6919 static unsigned int Int64Inc(struct Expression * exp, struct Operand * op1)
6920 {
6921 exp->type = 2;
6922 exp->__anon1.__anon2.string = PrintInt64((++op1->__anon1.i64));
6923 if(!exp->expType)
6924 {
6925 exp->expType = op1->type;
6926 if(op1->type)
6927 op1->type->refCount++;
6928 }
6929 return 1;
6930 }
6931
6932 static unsigned int UInt64Inc(struct Expression * exp, struct Operand * op1)
6933 {
6934 exp->type = 2;
6935 exp->__anon1.__anon2.string = PrintUInt64((++op1->__anon1.ui64));
6936 if(!exp->expType)
6937 {
6938 exp->expType = op1->type;
6939 if(op1->type)
6940 op1->type->refCount++;
6941 }
6942 return 1;
6943 }
6944
6945 static unsigned int ShortInc(struct Expression * exp, struct Operand * op1)
6946 {
6947 exp->type = 2;
6948 exp->__anon1.__anon2.string = PrintShort((++op1->__anon1.s));
6949 if(!exp->expType)
6950 {
6951 exp->expType = op1->type;
6952 if(op1->type)
6953 op1->type->refCount++;
6954 }
6955 return 1;
6956 }
6957
6958 static unsigned int UShortInc(struct Expression * exp, struct Operand * op1)
6959 {
6960 exp->type = 2;
6961 exp->__anon1.__anon2.string = PrintUShort((++op1->__anon1.us));
6962 if(!exp->expType)
6963 {
6964 exp->expType = op1->type;
6965 if(op1->type)
6966 op1->type->refCount++;
6967 }
6968 return 1;
6969 }
6970
6971 static unsigned int CharInc(struct Expression * exp, struct Operand * op1)
6972 {
6973 exp->type = 2;
6974 exp->__anon1.__anon2.string = PrintChar((++op1->__anon1.c));
6975 if(!exp->expType)
6976 {
6977 exp->expType = op1->type;
6978 if(op1->type)
6979 op1->type->refCount++;
6980 }
6981 return 1;
6982 }
6983
6984 static unsigned int UCharInc(struct Expression * exp, struct Operand * op1)
6985 {
6986 exp->type = 2;
6987 exp->__anon1.__anon2.string = PrintUChar((++op1->__anon1.uc));
6988 if(!exp->expType)
6989 {
6990 exp->expType = op1->type;
6991 if(op1->type)
6992 op1->type->refCount++;
6993 }
6994 return 1;
6995 }
6996
6997 static unsigned int FloatInc(struct Expression * exp, struct Operand * op1)
6998 {
6999 exp->type = 2;
7000 exp->__anon1.__anon2.string = PrintFloat((float)(++op1->__anon1.f));
7001 if(!exp->expType)
7002 {
7003 exp->expType = op1->type;
7004 if(op1->type)
7005 op1->type->refCount++;
7006 }
7007 return 1;
7008 }
7009
7010 static unsigned int DoubleInc(struct Expression * exp, struct Operand * op1)
7011 {
7012 exp->type = 2;
7013 exp->__anon1.__anon2.string = PrintDouble((double)(++op1->__anon1.d));
7014 if(!exp->expType)
7015 {
7016 exp->expType = op1->type;
7017 if(op1->type)
7018 op1->type->refCount++;
7019 }
7020 return 1;
7021 }
7022
7023 static unsigned int IntDec(struct Expression * exp, struct Operand * op1)
7024 {
7025 exp->type = 2;
7026 exp->__anon1.__anon2.string = PrintInt((--op1->__anon1.i));
7027 if(!exp->expType)
7028 {
7029 exp->expType = op1->type;
7030 if(op1->type)
7031 op1->type->refCount++;
7032 }
7033 return 1;
7034 }
7035
7036 static unsigned int UIntDec(struct Expression * exp, struct Operand * op1)
7037 {
7038 exp->type = 2;
7039 exp->__anon1.__anon2.string = PrintUInt((--op1->__anon1.ui));
7040 if(!exp->expType)
7041 {
7042 exp->expType = op1->type;
7043 if(op1->type)
7044 op1->type->refCount++;
7045 }
7046 return 1;
7047 }
7048
7049 static unsigned int Int64Dec(struct Expression * exp, struct Operand * op1)
7050 {
7051 exp->type = 2;
7052 exp->__anon1.__anon2.string = PrintInt64((--op1->__anon1.i64));
7053 if(!exp->expType)
7054 {
7055 exp->expType = op1->type;
7056 if(op1->type)
7057 op1->type->refCount++;
7058 }
7059 return 1;
7060 }
7061
7062 static unsigned int UInt64Dec(struct Expression * exp, struct Operand * op1)
7063 {
7064 exp->type = 2;
7065 exp->__anon1.__anon2.string = PrintUInt64((--op1->__anon1.ui64));
7066 if(!exp->expType)
7067 {
7068 exp->expType = op1->type;
7069 if(op1->type)
7070 op1->type->refCount++;
7071 }
7072 return 1;
7073 }
7074
7075 static unsigned int ShortDec(struct Expression * exp, struct Operand * op1)
7076 {
7077 exp->type = 2;
7078 exp->__anon1.__anon2.string = PrintShort((--op1->__anon1.s));
7079 if(!exp->expType)
7080 {
7081 exp->expType = op1->type;
7082 if(op1->type)
7083 op1->type->refCount++;
7084 }
7085 return 1;
7086 }
7087
7088 static unsigned int UShortDec(struct Expression * exp, struct Operand * op1)
7089 {
7090 exp->type = 2;
7091 exp->__anon1.__anon2.string = PrintUShort((--op1->__anon1.us));
7092 if(!exp->expType)
7093 {
7094 exp->expType = op1->type;
7095 if(op1->type)
7096 op1->type->refCount++;
7097 }
7098 return 1;
7099 }
7100
7101 static unsigned int CharDec(struct Expression * exp, struct Operand * op1)
7102 {
7103 exp->type = 2;
7104 exp->__anon1.__anon2.string = PrintChar((--op1->__anon1.c));
7105 if(!exp->expType)
7106 {
7107 exp->expType = op1->type;
7108 if(op1->type)
7109 op1->type->refCount++;
7110 }
7111 return 1;
7112 }
7113
7114 static unsigned int UCharDec(struct Expression * exp, struct Operand * op1)
7115 {
7116 exp->type = 2;
7117 exp->__anon1.__anon2.string = PrintUChar((--op1->__anon1.uc));
7118 if(!exp->expType)
7119 {
7120 exp->expType = op1->type;
7121 if(op1->type)
7122 op1->type->refCount++;
7123 }
7124 return 1;
7125 }
7126
7127 static unsigned int FloatDec(struct Expression * exp, struct Operand * op1)
7128 {
7129 exp->type = 2;
7130 exp->__anon1.__anon2.string = PrintFloat((float)(--op1->__anon1.f));
7131 if(!exp->expType)
7132 {
7133 exp->expType = op1->type;
7134 if(op1->type)
7135 op1->type->refCount++;
7136 }
7137 return 1;
7138 }
7139
7140 static unsigned int DoubleDec(struct Expression * exp, struct Operand * op1)
7141 {
7142 exp->type = 2;
7143 exp->__anon1.__anon2.string = PrintDouble((double)(--op1->__anon1.d));
7144 if(!exp->expType)
7145 {
7146 exp->expType = op1->type;
7147 if(op1->type)
7148 op1->type->refCount++;
7149 }
7150 return 1;
7151 }
7152
7153 static unsigned int IntAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7154 {
7155 int value2 = op2->__anon1.i;
7156
7157 exp->type = 2;
7158 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i = value2));
7159 if(!exp->expType)
7160 {
7161 exp->expType = op1->type;
7162 if(op1->type)
7163 op1->type->refCount++;
7164 }
7165 return 1;
7166 }
7167
7168 static unsigned int UIntAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7169 {
7170 unsigned int value2 = op2->__anon1.ui;
7171
7172 exp->type = 2;
7173 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui = value2));
7174 if(!exp->expType)
7175 {
7176 exp->expType = op1->type;
7177 if(op1->type)
7178 op1->type->refCount++;
7179 }
7180 return 1;
7181 }
7182
7183 static unsigned int Int64Asign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7184 {
7185 long long value2 = op2->__anon1.i64;
7186
7187 exp->type = 2;
7188 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 = value2));
7189 if(!exp->expType)
7190 {
7191 exp->expType = op1->type;
7192 if(op1->type)
7193 op1->type->refCount++;
7194 }
7195 return 1;
7196 }
7197
7198 static unsigned int UInt64Asign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7199 {
7200 uint64 value2 = op2->__anon1.ui64;
7201
7202 exp->type = 2;
7203 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 = value2));
7204 if(!exp->expType)
7205 {
7206 exp->expType = op1->type;
7207 if(op1->type)
7208 op1->type->refCount++;
7209 }
7210 return 1;
7211 }
7212
7213 static unsigned int ShortAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7214 {
7215 short value2 = op2->__anon1.s;
7216
7217 exp->type = 2;
7218 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s = value2));
7219 if(!exp->expType)
7220 {
7221 exp->expType = op1->type;
7222 if(op1->type)
7223 op1->type->refCount++;
7224 }
7225 return 1;
7226 }
7227
7228 static unsigned int UShortAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7229 {
7230 unsigned short value2 = op2->__anon1.us;
7231
7232 exp->type = 2;
7233 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us = value2));
7234 if(!exp->expType)
7235 {
7236 exp->expType = op1->type;
7237 if(op1->type)
7238 op1->type->refCount++;
7239 }
7240 return 1;
7241 }
7242
7243 static unsigned int CharAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7244 {
7245 char value2 = op2->__anon1.c;
7246
7247 exp->type = 2;
7248 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c = value2));
7249 if(!exp->expType)
7250 {
7251 exp->expType = op1->type;
7252 if(op1->type)
7253 op1->type->refCount++;
7254 }
7255 return 1;
7256 }
7257
7258 static unsigned int UCharAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7259 {
7260 unsigned char value2 = op2->__anon1.uc;
7261
7262 exp->type = 2;
7263 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc = value2));
7264 if(!exp->expType)
7265 {
7266 exp->expType = op1->type;
7267 if(op1->type)
7268 op1->type->refCount++;
7269 }
7270 return 1;
7271 }
7272
7273 static unsigned int FloatAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7274 {
7275 float value2 = op2->__anon1.f;
7276
7277 exp->type = 2;
7278 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f = value2));
7279 if(!exp->expType)
7280 {
7281 exp->expType = op1->type;
7282 if(op1->type)
7283 op1->type->refCount++;
7284 }
7285 return 1;
7286 }
7287
7288 static unsigned int DoubleAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7289 {
7290 double value2 = op2->__anon1.d;
7291
7292 exp->type = 2;
7293 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d = value2));
7294 if(!exp->expType)
7295 {
7296 exp->expType = op1->type;
7297 if(op1->type)
7298 op1->type->refCount++;
7299 }
7300 return 1;
7301 }
7302
7303 static unsigned int IntAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7304 {
7305 int value2 = op2->__anon1.i;
7306
7307 exp->type = 2;
7308 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i += value2));
7309 if(!exp->expType)
7310 {
7311 exp->expType = op1->type;
7312 if(op1->type)
7313 op1->type->refCount++;
7314 }
7315 return 1;
7316 }
7317
7318 static unsigned int UIntAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7319 {
7320 unsigned int value2 = op2->__anon1.ui;
7321
7322 exp->type = 2;
7323 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui += value2));
7324 if(!exp->expType)
7325 {
7326 exp->expType = op1->type;
7327 if(op1->type)
7328 op1->type->refCount++;
7329 }
7330 return 1;
7331 }
7332
7333 static unsigned int Int64AddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7334 {
7335 long long value2 = op2->__anon1.i64;
7336
7337 exp->type = 2;
7338 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 += value2));
7339 if(!exp->expType)
7340 {
7341 exp->expType = op1->type;
7342 if(op1->type)
7343 op1->type->refCount++;
7344 }
7345 return 1;
7346 }
7347
7348 static unsigned int UInt64AddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7349 {
7350 uint64 value2 = op2->__anon1.ui64;
7351
7352 exp->type = 2;
7353 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 += value2));
7354 if(!exp->expType)
7355 {
7356 exp->expType = op1->type;
7357 if(op1->type)
7358 op1->type->refCount++;
7359 }
7360 return 1;
7361 }
7362
7363 static unsigned int ShortAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7364 {
7365 short value2 = op2->__anon1.s;
7366
7367 exp->type = 2;
7368 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s += value2));
7369 if(!exp->expType)
7370 {
7371 exp->expType = op1->type;
7372 if(op1->type)
7373 op1->type->refCount++;
7374 }
7375 return 1;
7376 }
7377
7378 static unsigned int UShortAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7379 {
7380 unsigned short value2 = op2->__anon1.us;
7381
7382 exp->type = 2;
7383 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us += value2));
7384 if(!exp->expType)
7385 {
7386 exp->expType = op1->type;
7387 if(op1->type)
7388 op1->type->refCount++;
7389 }
7390 return 1;
7391 }
7392
7393 static unsigned int CharAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7394 {
7395 char value2 = op2->__anon1.c;
7396
7397 exp->type = 2;
7398 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c += value2));
7399 if(!exp->expType)
7400 {
7401 exp->expType = op1->type;
7402 if(op1->type)
7403 op1->type->refCount++;
7404 }
7405 return 1;
7406 }
7407
7408 static unsigned int UCharAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7409 {
7410 unsigned char value2 = op2->__anon1.uc;
7411
7412 exp->type = 2;
7413 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc += value2));
7414 if(!exp->expType)
7415 {
7416 exp->expType = op1->type;
7417 if(op1->type)
7418 op1->type->refCount++;
7419 }
7420 return 1;
7421 }
7422
7423 static unsigned int FloatAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7424 {
7425 float value2 = op2->__anon1.f;
7426
7427 exp->type = 2;
7428 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f += value2));
7429 if(!exp->expType)
7430 {
7431 exp->expType = op1->type;
7432 if(op1->type)
7433 op1->type->refCount++;
7434 }
7435 return 1;
7436 }
7437
7438 static unsigned int DoubleAddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7439 {
7440 double value2 = op2->__anon1.d;
7441
7442 exp->type = 2;
7443 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d += value2));
7444 if(!exp->expType)
7445 {
7446 exp->expType = op1->type;
7447 if(op1->type)
7448 op1->type->refCount++;
7449 }
7450 return 1;
7451 }
7452
7453 static unsigned int IntSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7454 {
7455 int value2 = op2->__anon1.i;
7456
7457 exp->type = 2;
7458 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i -= value2));
7459 if(!exp->expType)
7460 {
7461 exp->expType = op1->type;
7462 if(op1->type)
7463 op1->type->refCount++;
7464 }
7465 return 1;
7466 }
7467
7468 static unsigned int UIntSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7469 {
7470 unsigned int value2 = op2->__anon1.ui;
7471
7472 exp->type = 2;
7473 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui -= value2));
7474 if(!exp->expType)
7475 {
7476 exp->expType = op1->type;
7477 if(op1->type)
7478 op1->type->refCount++;
7479 }
7480 return 1;
7481 }
7482
7483 static unsigned int Int64SubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7484 {
7485 long long value2 = op2->__anon1.i64;
7486
7487 exp->type = 2;
7488 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 -= value2));
7489 if(!exp->expType)
7490 {
7491 exp->expType = op1->type;
7492 if(op1->type)
7493 op1->type->refCount++;
7494 }
7495 return 1;
7496 }
7497
7498 static unsigned int UInt64SubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7499 {
7500 uint64 value2 = op2->__anon1.ui64;
7501
7502 exp->type = 2;
7503 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 -= value2));
7504 if(!exp->expType)
7505 {
7506 exp->expType = op1->type;
7507 if(op1->type)
7508 op1->type->refCount++;
7509 }
7510 return 1;
7511 }
7512
7513 static unsigned int ShortSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7514 {
7515 short value2 = op2->__anon1.s;
7516
7517 exp->type = 2;
7518 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s -= value2));
7519 if(!exp->expType)
7520 {
7521 exp->expType = op1->type;
7522 if(op1->type)
7523 op1->type->refCount++;
7524 }
7525 return 1;
7526 }
7527
7528 static unsigned int UShortSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7529 {
7530 unsigned short value2 = op2->__anon1.us;
7531
7532 exp->type = 2;
7533 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us -= value2));
7534 if(!exp->expType)
7535 {
7536 exp->expType = op1->type;
7537 if(op1->type)
7538 op1->type->refCount++;
7539 }
7540 return 1;
7541 }
7542
7543 static unsigned int CharSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7544 {
7545 char value2 = op2->__anon1.c;
7546
7547 exp->type = 2;
7548 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c -= value2));
7549 if(!exp->expType)
7550 {
7551 exp->expType = op1->type;
7552 if(op1->type)
7553 op1->type->refCount++;
7554 }
7555 return 1;
7556 }
7557
7558 static unsigned int UCharSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7559 {
7560 unsigned char value2 = op2->__anon1.uc;
7561
7562 exp->type = 2;
7563 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc -= value2));
7564 if(!exp->expType)
7565 {
7566 exp->expType = op1->type;
7567 if(op1->type)
7568 op1->type->refCount++;
7569 }
7570 return 1;
7571 }
7572
7573 static unsigned int FloatSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7574 {
7575 float value2 = op2->__anon1.f;
7576
7577 exp->type = 2;
7578 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f -= value2));
7579 if(!exp->expType)
7580 {
7581 exp->expType = op1->type;
7582 if(op1->type)
7583 op1->type->refCount++;
7584 }
7585 return 1;
7586 }
7587
7588 static unsigned int DoubleSubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7589 {
7590 double value2 = op2->__anon1.d;
7591
7592 exp->type = 2;
7593 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d -= value2));
7594 if(!exp->expType)
7595 {
7596 exp->expType = op1->type;
7597 if(op1->type)
7598 op1->type->refCount++;
7599 }
7600 return 1;
7601 }
7602
7603 static unsigned int IntMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7604 {
7605 int value2 = op2->__anon1.i;
7606
7607 exp->type = 2;
7608 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i *= value2));
7609 if(!exp->expType)
7610 {
7611 exp->expType = op1->type;
7612 if(op1->type)
7613 op1->type->refCount++;
7614 }
7615 return 1;
7616 }
7617
7618 static unsigned int UIntMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7619 {
7620 unsigned int value2 = op2->__anon1.ui;
7621
7622 exp->type = 2;
7623 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui *= value2));
7624 if(!exp->expType)
7625 {
7626 exp->expType = op1->type;
7627 if(op1->type)
7628 op1->type->refCount++;
7629 }
7630 return 1;
7631 }
7632
7633 static unsigned int Int64MulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7634 {
7635 long long value2 = op2->__anon1.i64;
7636
7637 exp->type = 2;
7638 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 *= value2));
7639 if(!exp->expType)
7640 {
7641 exp->expType = op1->type;
7642 if(op1->type)
7643 op1->type->refCount++;
7644 }
7645 return 1;
7646 }
7647
7648 static unsigned int UInt64MulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7649 {
7650 uint64 value2 = op2->__anon1.ui64;
7651
7652 exp->type = 2;
7653 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 *= value2));
7654 if(!exp->expType)
7655 {
7656 exp->expType = op1->type;
7657 if(op1->type)
7658 op1->type->refCount++;
7659 }
7660 return 1;
7661 }
7662
7663 static unsigned int ShortMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7664 {
7665 short value2 = op2->__anon1.s;
7666
7667 exp->type = 2;
7668 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s *= value2));
7669 if(!exp->expType)
7670 {
7671 exp->expType = op1->type;
7672 if(op1->type)
7673 op1->type->refCount++;
7674 }
7675 return 1;
7676 }
7677
7678 static unsigned int UShortMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7679 {
7680 unsigned short value2 = op2->__anon1.us;
7681
7682 exp->type = 2;
7683 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us *= value2));
7684 if(!exp->expType)
7685 {
7686 exp->expType = op1->type;
7687 if(op1->type)
7688 op1->type->refCount++;
7689 }
7690 return 1;
7691 }
7692
7693 static unsigned int CharMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7694 {
7695 char value2 = op2->__anon1.c;
7696
7697 exp->type = 2;
7698 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c *= value2));
7699 if(!exp->expType)
7700 {
7701 exp->expType = op1->type;
7702 if(op1->type)
7703 op1->type->refCount++;
7704 }
7705 return 1;
7706 }
7707
7708 static unsigned int UCharMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7709 {
7710 unsigned char value2 = op2->__anon1.uc;
7711
7712 exp->type = 2;
7713 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc *= value2));
7714 if(!exp->expType)
7715 {
7716 exp->expType = op1->type;
7717 if(op1->type)
7718 op1->type->refCount++;
7719 }
7720 return 1;
7721 }
7722
7723 static unsigned int FloatMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7724 {
7725 float value2 = op2->__anon1.f;
7726
7727 exp->type = 2;
7728 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f *= value2));
7729 if(!exp->expType)
7730 {
7731 exp->expType = op1->type;
7732 if(op1->type)
7733 op1->type->refCount++;
7734 }
7735 return 1;
7736 }
7737
7738 static unsigned int DoubleMulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7739 {
7740 double value2 = op2->__anon1.d;
7741
7742 exp->type = 2;
7743 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d *= value2));
7744 if(!exp->expType)
7745 {
7746 exp->expType = op1->type;
7747 if(op1->type)
7748 op1->type->refCount++;
7749 }
7750 return 1;
7751 }
7752
7753 static unsigned int IntDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7754 {
7755 int value2 = op2->__anon1.i;
7756
7757 exp->type = 2;
7758 exp->__anon1.__anon2.string = PrintInt(value2 ? (op1->__anon1.i /= value2) : 0);
7759 if(!exp->expType)
7760 {
7761 exp->expType = op1->type;
7762 if(op1->type)
7763 op1->type->refCount++;
7764 }
7765 return 1;
7766 }
7767
7768 static unsigned int UIntDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7769 {
7770 unsigned int value2 = op2->__anon1.ui;
7771
7772 exp->type = 2;
7773 exp->__anon1.__anon2.string = PrintUInt(value2 ? (op1->__anon1.ui /= value2) : 0);
7774 if(!exp->expType)
7775 {
7776 exp->expType = op1->type;
7777 if(op1->type)
7778 op1->type->refCount++;
7779 }
7780 return 1;
7781 }
7782
7783 static unsigned int Int64DivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7784 {
7785 long long value2 = op2->__anon1.i64;
7786
7787 exp->type = 2;
7788 exp->__anon1.__anon2.string = PrintInt64(value2 ? (op1->__anon1.i64 /= value2) : 0);
7789 if(!exp->expType)
7790 {
7791 exp->expType = op1->type;
7792 if(op1->type)
7793 op1->type->refCount++;
7794 }
7795 return 1;
7796 }
7797
7798 static unsigned int UInt64DivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7799 {
7800 uint64 value2 = op2->__anon1.ui64;
7801
7802 exp->type = 2;
7803 exp->__anon1.__anon2.string = PrintUInt64(value2 ? (op1->__anon1.ui64 /= value2) : 0);
7804 if(!exp->expType)
7805 {
7806 exp->expType = op1->type;
7807 if(op1->type)
7808 op1->type->refCount++;
7809 }
7810 return 1;
7811 }
7812
7813 static unsigned int ShortDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7814 {
7815 short value2 = op2->__anon1.s;
7816
7817 exp->type = 2;
7818 exp->__anon1.__anon2.string = PrintShort(value2 ? (op1->__anon1.s /= value2) : (short)0);
7819 if(!exp->expType)
7820 {
7821 exp->expType = op1->type;
7822 if(op1->type)
7823 op1->type->refCount++;
7824 }
7825 return 1;
7826 }
7827
7828 static unsigned int UShortDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7829 {
7830 unsigned short value2 = op2->__anon1.us;
7831
7832 exp->type = 2;
7833 exp->__anon1.__anon2.string = PrintUShort(value2 ? (op1->__anon1.us /= value2) : (unsigned short)0);
7834 if(!exp->expType)
7835 {
7836 exp->expType = op1->type;
7837 if(op1->type)
7838 op1->type->refCount++;
7839 }
7840 return 1;
7841 }
7842
7843 static unsigned int CharDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7844 {
7845 char value2 = op2->__anon1.c;
7846
7847 exp->type = 2;
7848 exp->__anon1.__anon2.string = PrintChar(value2 ? (op1->__anon1.c /= value2) : (char)0);
7849 if(!exp->expType)
7850 {
7851 exp->expType = op1->type;
7852 if(op1->type)
7853 op1->type->refCount++;
7854 }
7855 return 1;
7856 }
7857
7858 static unsigned int UCharDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7859 {
7860 unsigned char value2 = op2->__anon1.uc;
7861
7862 exp->type = 2;
7863 exp->__anon1.__anon2.string = PrintUChar(value2 ? (op1->__anon1.uc /= value2) : (unsigned char)0);
7864 if(!exp->expType)
7865 {
7866 exp->expType = op1->type;
7867 if(op1->type)
7868 op1->type->refCount++;
7869 }
7870 return 1;
7871 }
7872
7873 static unsigned int FloatDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7874 {
7875 float value2 = op2->__anon1.f;
7876
7877 exp->type = 2;
7878 exp->__anon1.__anon2.string = PrintFloat(op1->__anon1.f /= value2);
7879 if(!exp->expType)
7880 {
7881 exp->expType = op1->type;
7882 if(op1->type)
7883 op1->type->refCount++;
7884 }
7885 return 1;
7886 }
7887
7888 static unsigned int DoubleDivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7889 {
7890 double value2 = op2->__anon1.d;
7891
7892 exp->type = 2;
7893 exp->__anon1.__anon2.string = PrintDouble(op1->__anon1.d /= value2);
7894 if(!exp->expType)
7895 {
7896 exp->expType = op1->type;
7897 if(op1->type)
7898 op1->type->refCount++;
7899 }
7900 return 1;
7901 }
7902
7903 static unsigned int IntModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7904 {
7905 int value2 = op2->__anon1.i;
7906
7907 exp->type = 2;
7908 exp->__anon1.__anon2.string = PrintInt(value2 ? (op1->__anon1.i %= value2) : 0);
7909 if(!exp->expType)
7910 {
7911 exp->expType = op1->type;
7912 if(op1->type)
7913 op1->type->refCount++;
7914 }
7915 return 1;
7916 }
7917
7918 static unsigned int UIntModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7919 {
7920 unsigned int value2 = op2->__anon1.ui;
7921
7922 exp->type = 2;
7923 exp->__anon1.__anon2.string = PrintUInt(value2 ? (op1->__anon1.ui %= value2) : 0);
7924 if(!exp->expType)
7925 {
7926 exp->expType = op1->type;
7927 if(op1->type)
7928 op1->type->refCount++;
7929 }
7930 return 1;
7931 }
7932
7933 static unsigned int Int64ModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7934 {
7935 long long value2 = op2->__anon1.i64;
7936
7937 exp->type = 2;
7938 exp->__anon1.__anon2.string = PrintInt64(value2 ? (op1->__anon1.i64 %= value2) : 0);
7939 if(!exp->expType)
7940 {
7941 exp->expType = op1->type;
7942 if(op1->type)
7943 op1->type->refCount++;
7944 }
7945 return 1;
7946 }
7947
7948 static unsigned int UInt64ModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7949 {
7950 uint64 value2 = op2->__anon1.ui64;
7951
7952 exp->type = 2;
7953 exp->__anon1.__anon2.string = PrintUInt64(value2 ? (op1->__anon1.ui64 %= value2) : 0);
7954 if(!exp->expType)
7955 {
7956 exp->expType = op1->type;
7957 if(op1->type)
7958 op1->type->refCount++;
7959 }
7960 return 1;
7961 }
7962
7963 static unsigned int ShortModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7964 {
7965 short value2 = op2->__anon1.s;
7966
7967 exp->type = 2;
7968 exp->__anon1.__anon2.string = PrintShort(value2 ? (op1->__anon1.s %= value2) : (short)0);
7969 if(!exp->expType)
7970 {
7971 exp->expType = op1->type;
7972 if(op1->type)
7973 op1->type->refCount++;
7974 }
7975 return 1;
7976 }
7977
7978 static unsigned int UShortModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7979 {
7980 unsigned short value2 = op2->__anon1.us;
7981
7982 exp->type = 2;
7983 exp->__anon1.__anon2.string = PrintUShort(value2 ? (op1->__anon1.us %= value2) : (unsigned short)0);
7984 if(!exp->expType)
7985 {
7986 exp->expType = op1->type;
7987 if(op1->type)
7988 op1->type->refCount++;
7989 }
7990 return 1;
7991 }
7992
7993 static unsigned int CharModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
7994 {
7995 char value2 = op2->__anon1.c;
7996
7997 exp->type = 2;
7998 exp->__anon1.__anon2.string = PrintChar(value2 ? (op1->__anon1.c %= value2) : (char)0);
7999 if(!exp->expType)
8000 {
8001 exp->expType = op1->type;
8002 if(op1->type)
8003 op1->type->refCount++;
8004 }
8005 return 1;
8006 }
8007
8008 static unsigned int UCharModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8009 {
8010 unsigned char value2 = op2->__anon1.uc;
8011
8012 exp->type = 2;
8013 exp->__anon1.__anon2.string = PrintUChar(value2 ? (op1->__anon1.uc %= value2) : (unsigned char)0);
8014 if(!exp->expType)
8015 {
8016 exp->expType = op1->type;
8017 if(op1->type)
8018 op1->type->refCount++;
8019 }
8020 return 1;
8021 }
8022
8023 static unsigned int IntBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8024 {
8025 int value2 = op2->__anon1.i;
8026
8027 exp->type = 2;
8028 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i & value2));
8029 if(!exp->expType)
8030 {
8031 exp->expType = op1->type;
8032 if(op1->type)
8033 op1->type->refCount++;
8034 }
8035 return 1;
8036 }
8037
8038 static unsigned int UIntBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8039 {
8040 unsigned int value2 = op2->__anon1.ui;
8041
8042 exp->type = 2;
8043 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui & value2));
8044 if(!exp->expType)
8045 {
8046 exp->expType = op1->type;
8047 if(op1->type)
8048 op1->type->refCount++;
8049 }
8050 return 1;
8051 }
8052
8053 static unsigned int Int64BitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8054 {
8055 long long value2 = op2->__anon1.i64;
8056
8057 exp->type = 2;
8058 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 & value2));
8059 if(!exp->expType)
8060 {
8061 exp->expType = op1->type;
8062 if(op1->type)
8063 op1->type->refCount++;
8064 }
8065 return 1;
8066 }
8067
8068 static unsigned int UInt64BitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8069 {
8070 uint64 value2 = op2->__anon1.ui64;
8071
8072 exp->type = 2;
8073 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 & value2));
8074 if(!exp->expType)
8075 {
8076 exp->expType = op1->type;
8077 if(op1->type)
8078 op1->type->refCount++;
8079 }
8080 return 1;
8081 }
8082
8083 static unsigned int ShortBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8084 {
8085 short value2 = op2->__anon1.s;
8086
8087 exp->type = 2;
8088 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s & value2));
8089 if(!exp->expType)
8090 {
8091 exp->expType = op1->type;
8092 if(op1->type)
8093 op1->type->refCount++;
8094 }
8095 return 1;
8096 }
8097
8098 static unsigned int UShortBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8099 {
8100 unsigned short value2 = op2->__anon1.us;
8101
8102 exp->type = 2;
8103 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us & value2));
8104 if(!exp->expType)
8105 {
8106 exp->expType = op1->type;
8107 if(op1->type)
8108 op1->type->refCount++;
8109 }
8110 return 1;
8111 }
8112
8113 static unsigned int CharBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8114 {
8115 char value2 = op2->__anon1.c;
8116
8117 exp->type = 2;
8118 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c & value2));
8119 if(!exp->expType)
8120 {
8121 exp->expType = op1->type;
8122 if(op1->type)
8123 op1->type->refCount++;
8124 }
8125 return 1;
8126 }
8127
8128 static unsigned int UCharBitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8129 {
8130 unsigned char value2 = op2->__anon1.uc;
8131
8132 exp->type = 2;
8133 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc & value2));
8134 if(!exp->expType)
8135 {
8136 exp->expType = op1->type;
8137 if(op1->type)
8138 op1->type->refCount++;
8139 }
8140 return 1;
8141 }
8142
8143 static unsigned int IntBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8144 {
8145 int value2 = op2->__anon1.i;
8146
8147 exp->type = 2;
8148 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i | value2));
8149 if(!exp->expType)
8150 {
8151 exp->expType = op1->type;
8152 if(op1->type)
8153 op1->type->refCount++;
8154 }
8155 return 1;
8156 }
8157
8158 static unsigned int UIntBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8159 {
8160 unsigned int value2 = op2->__anon1.ui;
8161
8162 exp->type = 2;
8163 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui | value2));
8164 if(!exp->expType)
8165 {
8166 exp->expType = op1->type;
8167 if(op1->type)
8168 op1->type->refCount++;
8169 }
8170 return 1;
8171 }
8172
8173 static unsigned int Int64BitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8174 {
8175 long long value2 = op2->__anon1.i64;
8176
8177 exp->type = 2;
8178 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 | value2));
8179 if(!exp->expType)
8180 {
8181 exp->expType = op1->type;
8182 if(op1->type)
8183 op1->type->refCount++;
8184 }
8185 return 1;
8186 }
8187
8188 static unsigned int UInt64BitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8189 {
8190 uint64 value2 = op2->__anon1.ui64;
8191
8192 exp->type = 2;
8193 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 | value2));
8194 if(!exp->expType)
8195 {
8196 exp->expType = op1->type;
8197 if(op1->type)
8198 op1->type->refCount++;
8199 }
8200 return 1;
8201 }
8202
8203 static unsigned int ShortBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8204 {
8205 short value2 = op2->__anon1.s;
8206
8207 exp->type = 2;
8208 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s | value2));
8209 if(!exp->expType)
8210 {
8211 exp->expType = op1->type;
8212 if(op1->type)
8213 op1->type->refCount++;
8214 }
8215 return 1;
8216 }
8217
8218 static unsigned int UShortBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8219 {
8220 unsigned short value2 = op2->__anon1.us;
8221
8222 exp->type = 2;
8223 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us | value2));
8224 if(!exp->expType)
8225 {
8226 exp->expType = op1->type;
8227 if(op1->type)
8228 op1->type->refCount++;
8229 }
8230 return 1;
8231 }
8232
8233 static unsigned int CharBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8234 {
8235 char value2 = op2->__anon1.c;
8236
8237 exp->type = 2;
8238 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c | value2));
8239 if(!exp->expType)
8240 {
8241 exp->expType = op1->type;
8242 if(op1->type)
8243 op1->type->refCount++;
8244 }
8245 return 1;
8246 }
8247
8248 static unsigned int UCharBitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8249 {
8250 unsigned char value2 = op2->__anon1.uc;
8251
8252 exp->type = 2;
8253 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc | value2));
8254 if(!exp->expType)
8255 {
8256 exp->expType = op1->type;
8257 if(op1->type)
8258 op1->type->refCount++;
8259 }
8260 return 1;
8261 }
8262
8263 static unsigned int IntBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8264 {
8265 int value2 = op2->__anon1.i;
8266
8267 exp->type = 2;
8268 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i ^ value2));
8269 if(!exp->expType)
8270 {
8271 exp->expType = op1->type;
8272 if(op1->type)
8273 op1->type->refCount++;
8274 }
8275 return 1;
8276 }
8277
8278 static unsigned int UIntBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8279 {
8280 unsigned int value2 = op2->__anon1.ui;
8281
8282 exp->type = 2;
8283 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui ^ value2));
8284 if(!exp->expType)
8285 {
8286 exp->expType = op1->type;
8287 if(op1->type)
8288 op1->type->refCount++;
8289 }
8290 return 1;
8291 }
8292
8293 static unsigned int Int64BitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8294 {
8295 long long value2 = op2->__anon1.i64;
8296
8297 exp->type = 2;
8298 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 ^ value2));
8299 if(!exp->expType)
8300 {
8301 exp->expType = op1->type;
8302 if(op1->type)
8303 op1->type->refCount++;
8304 }
8305 return 1;
8306 }
8307
8308 static unsigned int UInt64BitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8309 {
8310 uint64 value2 = op2->__anon1.ui64;
8311
8312 exp->type = 2;
8313 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 ^ value2));
8314 if(!exp->expType)
8315 {
8316 exp->expType = op1->type;
8317 if(op1->type)
8318 op1->type->refCount++;
8319 }
8320 return 1;
8321 }
8322
8323 static unsigned int ShortBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8324 {
8325 short value2 = op2->__anon1.s;
8326
8327 exp->type = 2;
8328 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s ^ value2));
8329 if(!exp->expType)
8330 {
8331 exp->expType = op1->type;
8332 if(op1->type)
8333 op1->type->refCount++;
8334 }
8335 return 1;
8336 }
8337
8338 static unsigned int UShortBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8339 {
8340 unsigned short value2 = op2->__anon1.us;
8341
8342 exp->type = 2;
8343 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us ^ value2));
8344 if(!exp->expType)
8345 {
8346 exp->expType = op1->type;
8347 if(op1->type)
8348 op1->type->refCount++;
8349 }
8350 return 1;
8351 }
8352
8353 static unsigned int CharBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8354 {
8355 char value2 = op2->__anon1.c;
8356
8357 exp->type = 2;
8358 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c ^ value2));
8359 if(!exp->expType)
8360 {
8361 exp->expType = op1->type;
8362 if(op1->type)
8363 op1->type->refCount++;
8364 }
8365 return 1;
8366 }
8367
8368 static unsigned int UCharBitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8369 {
8370 unsigned char value2 = op2->__anon1.uc;
8371
8372 exp->type = 2;
8373 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc ^ value2));
8374 if(!exp->expType)
8375 {
8376 exp->expType = op1->type;
8377 if(op1->type)
8378 op1->type->refCount++;
8379 }
8380 return 1;
8381 }
8382
8383 static unsigned int IntLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8384 {
8385 int value2 = op2->__anon1.i;
8386
8387 exp->type = 2;
8388 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i << value2));
8389 if(!exp->expType)
8390 {
8391 exp->expType = op1->type;
8392 if(op1->type)
8393 op1->type->refCount++;
8394 }
8395 return 1;
8396 }
8397
8398 static unsigned int UIntLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8399 {
8400 unsigned int value2 = op2->__anon1.ui;
8401
8402 exp->type = 2;
8403 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui << value2));
8404 if(!exp->expType)
8405 {
8406 exp->expType = op1->type;
8407 if(op1->type)
8408 op1->type->refCount++;
8409 }
8410 return 1;
8411 }
8412
8413 static unsigned int Int64LShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8414 {
8415 long long value2 = op2->__anon1.i64;
8416
8417 exp->type = 2;
8418 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 << value2));
8419 if(!exp->expType)
8420 {
8421 exp->expType = op1->type;
8422 if(op1->type)
8423 op1->type->refCount++;
8424 }
8425 return 1;
8426 }
8427
8428 static unsigned int UInt64LShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8429 {
8430 uint64 value2 = op2->__anon1.ui64;
8431
8432 exp->type = 2;
8433 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 << value2));
8434 if(!exp->expType)
8435 {
8436 exp->expType = op1->type;
8437 if(op1->type)
8438 op1->type->refCount++;
8439 }
8440 return 1;
8441 }
8442
8443 static unsigned int ShortLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8444 {
8445 short value2 = op2->__anon1.s;
8446
8447 exp->type = 2;
8448 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s << value2));
8449 if(!exp->expType)
8450 {
8451 exp->expType = op1->type;
8452 if(op1->type)
8453 op1->type->refCount++;
8454 }
8455 return 1;
8456 }
8457
8458 static unsigned int UShortLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8459 {
8460 unsigned short value2 = op2->__anon1.us;
8461
8462 exp->type = 2;
8463 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us << value2));
8464 if(!exp->expType)
8465 {
8466 exp->expType = op1->type;
8467 if(op1->type)
8468 op1->type->refCount++;
8469 }
8470 return 1;
8471 }
8472
8473 static unsigned int CharLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8474 {
8475 char value2 = op2->__anon1.c;
8476
8477 exp->type = 2;
8478 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c << value2));
8479 if(!exp->expType)
8480 {
8481 exp->expType = op1->type;
8482 if(op1->type)
8483 op1->type->refCount++;
8484 }
8485 return 1;
8486 }
8487
8488 static unsigned int UCharLShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8489 {
8490 unsigned char value2 = op2->__anon1.uc;
8491
8492 exp->type = 2;
8493 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc << value2));
8494 if(!exp->expType)
8495 {
8496 exp->expType = op1->type;
8497 if(op1->type)
8498 op1->type->refCount++;
8499 }
8500 return 1;
8501 }
8502
8503 static unsigned int IntRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8504 {
8505 int value2 = op2->__anon1.i;
8506
8507 exp->type = 2;
8508 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i >> value2));
8509 if(!exp->expType)
8510 {
8511 exp->expType = op1->type;
8512 if(op1->type)
8513 op1->type->refCount++;
8514 }
8515 return 1;
8516 }
8517
8518 static unsigned int UIntRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8519 {
8520 unsigned int value2 = op2->__anon1.ui;
8521
8522 exp->type = 2;
8523 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui >> value2));
8524 if(!exp->expType)
8525 {
8526 exp->expType = op1->type;
8527 if(op1->type)
8528 op1->type->refCount++;
8529 }
8530 return 1;
8531 }
8532
8533 static unsigned int Int64RShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8534 {
8535 long long value2 = op2->__anon1.i64;
8536
8537 exp->type = 2;
8538 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 >> value2));
8539 if(!exp->expType)
8540 {
8541 exp->expType = op1->type;
8542 if(op1->type)
8543 op1->type->refCount++;
8544 }
8545 return 1;
8546 }
8547
8548 static unsigned int UInt64RShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8549 {
8550 uint64 value2 = op2->__anon1.ui64;
8551
8552 exp->type = 2;
8553 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 >> value2));
8554 if(!exp->expType)
8555 {
8556 exp->expType = op1->type;
8557 if(op1->type)
8558 op1->type->refCount++;
8559 }
8560 return 1;
8561 }
8562
8563 static unsigned int ShortRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8564 {
8565 short value2 = op2->__anon1.s;
8566
8567 exp->type = 2;
8568 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s >> value2));
8569 if(!exp->expType)
8570 {
8571 exp->expType = op1->type;
8572 if(op1->type)
8573 op1->type->refCount++;
8574 }
8575 return 1;
8576 }
8577
8578 static unsigned int UShortRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8579 {
8580 unsigned short value2 = op2->__anon1.us;
8581
8582 exp->type = 2;
8583 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us >> value2));
8584 if(!exp->expType)
8585 {
8586 exp->expType = op1->type;
8587 if(op1->type)
8588 op1->type->refCount++;
8589 }
8590 return 1;
8591 }
8592
8593 static unsigned int CharRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8594 {
8595 char value2 = op2->__anon1.c;
8596
8597 exp->type = 2;
8598 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c >> value2));
8599 if(!exp->expType)
8600 {
8601 exp->expType = op1->type;
8602 if(op1->type)
8603 op1->type->refCount++;
8604 }
8605 return 1;
8606 }
8607
8608 static unsigned int UCharRShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8609 {
8610 unsigned char value2 = op2->__anon1.uc;
8611
8612 exp->type = 2;
8613 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc >> value2));
8614 if(!exp->expType)
8615 {
8616 exp->expType = op1->type;
8617 if(op1->type)
8618 op1->type->refCount++;
8619 }
8620 return 1;
8621 }
8622
8623 static unsigned int IntBitNot(struct Expression * exp, struct Operand * op1)
8624 {
8625 exp->type = 2;
8626 exp->__anon1.__anon2.string = PrintInt((~op1->__anon1.i));
8627 if(!exp->expType)
8628 {
8629 exp->expType = op1->type;
8630 if(op1->type)
8631 op1->type->refCount++;
8632 }
8633 return 1;
8634 }
8635
8636 static unsigned int UIntBitNot(struct Expression * exp, struct Operand * op1)
8637 {
8638 exp->type = 2;
8639 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(~op1->__anon1.ui));
8640 if(!exp->expType)
8641 {
8642 exp->expType = op1->type;
8643 if(op1->type)
8644 op1->type->refCount++;
8645 }
8646 return 1;
8647 }
8648
8649 static unsigned int Int64BitNot(struct Expression * exp, struct Operand * op1)
8650 {
8651 exp->type = 2;
8652 exp->__anon1.__anon2.string = PrintInt64((long long)(~op1->__anon1.i64));
8653 if(!exp->expType)
8654 {
8655 exp->expType = op1->type;
8656 if(op1->type)
8657 op1->type->refCount++;
8658 }
8659 return 1;
8660 }
8661
8662 static unsigned int UInt64BitNot(struct Expression * exp, struct Operand * op1)
8663 {
8664 exp->type = 2;
8665 exp->__anon1.__anon2.string = PrintUInt64((uint64)(~op1->__anon1.ui64));
8666 if(!exp->expType)
8667 {
8668 exp->expType = op1->type;
8669 if(op1->type)
8670 op1->type->refCount++;
8671 }
8672 return 1;
8673 }
8674
8675 static unsigned int ShortBitNot(struct Expression * exp, struct Operand * op1)
8676 {
8677 exp->type = 2;
8678 exp->__anon1.__anon2.string = PrintShort((short)(~op1->__anon1.s));
8679 if(!exp->expType)
8680 {
8681 exp->expType = op1->type;
8682 if(op1->type)
8683 op1->type->refCount++;
8684 }
8685 return 1;
8686 }
8687
8688 static unsigned int UShortBitNot(struct Expression * exp, struct Operand * op1)
8689 {
8690 exp->type = 2;
8691 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(~op1->__anon1.us));
8692 if(!exp->expType)
8693 {
8694 exp->expType = op1->type;
8695 if(op1->type)
8696 op1->type->refCount++;
8697 }
8698 return 1;
8699 }
8700
8701 static unsigned int CharBitNot(struct Expression * exp, struct Operand * op1)
8702 {
8703 exp->type = 2;
8704 exp->__anon1.__anon2.string = PrintChar((char)(~op1->__anon1.c));
8705 if(!exp->expType)
8706 {
8707 exp->expType = op1->type;
8708 if(op1->type)
8709 op1->type->refCount++;
8710 }
8711 return 1;
8712 }
8713
8714 static unsigned int UCharBitNot(struct Expression * exp, struct Operand * op1)
8715 {
8716 exp->type = 2;
8717 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(~op1->__anon1.uc));
8718 if(!exp->expType)
8719 {
8720 exp->expType = op1->type;
8721 if(op1->type)
8722 op1->type->refCount++;
8723 }
8724 return 1;
8725 }
8726
8727 static unsigned int IntAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8728 {
8729 int value2 = op2->__anon1.i;
8730
8731 exp->type = 2;
8732 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i &= value2));
8733 if(!exp->expType)
8734 {
8735 exp->expType = op1->type;
8736 if(op1->type)
8737 op1->type->refCount++;
8738 }
8739 return 1;
8740 }
8741
8742 static unsigned int UIntAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8743 {
8744 unsigned int value2 = op2->__anon1.ui;
8745
8746 exp->type = 2;
8747 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui &= value2));
8748 if(!exp->expType)
8749 {
8750 exp->expType = op1->type;
8751 if(op1->type)
8752 op1->type->refCount++;
8753 }
8754 return 1;
8755 }
8756
8757 static unsigned int Int64AndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8758 {
8759 long long value2 = op2->__anon1.i64;
8760
8761 exp->type = 2;
8762 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 &= value2));
8763 if(!exp->expType)
8764 {
8765 exp->expType = op1->type;
8766 if(op1->type)
8767 op1->type->refCount++;
8768 }
8769 return 1;
8770 }
8771
8772 static unsigned int UInt64AndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8773 {
8774 uint64 value2 = op2->__anon1.ui64;
8775
8776 exp->type = 2;
8777 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 &= value2));
8778 if(!exp->expType)
8779 {
8780 exp->expType = op1->type;
8781 if(op1->type)
8782 op1->type->refCount++;
8783 }
8784 return 1;
8785 }
8786
8787 static unsigned int ShortAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8788 {
8789 short value2 = op2->__anon1.s;
8790
8791 exp->type = 2;
8792 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s &= value2));
8793 if(!exp->expType)
8794 {
8795 exp->expType = op1->type;
8796 if(op1->type)
8797 op1->type->refCount++;
8798 }
8799 return 1;
8800 }
8801
8802 static unsigned int UShortAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8803 {
8804 unsigned short value2 = op2->__anon1.us;
8805
8806 exp->type = 2;
8807 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us &= value2));
8808 if(!exp->expType)
8809 {
8810 exp->expType = op1->type;
8811 if(op1->type)
8812 op1->type->refCount++;
8813 }
8814 return 1;
8815 }
8816
8817 static unsigned int CharAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8818 {
8819 char value2 = op2->__anon1.c;
8820
8821 exp->type = 2;
8822 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c &= value2));
8823 if(!exp->expType)
8824 {
8825 exp->expType = op1->type;
8826 if(op1->type)
8827 op1->type->refCount++;
8828 }
8829 return 1;
8830 }
8831
8832 static unsigned int UCharAndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8833 {
8834 unsigned char value2 = op2->__anon1.uc;
8835
8836 exp->type = 2;
8837 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc &= value2));
8838 if(!exp->expType)
8839 {
8840 exp->expType = op1->type;
8841 if(op1->type)
8842 op1->type->refCount++;
8843 }
8844 return 1;
8845 }
8846
8847 static unsigned int IntOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8848 {
8849 int value2 = op2->__anon1.i;
8850
8851 exp->type = 2;
8852 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i |= value2));
8853 if(!exp->expType)
8854 {
8855 exp->expType = op1->type;
8856 if(op1->type)
8857 op1->type->refCount++;
8858 }
8859 return 1;
8860 }
8861
8862 static unsigned int UIntOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8863 {
8864 unsigned int value2 = op2->__anon1.ui;
8865
8866 exp->type = 2;
8867 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui |= value2));
8868 if(!exp->expType)
8869 {
8870 exp->expType = op1->type;
8871 if(op1->type)
8872 op1->type->refCount++;
8873 }
8874 return 1;
8875 }
8876
8877 static unsigned int Int64OrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8878 {
8879 long long value2 = op2->__anon1.i64;
8880
8881 exp->type = 2;
8882 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 |= value2));
8883 if(!exp->expType)
8884 {
8885 exp->expType = op1->type;
8886 if(op1->type)
8887 op1->type->refCount++;
8888 }
8889 return 1;
8890 }
8891
8892 static unsigned int UInt64OrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8893 {
8894 uint64 value2 = op2->__anon1.ui64;
8895
8896 exp->type = 2;
8897 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 |= value2));
8898 if(!exp->expType)
8899 {
8900 exp->expType = op1->type;
8901 if(op1->type)
8902 op1->type->refCount++;
8903 }
8904 return 1;
8905 }
8906
8907 static unsigned int ShortOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8908 {
8909 short value2 = op2->__anon1.s;
8910
8911 exp->type = 2;
8912 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s |= value2));
8913 if(!exp->expType)
8914 {
8915 exp->expType = op1->type;
8916 if(op1->type)
8917 op1->type->refCount++;
8918 }
8919 return 1;
8920 }
8921
8922 static unsigned int UShortOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8923 {
8924 unsigned short value2 = op2->__anon1.us;
8925
8926 exp->type = 2;
8927 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us |= value2));
8928 if(!exp->expType)
8929 {
8930 exp->expType = op1->type;
8931 if(op1->type)
8932 op1->type->refCount++;
8933 }
8934 return 1;
8935 }
8936
8937 static unsigned int CharOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8938 {
8939 char value2 = op2->__anon1.c;
8940
8941 exp->type = 2;
8942 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c |= value2));
8943 if(!exp->expType)
8944 {
8945 exp->expType = op1->type;
8946 if(op1->type)
8947 op1->type->refCount++;
8948 }
8949 return 1;
8950 }
8951
8952 static unsigned int UCharOrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8953 {
8954 unsigned char value2 = op2->__anon1.uc;
8955
8956 exp->type = 2;
8957 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc |= value2));
8958 if(!exp->expType)
8959 {
8960 exp->expType = op1->type;
8961 if(op1->type)
8962 op1->type->refCount++;
8963 }
8964 return 1;
8965 }
8966
8967 static unsigned int IntXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8968 {
8969 int value2 = op2->__anon1.i;
8970
8971 exp->type = 2;
8972 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i ^= value2));
8973 if(!exp->expType)
8974 {
8975 exp->expType = op1->type;
8976 if(op1->type)
8977 op1->type->refCount++;
8978 }
8979 return 1;
8980 }
8981
8982 static unsigned int UIntXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8983 {
8984 unsigned int value2 = op2->__anon1.ui;
8985
8986 exp->type = 2;
8987 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui ^= value2));
8988 if(!exp->expType)
8989 {
8990 exp->expType = op1->type;
8991 if(op1->type)
8992 op1->type->refCount++;
8993 }
8994 return 1;
8995 }
8996
8997 static unsigned int Int64XorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
8998 {
8999 long long value2 = op2->__anon1.i64;
9000
9001 exp->type = 2;
9002 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 ^= value2));
9003 if(!exp->expType)
9004 {
9005 exp->expType = op1->type;
9006 if(op1->type)
9007 op1->type->refCount++;
9008 }
9009 return 1;
9010 }
9011
9012 static unsigned int UInt64XorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9013 {
9014 uint64 value2 = op2->__anon1.ui64;
9015
9016 exp->type = 2;
9017 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 ^= value2));
9018 if(!exp->expType)
9019 {
9020 exp->expType = op1->type;
9021 if(op1->type)
9022 op1->type->refCount++;
9023 }
9024 return 1;
9025 }
9026
9027 static unsigned int ShortXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9028 {
9029 short value2 = op2->__anon1.s;
9030
9031 exp->type = 2;
9032 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s ^= value2));
9033 if(!exp->expType)
9034 {
9035 exp->expType = op1->type;
9036 if(op1->type)
9037 op1->type->refCount++;
9038 }
9039 return 1;
9040 }
9041
9042 static unsigned int UShortXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9043 {
9044 unsigned short value2 = op2->__anon1.us;
9045
9046 exp->type = 2;
9047 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us ^= value2));
9048 if(!exp->expType)
9049 {
9050 exp->expType = op1->type;
9051 if(op1->type)
9052 op1->type->refCount++;
9053 }
9054 return 1;
9055 }
9056
9057 static unsigned int CharXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9058 {
9059 char value2 = op2->__anon1.c;
9060
9061 exp->type = 2;
9062 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c ^= value2));
9063 if(!exp->expType)
9064 {
9065 exp->expType = op1->type;
9066 if(op1->type)
9067 op1->type->refCount++;
9068 }
9069 return 1;
9070 }
9071
9072 static unsigned int UCharXorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9073 {
9074 unsigned char value2 = op2->__anon1.uc;
9075
9076 exp->type = 2;
9077 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc ^= value2));
9078 if(!exp->expType)
9079 {
9080 exp->expType = op1->type;
9081 if(op1->type)
9082 op1->type->refCount++;
9083 }
9084 return 1;
9085 }
9086
9087 static unsigned int IntLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9088 {
9089 int value2 = op2->__anon1.i;
9090
9091 exp->type = 2;
9092 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i <<= value2));
9093 if(!exp->expType)
9094 {
9095 exp->expType = op1->type;
9096 if(op1->type)
9097 op1->type->refCount++;
9098 }
9099 return 1;
9100 }
9101
9102 static unsigned int UIntLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9103 {
9104 unsigned int value2 = op2->__anon1.ui;
9105
9106 exp->type = 2;
9107 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui <<= value2));
9108 if(!exp->expType)
9109 {
9110 exp->expType = op1->type;
9111 if(op1->type)
9112 op1->type->refCount++;
9113 }
9114 return 1;
9115 }
9116
9117 static unsigned int Int64LShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9118 {
9119 long long value2 = op2->__anon1.i64;
9120
9121 exp->type = 2;
9122 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 <<= value2));
9123 if(!exp->expType)
9124 {
9125 exp->expType = op1->type;
9126 if(op1->type)
9127 op1->type->refCount++;
9128 }
9129 return 1;
9130 }
9131
9132 static unsigned int UInt64LShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9133 {
9134 uint64 value2 = op2->__anon1.ui64;
9135
9136 exp->type = 2;
9137 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 <<= value2));
9138 if(!exp->expType)
9139 {
9140 exp->expType = op1->type;
9141 if(op1->type)
9142 op1->type->refCount++;
9143 }
9144 return 1;
9145 }
9146
9147 static unsigned int ShortLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9148 {
9149 short value2 = op2->__anon1.s;
9150
9151 exp->type = 2;
9152 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s <<= value2));
9153 if(!exp->expType)
9154 {
9155 exp->expType = op1->type;
9156 if(op1->type)
9157 op1->type->refCount++;
9158 }
9159 return 1;
9160 }
9161
9162 static unsigned int UShortLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9163 {
9164 unsigned short value2 = op2->__anon1.us;
9165
9166 exp->type = 2;
9167 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us <<= value2));
9168 if(!exp->expType)
9169 {
9170 exp->expType = op1->type;
9171 if(op1->type)
9172 op1->type->refCount++;
9173 }
9174 return 1;
9175 }
9176
9177 static unsigned int CharLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9178 {
9179 char value2 = op2->__anon1.c;
9180
9181 exp->type = 2;
9182 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c <<= value2));
9183 if(!exp->expType)
9184 {
9185 exp->expType = op1->type;
9186 if(op1->type)
9187 op1->type->refCount++;
9188 }
9189 return 1;
9190 }
9191
9192 static unsigned int UCharLShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9193 {
9194 unsigned char value2 = op2->__anon1.uc;
9195
9196 exp->type = 2;
9197 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc <<= value2));
9198 if(!exp->expType)
9199 {
9200 exp->expType = op1->type;
9201 if(op1->type)
9202 op1->type->refCount++;
9203 }
9204 return 1;
9205 }
9206
9207 static unsigned int IntRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9208 {
9209 int value2 = op2->__anon1.i;
9210
9211 exp->type = 2;
9212 exp->__anon1.__anon2.string = PrintInt((op1->__anon1.i >>= value2));
9213 if(!exp->expType)
9214 {
9215 exp->expType = op1->type;
9216 if(op1->type)
9217 op1->type->refCount++;
9218 }
9219 return 1;
9220 }
9221
9222 static unsigned int UIntRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9223 {
9224 unsigned int value2 = op2->__anon1.ui;
9225
9226 exp->type = 2;
9227 exp->__anon1.__anon2.string = PrintUInt((op1->__anon1.ui >>= value2));
9228 if(!exp->expType)
9229 {
9230 exp->expType = op1->type;
9231 if(op1->type)
9232 op1->type->refCount++;
9233 }
9234 return 1;
9235 }
9236
9237 static unsigned int Int64RShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9238 {
9239 long long value2 = op2->__anon1.i64;
9240
9241 exp->type = 2;
9242 exp->__anon1.__anon2.string = PrintInt64((op1->__anon1.i64 >>= value2));
9243 if(!exp->expType)
9244 {
9245 exp->expType = op1->type;
9246 if(op1->type)
9247 op1->type->refCount++;
9248 }
9249 return 1;
9250 }
9251
9252 static unsigned int UInt64RShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9253 {
9254 uint64 value2 = op2->__anon1.ui64;
9255
9256 exp->type = 2;
9257 exp->__anon1.__anon2.string = PrintUInt64((op1->__anon1.ui64 >>= value2));
9258 if(!exp->expType)
9259 {
9260 exp->expType = op1->type;
9261 if(op1->type)
9262 op1->type->refCount++;
9263 }
9264 return 1;
9265 }
9266
9267 static unsigned int ShortRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9268 {
9269 short value2 = op2->__anon1.s;
9270
9271 exp->type = 2;
9272 exp->__anon1.__anon2.string = PrintShort((op1->__anon1.s >>= value2));
9273 if(!exp->expType)
9274 {
9275 exp->expType = op1->type;
9276 if(op1->type)
9277 op1->type->refCount++;
9278 }
9279 return 1;
9280 }
9281
9282 static unsigned int UShortRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9283 {
9284 unsigned short value2 = op2->__anon1.us;
9285
9286 exp->type = 2;
9287 exp->__anon1.__anon2.string = PrintUShort((op1->__anon1.us >>= value2));
9288 if(!exp->expType)
9289 {
9290 exp->expType = op1->type;
9291 if(op1->type)
9292 op1->type->refCount++;
9293 }
9294 return 1;
9295 }
9296
9297 static unsigned int CharRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9298 {
9299 char value2 = op2->__anon1.c;
9300
9301 exp->type = 2;
9302 exp->__anon1.__anon2.string = PrintChar((op1->__anon1.c >>= value2));
9303 if(!exp->expType)
9304 {
9305 exp->expType = op1->type;
9306 if(op1->type)
9307 op1->type->refCount++;
9308 }
9309 return 1;
9310 }
9311
9312 static unsigned int UCharRShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9313 {
9314 unsigned char value2 = op2->__anon1.uc;
9315
9316 exp->type = 2;
9317 exp->__anon1.__anon2.string = PrintUChar((op1->__anon1.uc >>= value2));
9318 if(!exp->expType)
9319 {
9320 exp->expType = op1->type;
9321 if(op1->type)
9322 op1->type->refCount++;
9323 }
9324 return 1;
9325 }
9326
9327 static unsigned int IntNot(struct Expression * exp, struct Operand * op1)
9328 {
9329 exp->type = 2;
9330 exp->__anon1.__anon2.string = PrintInt((int)(!op1->__anon1.i));
9331 if(!exp->expType)
9332 {
9333 exp->expType = op1->type;
9334 if(op1->type)
9335 op1->type->refCount++;
9336 }
9337 return 1;
9338 }
9339
9340 static unsigned int UIntNot(struct Expression * exp, struct Operand * op1)
9341 {
9342 exp->type = 2;
9343 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(!op1->__anon1.ui));
9344 if(!exp->expType)
9345 {
9346 exp->expType = op1->type;
9347 if(op1->type)
9348 op1->type->refCount++;
9349 }
9350 return 1;
9351 }
9352
9353 static unsigned int Int64Not(struct Expression * exp, struct Operand * op1)
9354 {
9355 exp->type = 2;
9356 exp->__anon1.__anon2.string = PrintInt64((long long)(!op1->__anon1.i64));
9357 if(!exp->expType)
9358 {
9359 exp->expType = op1->type;
9360 if(op1->type)
9361 op1->type->refCount++;
9362 }
9363 return 1;
9364 }
9365
9366 static unsigned int UInt64Not(struct Expression * exp, struct Operand * op1)
9367 {
9368 exp->type = 2;
9369 exp->__anon1.__anon2.string = PrintUInt64((uint64)(!op1->__anon1.ui64));
9370 if(!exp->expType)
9371 {
9372 exp->expType = op1->type;
9373 if(op1->type)
9374 op1->type->refCount++;
9375 }
9376 return 1;
9377 }
9378
9379 static unsigned int ShortNot(struct Expression * exp, struct Operand * op1)
9380 {
9381 exp->type = 2;
9382 exp->__anon1.__anon2.string = PrintShort((short)(!op1->__anon1.s));
9383 if(!exp->expType)
9384 {
9385 exp->expType = op1->type;
9386 if(op1->type)
9387 op1->type->refCount++;
9388 }
9389 return 1;
9390 }
9391
9392 static unsigned int UShortNot(struct Expression * exp, struct Operand * op1)
9393 {
9394 exp->type = 2;
9395 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(!op1->__anon1.us));
9396 if(!exp->expType)
9397 {
9398 exp->expType = op1->type;
9399 if(op1->type)
9400 op1->type->refCount++;
9401 }
9402 return 1;
9403 }
9404
9405 static unsigned int CharNot(struct Expression * exp, struct Operand * op1)
9406 {
9407 exp->type = 2;
9408 exp->__anon1.__anon2.string = PrintChar((char)(!op1->__anon1.c));
9409 if(!exp->expType)
9410 {
9411 exp->expType = op1->type;
9412 if(op1->type)
9413 op1->type->refCount++;
9414 }
9415 return 1;
9416 }
9417
9418 static unsigned int UCharNot(struct Expression * exp, struct Operand * op1)
9419 {
9420 exp->type = 2;
9421 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(!op1->__anon1.uc));
9422 if(!exp->expType)
9423 {
9424 exp->expType = op1->type;
9425 if(op1->type)
9426 op1->type->refCount++;
9427 }
9428 return 1;
9429 }
9430
9431 static unsigned int IntEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9432 {
9433 int value2 = op2->__anon1.i;
9434
9435 exp->type = 2;
9436 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i == value2));
9437 if(!exp->expType)
9438 {
9439 exp->expType = op1->type;
9440 if(op1->type)
9441 op1->type->refCount++;
9442 }
9443 return 1;
9444 }
9445
9446 static unsigned int UIntEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9447 {
9448 unsigned int value2 = op2->__anon1.ui;
9449
9450 exp->type = 2;
9451 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui == value2));
9452 if(!exp->expType)
9453 {
9454 exp->expType = op1->type;
9455 if(op1->type)
9456 op1->type->refCount++;
9457 }
9458 return 1;
9459 }
9460
9461 static unsigned int Int64Equ(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9462 {
9463 long long value2 = op2->__anon1.i64;
9464
9465 exp->type = 2;
9466 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 == value2));
9467 if(!exp->expType)
9468 {
9469 exp->expType = op1->type;
9470 if(op1->type)
9471 op1->type->refCount++;
9472 }
9473 return 1;
9474 }
9475
9476 static unsigned int UInt64Equ(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9477 {
9478 uint64 value2 = op2->__anon1.ui64;
9479
9480 exp->type = 2;
9481 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 == value2));
9482 if(!exp->expType)
9483 {
9484 exp->expType = op1->type;
9485 if(op1->type)
9486 op1->type->refCount++;
9487 }
9488 return 1;
9489 }
9490
9491 static unsigned int ShortEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9492 {
9493 short value2 = op2->__anon1.s;
9494
9495 exp->type = 2;
9496 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s == value2));
9497 if(!exp->expType)
9498 {
9499 exp->expType = op1->type;
9500 if(op1->type)
9501 op1->type->refCount++;
9502 }
9503 return 1;
9504 }
9505
9506 static unsigned int UShortEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9507 {
9508 unsigned short value2 = op2->__anon1.us;
9509
9510 exp->type = 2;
9511 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us == value2));
9512 if(!exp->expType)
9513 {
9514 exp->expType = op1->type;
9515 if(op1->type)
9516 op1->type->refCount++;
9517 }
9518 return 1;
9519 }
9520
9521 static unsigned int CharEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9522 {
9523 char value2 = op2->__anon1.c;
9524
9525 exp->type = 2;
9526 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c == value2));
9527 if(!exp->expType)
9528 {
9529 exp->expType = op1->type;
9530 if(op1->type)
9531 op1->type->refCount++;
9532 }
9533 return 1;
9534 }
9535
9536 static unsigned int UCharEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9537 {
9538 unsigned char value2 = op2->__anon1.uc;
9539
9540 exp->type = 2;
9541 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc == value2));
9542 if(!exp->expType)
9543 {
9544 exp->expType = op1->type;
9545 if(op1->type)
9546 op1->type->refCount++;
9547 }
9548 return 1;
9549 }
9550
9551 static unsigned int FloatEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9552 {
9553 float value2 = op2->__anon1.f;
9554
9555 exp->type = 2;
9556 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f == value2));
9557 if(!exp->expType)
9558 {
9559 exp->expType = op1->type;
9560 if(op1->type)
9561 op1->type->refCount++;
9562 }
9563 return 1;
9564 }
9565
9566 static unsigned int DoubleEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9567 {
9568 double value2 = op2->__anon1.d;
9569
9570 exp->type = 2;
9571 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d == value2));
9572 if(!exp->expType)
9573 {
9574 exp->expType = op1->type;
9575 if(op1->type)
9576 op1->type->refCount++;
9577 }
9578 return 1;
9579 }
9580
9581 static unsigned int IntNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9582 {
9583 int value2 = op2->__anon1.i;
9584
9585 exp->type = 2;
9586 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i != value2));
9587 if(!exp->expType)
9588 {
9589 exp->expType = op1->type;
9590 if(op1->type)
9591 op1->type->refCount++;
9592 }
9593 return 1;
9594 }
9595
9596 static unsigned int UIntNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9597 {
9598 unsigned int value2 = op2->__anon1.ui;
9599
9600 exp->type = 2;
9601 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui != value2));
9602 if(!exp->expType)
9603 {
9604 exp->expType = op1->type;
9605 if(op1->type)
9606 op1->type->refCount++;
9607 }
9608 return 1;
9609 }
9610
9611 static unsigned int Int64Nqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9612 {
9613 long long value2 = op2->__anon1.i64;
9614
9615 exp->type = 2;
9616 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 != value2));
9617 if(!exp->expType)
9618 {
9619 exp->expType = op1->type;
9620 if(op1->type)
9621 op1->type->refCount++;
9622 }
9623 return 1;
9624 }
9625
9626 static unsigned int UInt64Nqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9627 {
9628 uint64 value2 = op2->__anon1.ui64;
9629
9630 exp->type = 2;
9631 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 != value2));
9632 if(!exp->expType)
9633 {
9634 exp->expType = op1->type;
9635 if(op1->type)
9636 op1->type->refCount++;
9637 }
9638 return 1;
9639 }
9640
9641 static unsigned int ShortNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9642 {
9643 short value2 = op2->__anon1.s;
9644
9645 exp->type = 2;
9646 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s != value2));
9647 if(!exp->expType)
9648 {
9649 exp->expType = op1->type;
9650 if(op1->type)
9651 op1->type->refCount++;
9652 }
9653 return 1;
9654 }
9655
9656 static unsigned int UShortNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9657 {
9658 unsigned short value2 = op2->__anon1.us;
9659
9660 exp->type = 2;
9661 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us != value2));
9662 if(!exp->expType)
9663 {
9664 exp->expType = op1->type;
9665 if(op1->type)
9666 op1->type->refCount++;
9667 }
9668 return 1;
9669 }
9670
9671 static unsigned int CharNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9672 {
9673 char value2 = op2->__anon1.c;
9674
9675 exp->type = 2;
9676 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c != value2));
9677 if(!exp->expType)
9678 {
9679 exp->expType = op1->type;
9680 if(op1->type)
9681 op1->type->refCount++;
9682 }
9683 return 1;
9684 }
9685
9686 static unsigned int UCharNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9687 {
9688 unsigned char value2 = op2->__anon1.uc;
9689
9690 exp->type = 2;
9691 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc != value2));
9692 if(!exp->expType)
9693 {
9694 exp->expType = op1->type;
9695 if(op1->type)
9696 op1->type->refCount++;
9697 }
9698 return 1;
9699 }
9700
9701 static unsigned int FloatNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9702 {
9703 float value2 = op2->__anon1.f;
9704
9705 exp->type = 2;
9706 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f != value2));
9707 if(!exp->expType)
9708 {
9709 exp->expType = op1->type;
9710 if(op1->type)
9711 op1->type->refCount++;
9712 }
9713 return 1;
9714 }
9715
9716 static unsigned int DoubleNqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9717 {
9718 double value2 = op2->__anon1.d;
9719
9720 exp->type = 2;
9721 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d != value2));
9722 if(!exp->expType)
9723 {
9724 exp->expType = op1->type;
9725 if(op1->type)
9726 op1->type->refCount++;
9727 }
9728 return 1;
9729 }
9730
9731 static unsigned int IntAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9732 {
9733 int value2 = op2->__anon1.i;
9734
9735 exp->type = 2;
9736 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i && value2));
9737 if(!exp->expType)
9738 {
9739 exp->expType = op1->type;
9740 if(op1->type)
9741 op1->type->refCount++;
9742 }
9743 return 1;
9744 }
9745
9746 static unsigned int UIntAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9747 {
9748 unsigned int value2 = op2->__anon1.ui;
9749
9750 exp->type = 2;
9751 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui && value2));
9752 if(!exp->expType)
9753 {
9754 exp->expType = op1->type;
9755 if(op1->type)
9756 op1->type->refCount++;
9757 }
9758 return 1;
9759 }
9760
9761 static unsigned int Int64And(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9762 {
9763 long long value2 = op2->__anon1.i64;
9764
9765 exp->type = 2;
9766 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 && value2));
9767 if(!exp->expType)
9768 {
9769 exp->expType = op1->type;
9770 if(op1->type)
9771 op1->type->refCount++;
9772 }
9773 return 1;
9774 }
9775
9776 static unsigned int UInt64And(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9777 {
9778 uint64 value2 = op2->__anon1.ui64;
9779
9780 exp->type = 2;
9781 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 && value2));
9782 if(!exp->expType)
9783 {
9784 exp->expType = op1->type;
9785 if(op1->type)
9786 op1->type->refCount++;
9787 }
9788 return 1;
9789 }
9790
9791 static unsigned int ShortAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9792 {
9793 short value2 = op2->__anon1.s;
9794
9795 exp->type = 2;
9796 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s && value2));
9797 if(!exp->expType)
9798 {
9799 exp->expType = op1->type;
9800 if(op1->type)
9801 op1->type->refCount++;
9802 }
9803 return 1;
9804 }
9805
9806 static unsigned int UShortAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9807 {
9808 unsigned short value2 = op2->__anon1.us;
9809
9810 exp->type = 2;
9811 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us && value2));
9812 if(!exp->expType)
9813 {
9814 exp->expType = op1->type;
9815 if(op1->type)
9816 op1->type->refCount++;
9817 }
9818 return 1;
9819 }
9820
9821 static unsigned int CharAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9822 {
9823 char value2 = op2->__anon1.c;
9824
9825 exp->type = 2;
9826 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c && value2));
9827 if(!exp->expType)
9828 {
9829 exp->expType = op1->type;
9830 if(op1->type)
9831 op1->type->refCount++;
9832 }
9833 return 1;
9834 }
9835
9836 static unsigned int UCharAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9837 {
9838 unsigned char value2 = op2->__anon1.uc;
9839
9840 exp->type = 2;
9841 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc && value2));
9842 if(!exp->expType)
9843 {
9844 exp->expType = op1->type;
9845 if(op1->type)
9846 op1->type->refCount++;
9847 }
9848 return 1;
9849 }
9850
9851 static unsigned int FloatAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9852 {
9853 float value2 = op2->__anon1.f;
9854
9855 exp->type = 2;
9856 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f && value2));
9857 if(!exp->expType)
9858 {
9859 exp->expType = op1->type;
9860 if(op1->type)
9861 op1->type->refCount++;
9862 }
9863 return 1;
9864 }
9865
9866 static unsigned int DoubleAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9867 {
9868 double value2 = op2->__anon1.d;
9869
9870 exp->type = 2;
9871 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d && value2));
9872 if(!exp->expType)
9873 {
9874 exp->expType = op1->type;
9875 if(op1->type)
9876 op1->type->refCount++;
9877 }
9878 return 1;
9879 }
9880
9881 static unsigned int IntOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9882 {
9883 int value2 = op2->__anon1.i;
9884
9885 exp->type = 2;
9886 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i || value2));
9887 if(!exp->expType)
9888 {
9889 exp->expType = op1->type;
9890 if(op1->type)
9891 op1->type->refCount++;
9892 }
9893 return 1;
9894 }
9895
9896 static unsigned int UIntOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9897 {
9898 unsigned int value2 = op2->__anon1.ui;
9899
9900 exp->type = 2;
9901 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui || value2));
9902 if(!exp->expType)
9903 {
9904 exp->expType = op1->type;
9905 if(op1->type)
9906 op1->type->refCount++;
9907 }
9908 return 1;
9909 }
9910
9911 static unsigned int Int64Or(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9912 {
9913 long long value2 = op2->__anon1.i64;
9914
9915 exp->type = 2;
9916 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 || value2));
9917 if(!exp->expType)
9918 {
9919 exp->expType = op1->type;
9920 if(op1->type)
9921 op1->type->refCount++;
9922 }
9923 return 1;
9924 }
9925
9926 static unsigned int UInt64Or(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9927 {
9928 uint64 value2 = op2->__anon1.ui64;
9929
9930 exp->type = 2;
9931 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 || value2));
9932 if(!exp->expType)
9933 {
9934 exp->expType = op1->type;
9935 if(op1->type)
9936 op1->type->refCount++;
9937 }
9938 return 1;
9939 }
9940
9941 static unsigned int ShortOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9942 {
9943 short value2 = op2->__anon1.s;
9944
9945 exp->type = 2;
9946 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s || value2));
9947 if(!exp->expType)
9948 {
9949 exp->expType = op1->type;
9950 if(op1->type)
9951 op1->type->refCount++;
9952 }
9953 return 1;
9954 }
9955
9956 static unsigned int UShortOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9957 {
9958 unsigned short value2 = op2->__anon1.us;
9959
9960 exp->type = 2;
9961 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us || value2));
9962 if(!exp->expType)
9963 {
9964 exp->expType = op1->type;
9965 if(op1->type)
9966 op1->type->refCount++;
9967 }
9968 return 1;
9969 }
9970
9971 static unsigned int CharOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9972 {
9973 char value2 = op2->__anon1.c;
9974
9975 exp->type = 2;
9976 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c || value2));
9977 if(!exp->expType)
9978 {
9979 exp->expType = op1->type;
9980 if(op1->type)
9981 op1->type->refCount++;
9982 }
9983 return 1;
9984 }
9985
9986 static unsigned int UCharOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
9987 {
9988 unsigned char value2 = op2->__anon1.uc;
9989
9990 exp->type = 2;
9991 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc || value2));
9992 if(!exp->expType)
9993 {
9994 exp->expType = op1->type;
9995 if(op1->type)
9996 op1->type->refCount++;
9997 }
9998 return 1;
9999 }
10000
10001 static unsigned int FloatOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10002 {
10003 float value2 = op2->__anon1.f;
10004
10005 exp->type = 2;
10006 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f || value2));
10007 if(!exp->expType)
10008 {
10009 exp->expType = op1->type;
10010 if(op1->type)
10011 op1->type->refCount++;
10012 }
10013 return 1;
10014 }
10015
10016 static unsigned int DoubleOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10017 {
10018 double value2 = op2->__anon1.d;
10019
10020 exp->type = 2;
10021 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d || value2));
10022 if(!exp->expType)
10023 {
10024 exp->expType = op1->type;
10025 if(op1->type)
10026 op1->type->refCount++;
10027 }
10028 return 1;
10029 }
10030
10031 static unsigned int IntGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10032 {
10033 int value2 = op2->__anon1.i;
10034
10035 exp->type = 2;
10036 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i > value2));
10037 if(!exp->expType)
10038 {
10039 exp->expType = op1->type;
10040 if(op1->type)
10041 op1->type->refCount++;
10042 }
10043 return 1;
10044 }
10045
10046 static unsigned int UIntGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10047 {
10048 unsigned int value2 = op2->__anon1.ui;
10049
10050 exp->type = 2;
10051 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui > value2));
10052 if(!exp->expType)
10053 {
10054 exp->expType = op1->type;
10055 if(op1->type)
10056 op1->type->refCount++;
10057 }
10058 return 1;
10059 }
10060
10061 static unsigned int Int64Grt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10062 {
10063 long long value2 = op2->__anon1.i64;
10064
10065 exp->type = 2;
10066 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 > value2));
10067 if(!exp->expType)
10068 {
10069 exp->expType = op1->type;
10070 if(op1->type)
10071 op1->type->refCount++;
10072 }
10073 return 1;
10074 }
10075
10076 static unsigned int UInt64Grt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10077 {
10078 uint64 value2 = op2->__anon1.ui64;
10079
10080 exp->type = 2;
10081 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 > value2));
10082 if(!exp->expType)
10083 {
10084 exp->expType = op1->type;
10085 if(op1->type)
10086 op1->type->refCount++;
10087 }
10088 return 1;
10089 }
10090
10091 static unsigned int ShortGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10092 {
10093 short value2 = op2->__anon1.s;
10094
10095 exp->type = 2;
10096 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s > value2));
10097 if(!exp->expType)
10098 {
10099 exp->expType = op1->type;
10100 if(op1->type)
10101 op1->type->refCount++;
10102 }
10103 return 1;
10104 }
10105
10106 static unsigned int UShortGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10107 {
10108 unsigned short value2 = op2->__anon1.us;
10109
10110 exp->type = 2;
10111 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us > value2));
10112 if(!exp->expType)
10113 {
10114 exp->expType = op1->type;
10115 if(op1->type)
10116 op1->type->refCount++;
10117 }
10118 return 1;
10119 }
10120
10121 static unsigned int CharGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10122 {
10123 char value2 = op2->__anon1.c;
10124
10125 exp->type = 2;
10126 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c > value2));
10127 if(!exp->expType)
10128 {
10129 exp->expType = op1->type;
10130 if(op1->type)
10131 op1->type->refCount++;
10132 }
10133 return 1;
10134 }
10135
10136 static unsigned int UCharGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10137 {
10138 unsigned char value2 = op2->__anon1.uc;
10139
10140 exp->type = 2;
10141 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc > value2));
10142 if(!exp->expType)
10143 {
10144 exp->expType = op1->type;
10145 if(op1->type)
10146 op1->type->refCount++;
10147 }
10148 return 1;
10149 }
10150
10151 static unsigned int FloatGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10152 {
10153 float value2 = op2->__anon1.f;
10154
10155 exp->type = 2;
10156 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f > value2));
10157 if(!exp->expType)
10158 {
10159 exp->expType = op1->type;
10160 if(op1->type)
10161 op1->type->refCount++;
10162 }
10163 return 1;
10164 }
10165
10166 static unsigned int DoubleGrt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10167 {
10168 double value2 = op2->__anon1.d;
10169
10170 exp->type = 2;
10171 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d > value2));
10172 if(!exp->expType)
10173 {
10174 exp->expType = op1->type;
10175 if(op1->type)
10176 op1->type->refCount++;
10177 }
10178 return 1;
10179 }
10180
10181 static unsigned int IntSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10182 {
10183 int value2 = op2->__anon1.i;
10184
10185 exp->type = 2;
10186 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i < value2));
10187 if(!exp->expType)
10188 {
10189 exp->expType = op1->type;
10190 if(op1->type)
10191 op1->type->refCount++;
10192 }
10193 return 1;
10194 }
10195
10196 static unsigned int UIntSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10197 {
10198 unsigned int value2 = op2->__anon1.ui;
10199
10200 exp->type = 2;
10201 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui < value2));
10202 if(!exp->expType)
10203 {
10204 exp->expType = op1->type;
10205 if(op1->type)
10206 op1->type->refCount++;
10207 }
10208 return 1;
10209 }
10210
10211 static unsigned int Int64Sma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10212 {
10213 long long value2 = op2->__anon1.i64;
10214
10215 exp->type = 2;
10216 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 < value2));
10217 if(!exp->expType)
10218 {
10219 exp->expType = op1->type;
10220 if(op1->type)
10221 op1->type->refCount++;
10222 }
10223 return 1;
10224 }
10225
10226 static unsigned int UInt64Sma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10227 {
10228 uint64 value2 = op2->__anon1.ui64;
10229
10230 exp->type = 2;
10231 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 < value2));
10232 if(!exp->expType)
10233 {
10234 exp->expType = op1->type;
10235 if(op1->type)
10236 op1->type->refCount++;
10237 }
10238 return 1;
10239 }
10240
10241 static unsigned int ShortSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10242 {
10243 short value2 = op2->__anon1.s;
10244
10245 exp->type = 2;
10246 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s < value2));
10247 if(!exp->expType)
10248 {
10249 exp->expType = op1->type;
10250 if(op1->type)
10251 op1->type->refCount++;
10252 }
10253 return 1;
10254 }
10255
10256 static unsigned int UShortSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10257 {
10258 unsigned short value2 = op2->__anon1.us;
10259
10260 exp->type = 2;
10261 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us < value2));
10262 if(!exp->expType)
10263 {
10264 exp->expType = op1->type;
10265 if(op1->type)
10266 op1->type->refCount++;
10267 }
10268 return 1;
10269 }
10270
10271 static unsigned int CharSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10272 {
10273 char value2 = op2->__anon1.c;
10274
10275 exp->type = 2;
10276 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c < value2));
10277 if(!exp->expType)
10278 {
10279 exp->expType = op1->type;
10280 if(op1->type)
10281 op1->type->refCount++;
10282 }
10283 return 1;
10284 }
10285
10286 static unsigned int UCharSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10287 {
10288 unsigned char value2 = op2->__anon1.uc;
10289
10290 exp->type = 2;
10291 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc < value2));
10292 if(!exp->expType)
10293 {
10294 exp->expType = op1->type;
10295 if(op1->type)
10296 op1->type->refCount++;
10297 }
10298 return 1;
10299 }
10300
10301 static unsigned int FloatSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10302 {
10303 float value2 = op2->__anon1.f;
10304
10305 exp->type = 2;
10306 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f < value2));
10307 if(!exp->expType)
10308 {
10309 exp->expType = op1->type;
10310 if(op1->type)
10311 op1->type->refCount++;
10312 }
10313 return 1;
10314 }
10315
10316 static unsigned int DoubleSma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10317 {
10318 double value2 = op2->__anon1.d;
10319
10320 exp->type = 2;
10321 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d < value2));
10322 if(!exp->expType)
10323 {
10324 exp->expType = op1->type;
10325 if(op1->type)
10326 op1->type->refCount++;
10327 }
10328 return 1;
10329 }
10330
10331 static unsigned int IntGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10332 {
10333 int value2 = op2->__anon1.i;
10334
10335 exp->type = 2;
10336 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i >= value2));
10337 if(!exp->expType)
10338 {
10339 exp->expType = op1->type;
10340 if(op1->type)
10341 op1->type->refCount++;
10342 }
10343 return 1;
10344 }
10345
10346 static unsigned int UIntGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10347 {
10348 unsigned int value2 = op2->__anon1.ui;
10349
10350 exp->type = 2;
10351 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui >= value2));
10352 if(!exp->expType)
10353 {
10354 exp->expType = op1->type;
10355 if(op1->type)
10356 op1->type->refCount++;
10357 }
10358 return 1;
10359 }
10360
10361 static unsigned int Int64GrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10362 {
10363 long long value2 = op2->__anon1.i64;
10364
10365 exp->type = 2;
10366 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 >= value2));
10367 if(!exp->expType)
10368 {
10369 exp->expType = op1->type;
10370 if(op1->type)
10371 op1->type->refCount++;
10372 }
10373 return 1;
10374 }
10375
10376 static unsigned int UInt64GrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10377 {
10378 uint64 value2 = op2->__anon1.ui64;
10379
10380 exp->type = 2;
10381 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 >= value2));
10382 if(!exp->expType)
10383 {
10384 exp->expType = op1->type;
10385 if(op1->type)
10386 op1->type->refCount++;
10387 }
10388 return 1;
10389 }
10390
10391 static unsigned int ShortGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10392 {
10393 short value2 = op2->__anon1.s;
10394
10395 exp->type = 2;
10396 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s >= value2));
10397 if(!exp->expType)
10398 {
10399 exp->expType = op1->type;
10400 if(op1->type)
10401 op1->type->refCount++;
10402 }
10403 return 1;
10404 }
10405
10406 static unsigned int UShortGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10407 {
10408 unsigned short value2 = op2->__anon1.us;
10409
10410 exp->type = 2;
10411 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us >= value2));
10412 if(!exp->expType)
10413 {
10414 exp->expType = op1->type;
10415 if(op1->type)
10416 op1->type->refCount++;
10417 }
10418 return 1;
10419 }
10420
10421 static unsigned int CharGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10422 {
10423 char value2 = op2->__anon1.c;
10424
10425 exp->type = 2;
10426 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c >= value2));
10427 if(!exp->expType)
10428 {
10429 exp->expType = op1->type;
10430 if(op1->type)
10431 op1->type->refCount++;
10432 }
10433 return 1;
10434 }
10435
10436 static unsigned int UCharGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10437 {
10438 unsigned char value2 = op2->__anon1.uc;
10439
10440 exp->type = 2;
10441 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc >= value2));
10442 if(!exp->expType)
10443 {
10444 exp->expType = op1->type;
10445 if(op1->type)
10446 op1->type->refCount++;
10447 }
10448 return 1;
10449 }
10450
10451 static unsigned int FloatGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10452 {
10453 float value2 = op2->__anon1.f;
10454
10455 exp->type = 2;
10456 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f >= value2));
10457 if(!exp->expType)
10458 {
10459 exp->expType = op1->type;
10460 if(op1->type)
10461 op1->type->refCount++;
10462 }
10463 return 1;
10464 }
10465
10466 static unsigned int DoubleGrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10467 {
10468 double value2 = op2->__anon1.d;
10469
10470 exp->type = 2;
10471 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d >= value2));
10472 if(!exp->expType)
10473 {
10474 exp->expType = op1->type;
10475 if(op1->type)
10476 op1->type->refCount++;
10477 }
10478 return 1;
10479 }
10480
10481 static unsigned int IntSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10482 {
10483 int value2 = op2->__anon1.i;
10484
10485 exp->type = 2;
10486 exp->__anon1.__anon2.string = PrintInt((int)(op1->__anon1.i <= value2));
10487 if(!exp->expType)
10488 {
10489 exp->expType = op1->type;
10490 if(op1->type)
10491 op1->type->refCount++;
10492 }
10493 return 1;
10494 }
10495
10496 static unsigned int UIntSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10497 {
10498 unsigned int value2 = op2->__anon1.ui;
10499
10500 exp->type = 2;
10501 exp->__anon1.__anon2.string = PrintUInt((unsigned int)(op1->__anon1.ui <= value2));
10502 if(!exp->expType)
10503 {
10504 exp->expType = op1->type;
10505 if(op1->type)
10506 op1->type->refCount++;
10507 }
10508 return 1;
10509 }
10510
10511 static unsigned int Int64SmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10512 {
10513 long long value2 = op2->__anon1.i64;
10514
10515 exp->type = 2;
10516 exp->__anon1.__anon2.string = PrintInt64((long long)(op1->__anon1.i64 <= value2));
10517 if(!exp->expType)
10518 {
10519 exp->expType = op1->type;
10520 if(op1->type)
10521 op1->type->refCount++;
10522 }
10523 return 1;
10524 }
10525
10526 static unsigned int UInt64SmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10527 {
10528 uint64 value2 = op2->__anon1.ui64;
10529
10530 exp->type = 2;
10531 exp->__anon1.__anon2.string = PrintUInt64((uint64)(op1->__anon1.ui64 <= value2));
10532 if(!exp->expType)
10533 {
10534 exp->expType = op1->type;
10535 if(op1->type)
10536 op1->type->refCount++;
10537 }
10538 return 1;
10539 }
10540
10541 static unsigned int ShortSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10542 {
10543 short value2 = op2->__anon1.s;
10544
10545 exp->type = 2;
10546 exp->__anon1.__anon2.string = PrintShort((short)(op1->__anon1.s <= value2));
10547 if(!exp->expType)
10548 {
10549 exp->expType = op1->type;
10550 if(op1->type)
10551 op1->type->refCount++;
10552 }
10553 return 1;
10554 }
10555
10556 static unsigned int UShortSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10557 {
10558 unsigned short value2 = op2->__anon1.us;
10559
10560 exp->type = 2;
10561 exp->__anon1.__anon2.string = PrintUShort((unsigned short)(op1->__anon1.us <= value2));
10562 if(!exp->expType)
10563 {
10564 exp->expType = op1->type;
10565 if(op1->type)
10566 op1->type->refCount++;
10567 }
10568 return 1;
10569 }
10570
10571 static unsigned int CharSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10572 {
10573 char value2 = op2->__anon1.c;
10574
10575 exp->type = 2;
10576 exp->__anon1.__anon2.string = PrintChar((char)(op1->__anon1.c <= value2));
10577 if(!exp->expType)
10578 {
10579 exp->expType = op1->type;
10580 if(op1->type)
10581 op1->type->refCount++;
10582 }
10583 return 1;
10584 }
10585
10586 static unsigned int UCharSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10587 {
10588 unsigned char value2 = op2->__anon1.uc;
10589
10590 exp->type = 2;
10591 exp->__anon1.__anon2.string = PrintUChar((unsigned char)(op1->__anon1.uc <= value2));
10592 if(!exp->expType)
10593 {
10594 exp->expType = op1->type;
10595 if(op1->type)
10596 op1->type->refCount++;
10597 }
10598 return 1;
10599 }
10600
10601 static unsigned int FloatSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10602 {
10603 float value2 = op2->__anon1.f;
10604
10605 exp->type = 2;
10606 exp->__anon1.__anon2.string = PrintFloat((float)(op1->__anon1.f <= value2));
10607 if(!exp->expType)
10608 {
10609 exp->expType = op1->type;
10610 if(op1->type)
10611 op1->type->refCount++;
10612 }
10613 return 1;
10614 }
10615
10616 static unsigned int DoubleSmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
10617 {
10618 double value2 = op2->__anon1.d;
10619
10620 exp->type = 2;
10621 exp->__anon1.__anon2.string = PrintDouble((double)(op1->__anon1.d <= value2));
10622 if(!exp->expType)
10623 {
10624 exp->expType = op1->type;
10625 if(op1->type)
10626 op1->type->refCount++;
10627 }
10628 return 1;
10629 }
10630
10631 static unsigned int IntCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10632 {
10633 exp->type = 2;
10634 exp->__anon1.__anon2.string = PrintInt(op1->__anon1.i ? op2->__anon1.i : op3->__anon1.i);
10635 if(!exp->expType)
10636 {
10637 exp->expType = op1->type;
10638 if(op1->type)
10639 op1->type->refCount++;
10640 }
10641 return 1;
10642 }
10643
10644 static unsigned int UIntCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10645 {
10646 exp->type = 2;
10647 exp->__anon1.__anon2.string = PrintUInt(op1->__anon1.ui ? op2->__anon1.ui : op3->__anon1.ui);
10648 if(!exp->expType)
10649 {
10650 exp->expType = op1->type;
10651 if(op1->type)
10652 op1->type->refCount++;
10653 }
10654 return 1;
10655 }
10656
10657 static unsigned int Int64Cond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10658 {
10659 exp->type = 2;
10660 exp->__anon1.__anon2.string = PrintInt64(op1->__anon1.i64 ? op2->__anon1.i64 : op3->__anon1.i64);
10661 if(!exp->expType)
10662 {
10663 exp->expType = op1->type;
10664 if(op1->type)
10665 op1->type->refCount++;
10666 }
10667 return 1;
10668 }
10669
10670 static unsigned int UInt64Cond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10671 {
10672 exp->type = 2;
10673 exp->__anon1.__anon2.string = PrintUInt64(op1->__anon1.ui64 ? op2->__anon1.ui64 : op3->__anon1.ui64);
10674 if(!exp->expType)
10675 {
10676 exp->expType = op1->type;
10677 if(op1->type)
10678 op1->type->refCount++;
10679 }
10680 return 1;
10681 }
10682
10683 static unsigned int ShortCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10684 {
10685 exp->type = 2;
10686 exp->__anon1.__anon2.string = PrintShort(op1->__anon1.s ? op2->__anon1.s : op3->__anon1.s);
10687 if(!exp->expType)
10688 {
10689 exp->expType = op1->type;
10690 if(op1->type)
10691 op1->type->refCount++;
10692 }
10693 return 1;
10694 }
10695
10696 static unsigned int UShortCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10697 {
10698 exp->type = 2;
10699 exp->__anon1.__anon2.string = PrintUShort(op1->__anon1.us ? op2->__anon1.us : op3->__anon1.us);
10700 if(!exp->expType)
10701 {
10702 exp->expType = op1->type;
10703 if(op1->type)
10704 op1->type->refCount++;
10705 }
10706 return 1;
10707 }
10708
10709 static unsigned int CharCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10710 {
10711 exp->type = 2;
10712 exp->__anon1.__anon2.string = PrintChar(op1->__anon1.c ? op2->__anon1.c : op3->__anon1.c);
10713 if(!exp->expType)
10714 {
10715 exp->expType = op1->type;
10716 if(op1->type)
10717 op1->type->refCount++;
10718 }
10719 return 1;
10720 }
10721
10722 static unsigned int UCharCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
10723 {
10724 exp->type = 2;
10725 exp->__anon1.__anon2.string = PrintUChar(op1->__anon1.uc ? op2->__anon1.uc : op3->__anon1.uc);
10726 if(!exp->expType)
10727 {
10728 exp->expType = op1->type;
10729 if(op1->type)
10730 op1->type->refCount++;
10731 }
10732 return 1;
10733 }
10734
10735 struct OpTable intOps =
10736 {
10737 (void *)(IntAdd), (void *)(IntSub), (void *)(IntMul), (void *)(IntDiv), (void *)(IntMod), (void *)(IntNeg), (void *)(IntInc), (void *)(IntDec), (void *)(IntAsign), (void *)(IntAddAsign), (void *)(IntSubAsign), (void *)(IntMulAsign), (void *)(IntDivAsign), (void *)(IntModAsign), (void *)(IntBitAnd), (void *)(IntBitOr), (void *)(IntBitXor), (void *)(IntLShift), (void *)(IntRShift), (void *)(IntBitNot), (void *)(IntAndAsign), (void *)(IntOrAsign), (void *)(IntXorAsign), (void *)(IntLShiftAsign), (void *)(IntRShiftAsign), (void *)(IntNot), (void *)(IntEqu), (void *)(IntNqu), (void *)(IntAnd), (void *)(IntOr), (void *)(IntGrt), (void *)(IntSma), (void *)(IntGrtEqu), (void *)(IntSmaEqu), (void *)(IntCond)
10738 };
10739
10740 struct OpTable uintOps =
10741 {
10742 (void *)(UIntAdd), (void *)(UIntSub), (void *)(UIntMul), (void *)(UIntDiv), (void *)(UIntMod), (void *)(UIntNeg), (void *)(UIntInc), (void *)(UIntDec), (void *)(UIntAsign), (void *)(UIntAddAsign), (void *)(UIntSubAsign), (void *)(UIntMulAsign), (void *)(UIntDivAsign), (void *)(UIntModAsign), (void *)(UIntBitAnd), (void *)(UIntBitOr), (void *)(UIntBitXor), (void *)(UIntLShift), (void *)(UIntRShift), (void *)(UIntBitNot), (void *)(UIntAndAsign), (void *)(UIntOrAsign), (void *)(UIntXorAsign), (void *)(UIntLShiftAsign), (void *)(UIntRShiftAsign), (void *)(UIntNot), (void *)(UIntEqu), (void *)(UIntNqu), (void *)(UIntAnd), (void *)(UIntOr), (void *)(UIntGrt), (void *)(UIntSma), (void *)(UIntGrtEqu), (void *)(UIntSmaEqu), (void *)(UIntCond)
10743 };
10744
10745 struct OpTable int64Ops =
10746 {
10747 (void *)(Int64Add), (void *)(Int64Sub), (void *)(Int64Mul), (void *)(Int64Div), (void *)(Int64Mod), (void *)(Int64Neg), (void *)(Int64Inc), (void *)(Int64Dec), (void *)(Int64Asign), (void *)(Int64AddAsign), (void *)(Int64SubAsign), (void *)(Int64MulAsign), (void *)(Int64DivAsign), (void *)(Int64ModAsign), (void *)(Int64BitAnd), (void *)(Int64BitOr), (void *)(Int64BitXor), (void *)(Int64LShift), (void *)(Int64RShift), (void *)(Int64BitNot), (void *)(Int64AndAsign), (void *)(Int64OrAsign), (void *)(Int64XorAsign), (void *)(Int64LShiftAsign), (void *)(Int64RShiftAsign), (void *)(Int64Not), (void *)(Int64Equ), (void *)(Int64Nqu), (void *)(Int64And), (void *)(Int64Or), (void *)(Int64Grt), (void *)(Int64Sma), (void *)(Int64GrtEqu), (void *)(Int64SmaEqu), (void *)(Int64Cond)
10748 };
10749
10750 struct OpTable uint64Ops =
10751 {
10752 (void *)(UInt64Add), (void *)(UInt64Sub), (void *)(UInt64Mul), (void *)(UInt64Div), (void *)(UInt64Mod), (void *)(UInt64Neg), (void *)(UInt64Inc), (void *)(UInt64Dec), (void *)(UInt64Asign), (void *)(UInt64AddAsign), (void *)(UInt64SubAsign), (void *)(UInt64MulAsign), (void *)(UInt64DivAsign), (void *)(UInt64ModAsign), (void *)(UInt64BitAnd), (void *)(UInt64BitOr), (void *)(UInt64BitXor), (void *)(UInt64LShift), (void *)(UInt64RShift), (void *)(UInt64BitNot), (void *)(UInt64AndAsign), (void *)(UInt64OrAsign), (void *)(UInt64XorAsign), (void *)(UInt64LShiftAsign), (void *)(UInt64RShiftAsign), (void *)(UInt64Not), (void *)(UInt64Equ), (void *)(UInt64Nqu), (void *)(UInt64And), (void *)(UInt64Or), (void *)(UInt64Grt), (void *)(UInt64Sma), (void *)(UInt64GrtEqu), (void *)(UInt64SmaEqu), (void *)(UInt64Cond)
10753 };
10754
10755 struct OpTable shortOps =
10756 {
10757 (void *)(ShortAdd), (void *)(ShortSub), (void *)(ShortMul), (void *)(ShortDiv), (void *)(ShortMod), (void *)(ShortNeg), (void *)(ShortInc), (void *)(ShortDec), (void *)(ShortAsign), (void *)(ShortAddAsign), (void *)(ShortSubAsign), (void *)(ShortMulAsign), (void *)(ShortDivAsign), (void *)(ShortModAsign), (void *)(ShortBitAnd), (void *)(ShortBitOr), (void *)(ShortBitXor), (void *)(ShortLShift), (void *)(ShortRShift), (void *)(ShortBitNot), (void *)(ShortAndAsign), (void *)(ShortOrAsign), (void *)(ShortXorAsign), (void *)(ShortLShiftAsign), (void *)(ShortRShiftAsign), (void *)(ShortNot), (void *)(ShortEqu), (void *)(ShortNqu), (void *)(ShortAnd), (void *)(ShortOr), (void *)(ShortGrt), (void *)(ShortSma), (void *)(ShortGrtEqu), (void *)(ShortSmaEqu), (void *)(ShortCond)
10758 };
10759
10760 struct OpTable ushortOps =
10761 {
10762 (void *)(UShortAdd), (void *)(UShortSub), (void *)(UShortMul), (void *)(UShortDiv), (void *)(UShortMod), (void *)(UShortNeg), (void *)(UShortInc), (void *)(UShortDec), (void *)(UShortAsign), (void *)(UShortAddAsign), (void *)(UShortSubAsign), (void *)(UShortMulAsign), (void *)(UShortDivAsign), (void *)(UShortModAsign), (void *)(UShortBitAnd), (void *)(UShortBitOr), (void *)(UShortBitXor), (void *)(UShortLShift), (void *)(UShortRShift), (void *)(UShortBitNot), (void *)(UShortAndAsign), (void *)(UShortOrAsign), (void *)(UShortXorAsign), (void *)(UShortLShiftAsign), (void *)(UShortRShiftAsign), (void *)(UShortNot), (void *)(UShortEqu), (void *)(UShortNqu), (void *)(UShortAnd), (void *)(UShortOr), (void *)(UShortGrt), (void *)(UShortSma), (void *)(UShortGrtEqu), (void *)(UShortSmaEqu), (void *)(UShortCond)
10763 };
10764
10765 struct OpTable floatOps =
10766 {
10767 (void *)(FloatAdd), (void *)(FloatSub), (void *)(FloatMul), (void *)(FloatDiv), (((void *)0)), (void *)(FloatNeg), (void *)(FloatInc), (void *)(FloatDec), (void *)(FloatAsign), (void *)(FloatAddAsign), (void *)(FloatSubAsign), (void *)(FloatMulAsign), (void *)(FloatDivAsign), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (void *)(FloatEqu), (void *)(FloatNqu), (void *)(FloatAnd), (void *)(FloatOr), (void *)(FloatGrt), (void *)(FloatSma), (void *)(FloatGrtEqu), (void *)(FloatSmaEqu)
10768 };
10769
10770 struct OpTable doubleOps =
10771 {
10772 (void *)(DoubleAdd), (void *)(DoubleSub), (void *)(DoubleMul), (void *)(DoubleDiv), (((void *)0)), (void *)(DoubleNeg), (void *)(DoubleInc), (void *)(DoubleDec), (void *)(DoubleAsign), (void *)(DoubleAddAsign), (void *)(DoubleSubAsign), (void *)(DoubleMulAsign), (void *)(DoubleDivAsign), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)), (void *)(DoubleEqu), (void *)(DoubleNqu), (void *)(DoubleAnd), (void *)(DoubleOr), (void *)(DoubleGrt), (void *)(DoubleSma), (void *)(DoubleGrtEqu), (void *)(DoubleSmaEqu)
10773 };
10774
10775 struct OpTable charOps =
10776 {
10777 (void *)(CharAdd), (void *)(CharSub), (void *)(CharMul), (void *)(CharDiv), (void *)(CharMod), (void *)(CharNeg), (void *)(CharInc), (void *)(CharDec), (void *)(CharAsign), (void *)(CharAddAsign), (void *)(CharSubAsign), (void *)(CharMulAsign), (void *)(CharDivAsign), (void *)(CharModAsign), (void *)(CharBitAnd), (void *)(CharBitOr), (void *)(CharBitXor), (void *)(CharLShift), (void *)(CharRShift), (void *)(CharBitNot), (void *)(CharAndAsign), (void *)(CharOrAsign), (void *)(CharXorAsign), (void *)(CharLShiftAsign), (void *)(CharRShiftAsign), (void *)(CharNot), (void *)(CharEqu), (void *)(CharNqu), (void *)(CharAnd), (void *)(CharOr), (void *)(CharGrt), (void *)(CharSma), (void *)(CharGrtEqu), (void *)(CharSmaEqu), (void *)(CharCond)
10778 };
10779
10780 struct OpTable ucharOps =
10781 {
10782 (void *)(UCharAdd), (void *)(UCharSub), (void *)(UCharMul), (void *)(UCharDiv), (void *)(UCharMod), (void *)(UCharNeg), (void *)(UCharInc), (void *)(UCharDec), (void *)(UCharAsign), (void *)(UCharAddAsign), (void *)(UCharSubAsign), (void *)(UCharMulAsign), (void *)(UCharDivAsign), (void *)(UCharModAsign), (void *)(UCharBitAnd), (void *)(UCharBitOr), (void *)(UCharBitXor), (void *)(UCharLShift), (void *)(UCharRShift), (void *)(UCharBitNot), (void *)(UCharAndAsign), (void *)(UCharOrAsign), (void *)(UCharXorAsign), (void *)(UCharLShiftAsign), (void *)(UCharRShiftAsign), (void *)(UCharNot), (void *)(UCharEqu), (void *)(UCharNqu), (void *)(UCharAnd), (void *)(UCharOr), (void *)(UCharGrt), (void *)(UCharSma), (void *)(UCharGrtEqu), (void *)(UCharSmaEqu), (void *)(UCharCond)
10783 };
10784
10785 void ReadString(char * output, char * string)
10786 {
10787 int len = strlen(string);
10788 int c, d = 0;
10789 unsigned int quoted = 0, escaped = 0;
10790
10791 for(c = 0; c < len; c++)
10792 {
10793 char ch = string[c];
10794
10795 if(escaped)
10796 {
10797 switch(ch)
10798 {
10799 case 'n':
10800 output[d] = '\n';
10801 break;
10802 case 't':
10803 output[d] = '\t';
10804 break;
10805 case 'a':
10806 output[d] = '\a';
10807 break;
10808 case 'b':
10809 output[d] = '\b';
10810 break;
10811 case 'f':
10812 output[d] = '\f';
10813 break;
10814 case 'r':
10815 output[d] = '\r';
10816 break;
10817 case 'v':
10818 output[d] = '\v';
10819 break;
10820 case '\\':
10821 output[d] = '\\';
10822 break;
10823 case '\"':
10824 output[d] = '\"';
10825 break;
10826 case '\'':
10827 output[d] = '\'';
10828 break;
10829 default:
10830 output[d] = ch;
10831 }
10832 d++;
10833 escaped = 0;
10834 }
10835 else
10836 {
10837 if(ch == '\"')
10838 quoted ^= 1;
10839 else if(quoted)
10840 {
10841 if(ch == '\\')
10842 escaped = 1;
10843 else
10844 output[d++] = ch;
10845 }
10846 }
10847 }
10848 output[d] = '\0';
10849 }
10850
10851 int UnescapeString(char * d, char * s, int len)
10852 {
10853 int j = 0, k = 0;
10854 char ch;
10855
10856 while(j < len && (ch = s[j]))
10857 {
10858 switch(ch)
10859 {
10860 case '\\':
10861 switch((ch = s[++j]))
10862 {
10863 case 'n':
10864 d[k] = '\n';
10865 break;
10866 case 't':
10867 d[k] = '\t';
10868 break;
10869 case 'a':
10870 d[k] = '\a';
10871 break;
10872 case 'b':
10873 d[k] = '\b';
10874 break;
10875 case 'f':
10876 d[k] = '\f';
10877 break;
10878 case 'r':
10879 d[k] = '\r';
10880 break;
10881 case 'v':
10882 d[k] = '\v';
10883 break;
10884 case '\\':
10885 d[k] = '\\';
10886 break;
10887 case '\"':
10888 d[k] = '\"';
10889 break;
10890 case '\'':
10891 d[k] = '\'';
10892 break;
10893 default:
10894 d[k] = '\\';
10895 d[k] = ch;
10896 }
10897 break;
10898 default:
10899 d[k] = ch;
10900 }
10901 j++, k++;
10902 }
10903 d[k] = '\0';
10904 return k;
10905 }
10906
10907 char * OffsetEscapedString(char * s, int len, int offset)
10908 {
10909 char ch;
10910 int j = 0, k = 0;
10911
10912 while(j < len && k < offset && (ch = s[j]))
10913 {
10914 if(ch == '\\')
10915 ++j;
10916 j++, k++;
10917 }
10918 return (k == offset) ? s + j : (((void *)0));
10919 }
10920
10921 extern long long __ecereNameSpace__ecere__com___strtoi64(const char *  string, const char * *  endString, int base);
10922
10923 extern uint64 __ecereNameSpace__ecere__com___strtoui64(const char *  string, const char * *  endString, int base);
10924
10925 extern double strtod(const char * , char * * );
10926
10927 extern float (* __ecereMethod_float_inf)(void);
10928
10929 extern float (* __ecereMethod_float_nan)(void);
10930
10931 extern double (* __ecereMethod_double_inf)(void);
10932
10933 extern double (* __ecereMethod_double_nan)(void);
10934
10935 struct Operand GetOperand(struct Expression * exp)
10936 {
10937 struct Operand op =
10938 {
10939 0, 0, 0,
10940 .__anon1 = {
10941 .c = 0
10942 },
10943 {
10944 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
10945 }
10946 };
10947 struct Type * type = exp->expType;
10948
10949 if(type)
10950 {
10951 while(type->kind == 8 && type->__anon1._class->__anon1.registered && (type->__anon1._class->__anon1.registered->type == 2 || type->__anon1._class->__anon1.registered->type == 3 || type->__anon1._class->__anon1.registered->type == 4))
10952 {
10953 if(!type->__anon1._class->__anon1.registered->dataType)
10954 type->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type->__anon1._class->__anon1.registered->dataTypeString, 0);
10955 type = type->__anon1._class->__anon1.registered->dataType;
10956 }
10957 if(exp->type == 3 && op.kind == 13)
10958 {
10959 op.__anon1.ui64 = (uint64)(uintptr_t)exp->__anon1.__anon2.string;
10960 op.kind = 13;
10961 op.ops = uint64Ops;
10962 }
10963 else if(exp->isConstant && exp->type == 2)
10964 {
10965 op.kind = type->kind;
10966 op.type = type;
10967 switch(op.kind)
10968 {
10969 case 24:
10970 case 1:
10971 {
10972 if(exp->__anon1.__anon1.constant[0] == '\'')
10973 {
10974 op.__anon1.c = exp->__anon1.__anon1.constant[1];
10975 op.ops = charOps;
10976 }
10977 else if(type->isSigned)
10978 {
10979 op.__anon1.c = (char)strtol(exp->__anon1.__anon1.constant, (((void *)0)), 0);
10980 op.ops = charOps;
10981 }
10982 else
10983 {
10984 op.__anon1.uc = (unsigned char)strtoul(exp->__anon1.__anon1.constant, (((void *)0)), 0);
10985 op.ops = ucharOps;
10986 }
10987 break;
10988 }
10989 case 2:
10990 if(type->isSigned)
10991 {
10992 op.__anon1.s = (short)strtol(exp->__anon1.__anon1.constant, (((void *)0)), 0);
10993 op.ops = shortOps;
10994 }
10995 else
10996 {
10997 op.__anon1.us = (unsigned short)strtoul(exp->__anon1.__anon1.constant, (((void *)0)), 0);
10998 op.ops = ushortOps;
10999 }
11000 break;
11001 case 3:
11002 case 5:
11003 if(type->isSigned)
11004 {
11005 op.__anon1.i = strtol(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11006 op.ops = intOps;
11007 }
11008 else
11009 {
11010 op.__anon1.ui = strtoul(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11011 op.ops = uintOps;
11012 }
11013 op.kind = 3;
11014 break;
11015 case 4:
11016 if(type->isSigned)
11017 {
11018 op.__anon1.i64 = __ecereNameSpace__ecere__com___strtoi64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11019 op.ops = int64Ops;
11020 }
11021 else
11022 {
11023 op.__anon1.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11024 op.ops = uint64Ops;
11025 }
11026 op.kind = 4;
11027 break;
11028 case 22:
11029 if(type->isSigned)
11030 {
11031 op.__anon1.i64 = __ecereNameSpace__ecere__com___strtoi64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11032 op.ops = int64Ops;
11033 }
11034 else
11035 {
11036 op.__anon1.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11037 op.ops = uint64Ops;
11038 }
11039 op.kind = 4;
11040 break;
11041 case 23:
11042 if(type->isSigned)
11043 {
11044 op.__anon1.i64 = __ecereNameSpace__ecere__com___strtoi64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11045 op.ops = int64Ops;
11046 }
11047 else
11048 {
11049 op.__anon1.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11050 op.ops = uint64Ops;
11051 }
11052 op.kind = 4;
11053 break;
11054 case 6:
11055 if(!strcmp(exp->__anon1.__anon1.constant, "inf"))
11056 op.__anon1.f = __ecereMethod_float_inf();
11057 else if(!strcmp(exp->__anon1.__anon1.constant, "-inf"))
11058 op.__anon1.f = -__ecereMethod_float_inf();
11059 else if(!strcmp(exp->__anon1.__anon1.constant, "nan"))
11060 op.__anon1.f = __ecereMethod_float_nan();
11061 else if(!strcmp(exp->__anon1.__anon1.constant, "-nan"))
11062 op.__anon1.f = -__ecereMethod_float_nan();
11063 else
11064 op.__anon1.f = (float)strtod(exp->__anon1.__anon1.constant, (((void *)0)));
11065 op.ops = floatOps;
11066 break;
11067 case 7:
11068 if(!strcmp(exp->__anon1.__anon1.constant, "inf"))
11069 op.__anon1.d = __ecereMethod_double_inf();
11070 else if(!strcmp(exp->__anon1.__anon1.constant, "-inf"))
11071 op.__anon1.d = -__ecereMethod_double_inf();
11072 else if(!strcmp(exp->__anon1.__anon1.constant, "nan"))
11073 op.__anon1.d = __ecereMethod_double_nan();
11074 else if(!strcmp(exp->__anon1.__anon1.constant, "-nan"))
11075 op.__anon1.d = -__ecereMethod_double_nan();
11076 else
11077 op.__anon1.d = (double)strtod(exp->__anon1.__anon1.constant, (((void *)0)));
11078 op.ops = doubleOps;
11079 break;
11080 case 12:
11081 case 13:
11082 case 8:
11083 op.__anon1.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->__anon1.__anon1.constant, (((void *)0)), 0);
11084 op.kind = 13;
11085 op.ops = uint64Ops;
11086 break;
11087 }
11088 }
11089 }
11090 return op;
11091 }
11092
11093 static long long GetEnumValue(struct __ecereNameSpace__ecere__com__Class * _class, void * ptr)
11094 {
11095 long long v = 0;
11096
11097 switch(_class->typeSize)
11098 {
11099 case 8:
11100 if(!strcmp(_class->dataTypeString, "uint64"))
11101 v = (long long)*(uint64 *)ptr;
11102 else
11103 v = *(long long *)ptr;
11104 break;
11105 case 4:
11106 if(!strcmp(_class->dataTypeString, "uint"))
11107 v = (long long)*(unsigned int *)ptr;
11108 else
11109 v = (long long)*(int *)ptr;
11110 break;
11111 case 2:
11112 if(!strcmp(_class->dataTypeString, "uint16"))
11113 v = (long long)*(unsigned short *)ptr;
11114 else
11115 v = (long long)*(short *)ptr;
11116 break;
11117 case 1:
11118 if(!strcmp(_class->dataTypeString, "byte"))
11119 v = (long long)*(unsigned char *)ptr;
11120 else
11121 v = (long long)*(char *)ptr;
11122 break;
11123 }
11124 return v;
11125 }
11126
11127 int __ecereVMethodID_class_OnGetString;
11128
11129 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_int;
11130
11131 static __attribute__((unused)) void UnusedFunction()
11132 {
11133 int a;
11134
11135 ((const char *  (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, char *  tempString, void *  fieldData, unsigned int *  needClass))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_int, (void *)&a, 0, 0, 0);
11136 }
11137
11138 extern int __ecereVMethodID_class_OnGetString;
11139
11140 static void PopulateInstanceProcessMember(struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * memberList, struct __ecereNameSpace__ecere__com__DataMember * parentDataMember, unsigned int offset)
11141 {
11142 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
11143
11144 for(dataMember = parentDataMember->members.first; dataMember; dataMember = dataMember->next)
11145 {
11146 if(!dataMember->name && (dataMember->type == 2 || dataMember->type == 1))
11147 PopulateInstanceProcessMember(inst, memberList, dataMember, offset + dataMember->offset);
11148 else
11149 {
11150 struct Expression * exp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
11151 struct MemberInit * member = MkMemberInit(MkListOne(MkIdentifier(dataMember->name)), MkInitializerAssignment(exp));
11152 struct Type * type;
11153 void * ptr = inst->data + dataMember->offset + offset;
11154 char * result = (((void *)0));
11155
11156 exp->loc = member->loc = inst->loc;
11157 ((struct Identifier *)(*member->identifiers).first)->loc = inst->loc;
11158 if(!dataMember->dataType)
11159 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
11160 type = dataMember->dataType;
11161 if(type->kind == 8)
11162 {
11163 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11164
11165 if(_class->type == 4)
11166 {
11167 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
11168
11169 if(enumClass)
11170 {
11171 struct __ecereNameSpace__ecere__com__EnumClassData * e = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
11172 struct __ecereNameSpace__ecere__sys__NamedLink64 * item;
11173
11174 for(item = e->values.first; item; item = item->next)
11175 {
11176 if(item->data == GetEnumValue(_class, ptr))
11177 {
11178 result = item->name;
11179 break;
11180 }
11181 }
11182 if(result)
11183 {
11184 exp->__anon1.__anon1.identifier = MkIdentifier(result);
11185 exp->type = 0;
11186 exp->destType = MkClassType(_class->fullName);
11187 ProcessExpressionType(exp);
11188 }
11189 }
11190 }
11191 if(_class->type == 4 || _class->type == 3 || _class->type == 2)
11192 {
11193 if(!_class->dataType)
11194 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
11195 type = _class->dataType;
11196 }
11197 }
11198 if(!result)
11199 {
11200 switch(type->kind)
11201 {
11202 case 6:
11203 {
11204 FreeExpContents(exp);
11205 exp->__anon1.__anon1.constant = PrintFloat(*(float *)ptr);
11206 exp->type = 2;
11207 break;
11208 }
11209 case 7:
11210 {
11211 FreeExpContents(exp);
11212 exp->__anon1.__anon1.constant = PrintDouble(*(double *)ptr);
11213 exp->type = 2;
11214 break;
11215 }
11216 case 3:
11217 {
11218 FreeExpContents(exp);
11219 exp->__anon1.__anon1.constant = PrintInt(*(int *)ptr);
11220 exp->type = 2;
11221 break;
11222 }
11223 case 4:
11224 {
11225 FreeExpContents(exp);
11226 exp->__anon1.__anon1.constant = PrintInt64(*(long long *)ptr);
11227 exp->type = 2;
11228 break;
11229 }
11230 case 22:
11231 {
11232 FreeExpContents(exp);
11233 exp->__anon1.__anon1.constant = PrintInt64((long long)*(intptr_t *)ptr);
11234 exp->type = 2;
11235 break;
11236 }
11237 case 23:
11238 {
11239 FreeExpContents(exp);
11240 exp->__anon1.__anon1.constant = PrintInt64((long long)*(intptr_t *)ptr);
11241 exp->type = 2;
11242 break;
11243 }
11244 default:
11245 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unhandled type populating instance\n", (((void *)0))));
11246 }
11247 }
11248 ListAdd(memberList, member);
11249 }
11250 if(parentDataMember->type == 1)
11251 break;
11252 }
11253 }
11254
11255 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
11256
11257 void PopulateInstance(struct Instantiation * inst)
11258 {
11259 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
11260 struct __ecereNameSpace__ecere__com__Class * _class = classSym->__anon1.registered;
11261 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
11262 struct __ecereNameSpace__ecere__sys__OldList * memberList = MkList();
11263
11264 if(!inst->members)
11265 inst->members = MkListOne(MkMembersInitList(memberList));
11266 else
11267 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*inst->members), MkMembersInitList(memberList));
11268 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
11269 {
11270 if(!dataMember->isProperty)
11271 {
11272 if(!dataMember->name && (dataMember->type == 2 || dataMember->type == 1))
11273 PopulateInstanceProcessMember(inst, memberList, dataMember, dataMember->offset);
11274 else
11275 {
11276 struct Expression * exp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
11277 struct MemberInit * member = MkMemberInit(MkListOne(MkIdentifier(dataMember->name)), MkInitializerAssignment(exp));
11278 struct Type * type;
11279 void * ptr = inst->data + dataMember->offset;
11280 char * result = (((void *)0));
11281
11282 exp->loc = member->loc = inst->loc;
11283 ((struct Identifier *)(*member->identifiers).first)->loc = inst->loc;
11284 if(!dataMember->dataType)
11285 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
11286 type = dataMember->dataType;
11287 if(type->kind == 8)
11288 {
11289 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11290
11291 if(_class->type == 4)
11292 {
11293 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
11294
11295 if(enumClass)
11296 {
11297 struct __ecereNameSpace__ecere__com__EnumClassData * e = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
11298 struct __ecereNameSpace__ecere__sys__NamedLink64 * item;
11299
11300 for(item = e->values.first; item; item = item->next)
11301 {
11302 if(item->data == GetEnumValue(_class, ptr))
11303 {
11304 result = item->name;
11305 break;
11306 }
11307 }
11308 }
11309 if(result)
11310 {
11311 exp->__anon1.__anon1.identifier = MkIdentifier(result);
11312 exp->type = 0;
11313 exp->destType = MkClassType(_class->fullName);
11314 ProcessExpressionType(exp);
11315 }
11316 }
11317 if(_class->type == 4 || _class->type == 3 || _class->type == 2)
11318 {
11319 if(!_class->dataType)
11320 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
11321 type = _class->dataType;
11322 }
11323 }
11324 if(!result)
11325 {
11326 switch(type->kind)
11327 {
11328 case 6:
11329 {
11330 exp->__anon1.__anon1.constant = PrintFloat(*(float *)ptr);
11331 exp->type = 2;
11332 break;
11333 }
11334 case 7:
11335 {
11336 exp->__anon1.__anon1.constant = PrintDouble(*(double *)ptr);
11337 exp->type = 2;
11338 break;
11339 }
11340 case 3:
11341 {
11342 exp->__anon1.__anon1.constant = PrintInt(*(int *)ptr);
11343 exp->type = 2;
11344 break;
11345 }
11346 case 4:
11347 {
11348 exp->__anon1.__anon1.constant = PrintInt64(*(long long *)ptr);
11349 exp->type = 2;
11350 break;
11351 }
11352 case 22:
11353 {
11354 exp->__anon1.__anon1.constant = PrintInt64((long long)*(intptr_t *)ptr);
11355 exp->type = 2;
11356 break;
11357 }
11358 default:
11359 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unhandled type populating instance\n", (((void *)0))));
11360 }
11361 }
11362 ListAdd(memberList, member);
11363 }
11364 }
11365 }
11366 }
11367
11368 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, unsigned int *  offset, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
11369
11370 extern void FreeInstance(struct Instantiation * inst);
11371
11372 void ComputeInstantiation(struct Expression * exp)
11373 {
11374 struct Instantiation * inst = exp->__anon1.instance;
11375 struct MembersInit * members;
11376 struct Symbol * classSym = inst->_class ? inst->_class->__anon1.__anon1.symbol : (((void *)0));
11377 struct __ecereNameSpace__ecere__com__Class * _class = classSym ? classSym->__anon1.registered : (((void *)0));
11378 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
11379 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
11380 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
11381 int subMemberStackPos = 0;
11382 uint64 bits = 0;
11383
11384 if(_class && (_class->type == 1 || _class->type == 0 || _class->type == 5))
11385 {
11386 if(inst->data)
11387 return ;
11388 if(_class->type == 0 || _class->type == 5)
11389 {
11390 inst->data = (unsigned char *)__ecereNameSpace__ecere__com__eInstance_New(_class);
11391 if(_class->type == 0)
11392 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)((struct __ecereNameSpace__ecere__com__Instance *)inst->data))->_refCount++;
11393 }
11394 else
11395 inst->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
11396 }
11397 if(inst->members)
11398 {
11399 for(members = (*inst->members).first; members; members = members->next)
11400 {
11401 switch(members->type)
11402 {
11403 case 0:
11404 {
11405 if(members->__anon1.dataMembers)
11406 {
11407 struct MemberInit * member;
11408
11409 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
11410 {
11411 struct Identifier * ident = member->identifiers ? (*member->identifiers).first : (((void *)0));
11412 unsigned int found = 0;
11413 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
11414 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
11415 unsigned int dataMemberOffset;
11416
11417 if(!ident)
11418 {
11419 __ecereNameSpace__ecere__com__eClass_FindNextMember(_class, &curClass, &curMember, subMemberStack, &subMemberStackPos);
11420 if(curMember)
11421 {
11422 if(curMember->isProperty)
11423 prop = (struct __ecereNameSpace__ecere__com__Property *)curMember;
11424 else
11425 {
11426 dataMember = curMember;
11427 __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(_class, dataMember->name, &dataMemberOffset, privateModule, (((void *)0)), (((void *)0)));
11428 if(_class->type == 0)
11429 dataMemberOffset += _class->base->structSize;
11430 }
11431 found = 1;
11432 }
11433 }
11434 else
11435 {
11436 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, ident->string, privateModule);
11437 if(prop)
11438 {
11439 found = 1;
11440 if(prop->memberAccess == 1)
11441 {
11442 curMember = (struct __ecereNameSpace__ecere__com__DataMember *)prop;
11443 curClass = prop->_class;
11444 }
11445 }
11446 else
11447 {
11448 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
11449 int _subMemberStackPos = 0;
11450
11451 dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(_class, ident->string, &dataMemberOffset, privateModule, _subMemberStack, &_subMemberStackPos);
11452 if(dataMember)
11453 {
11454 found = 1;
11455 if(dataMember->memberAccess == 1)
11456 {
11457 curMember = dataMember;
11458 curClass = dataMember->_class;
11459 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
11460 subMemberStackPos = _subMemberStackPos;
11461 }
11462 }
11463 }
11464 }
11465 if(found && member->initializer && member->initializer->type == 0)
11466 {
11467 struct Expression * value = member->initializer->__anon1.exp;
11468 struct Type * type = (((void *)0));
11469 unsigned int deepMember = 0;
11470
11471 if(prop)
11472 {
11473 type = prop->dataType;
11474 }
11475 else if(dataMember)
11476 {
11477 if(!dataMember->dataType)
11478 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0);
11479 type = dataMember->dataType;
11480 }
11481 if(ident && ident->next)
11482 {
11483 deepMember = 1;
11484 for(ident = ident->next; ident && type; ident = ident->next)
11485 {
11486 if(type->kind == 8)
11487 {
11488 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(type->__anon1._class->__anon1.registered, ident->string, privateModule);
11489 if(prop)
11490 type = prop->dataType;
11491 else
11492 {
11493 dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(type->__anon1._class->__anon1.registered, ident->string, &dataMemberOffset, privateModule, (((void *)0)), (((void *)0)));
11494 if(dataMember)
11495 type = dataMember->dataType;
11496 }
11497 }
11498 else if(type->kind == 9 || type->kind == 10)
11499 {
11500 struct Type * memberType;
11501
11502 for(memberType = type->__anon1.__anon1.members.first; memberType; memberType = memberType->next)
11503 {
11504 if(!strcmp(memberType->name, ident->string))
11505 {
11506 type = memberType;
11507 break;
11508 }
11509 }
11510 }
11511 }
11512 }
11513 if(value)
11514 {
11515 FreeType(value->destType);
11516 value->destType = type;
11517 if(type)
11518 type->refCount++;
11519 ComputeExpression(value);
11520 }
11521 if(!deepMember && type && value && (_class->type == 1 || _class->type == 0 || _class->type == 5))
11522 {
11523 if(type->kind == 8)
11524 {
11525 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11526
11527 if(_class->type == 2 || _class->type == 3 || _class->type == 4)
11528 {
11529 if(!_class->dataType)
11530 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
11531 type = _class->dataType;
11532 }
11533 }
11534 if(dataMember)
11535 {
11536 void * ptr = inst->data + dataMemberOffset;
11537
11538 if(value->type == 2)
11539 {
11540 switch(type->kind)
11541 {
11542 case 3:
11543 {
11544 GetInt(value, (int *)ptr);
11545 break;
11546 }
11547 case 4:
11548 {
11549 GetInt64(value, (long long *)ptr);
11550 break;
11551 }
11552 case 22:
11553 {
11554 GetIntPtr(value, (intptr_t *)ptr);
11555 break;
11556 }
11557 case 23:
11558 {
11559 GetIntSize(value, (ssize_t *)ptr);
11560 break;
11561 }
11562 case 6:
11563 {
11564 GetFloat(value, (float *)ptr);
11565 break;
11566 }
11567 case 7:
11568 {
11569 GetDouble(value, (double *)ptr);
11570 break;
11571 }
11572 }
11573 }
11574 else if(value->type == 1)
11575 {
11576 if(type->kind == 8)
11577 {
11578 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11579
11580 if(_class->type == 1)
11581 {
11582 ComputeTypeSize(type);
11583 if(value->__anon1.instance->data)
11584 memcpy(ptr, value->__anon1.instance->data, type->size);
11585 }
11586 }
11587 }
11588 }
11589 else if(prop)
11590 {
11591 if(value->type == 1 && value->__anon1.instance->data)
11592 {
11593 if(type->kind == 8)
11594 {
11595 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11596
11597 if(_class && (_class->type != 0 || __ecereNameSpace__ecere__com__eClass_IsDerived(((struct __ecereNameSpace__ecere__com__Instance *)(char *)((struct __ecereNameSpace__ecere__com__Instance *)value->__anon1.instance->data))->_class, _class)))
11598 {
11599 void (* Set)(void *, void *) = (void *)prop->Set;
11600
11601 Set(inst->data, value->__anon1.instance->data);
11602 PopulateInstance(inst);
11603 }
11604 }
11605 }
11606 else if(value->type == 2)
11607 {
11608 switch(type->kind)
11609 {
11610 case 7:
11611 {
11612 void (* Set)(void *, double) = (void *)prop->Set;
11613
11614 Set(inst->data, strtod(value->__anon1.__anon1.constant, (((void *)0))));
11615 break;
11616 }
11617 case 6:
11618 {
11619 void (* Set)(void *, float) = (void *)prop->Set;
11620
11621 Set(inst->data, (float)(strtod(value->__anon1.__anon1.constant, (((void *)0)))));
11622 break;
11623 }
11624 case 3:
11625 {
11626 void (* Set)(void *, int) = (void *)prop->Set;
11627
11628 Set(inst->data, strtol(value->__anon1.__anon1.constant, (((void *)0)), 0));
11629 break;
11630 }
11631 case 4:
11632 {
11633 void (* Set)(void *, long long) = (void *)prop->Set;
11634
11635 Set(inst->data, __ecereNameSpace__ecere__com___strtoi64(value->__anon1.__anon1.constant, (((void *)0)), 0));
11636 break;
11637 }
11638 case 22:
11639 {
11640 void (* Set)(void *, intptr_t) = (void *)prop->Set;
11641
11642 Set(inst->data, (intptr_t)__ecereNameSpace__ecere__com___strtoi64(value->__anon1.__anon1.constant, (((void *)0)), 0));
11643 break;
11644 }
11645 case 23:
11646 {
11647 void (* Set)(void *, ssize_t) = (void *)prop->Set;
11648
11649 Set(inst->data, (ssize_t)__ecereNameSpace__ecere__com___strtoi64(value->__anon1.__anon1.constant, (((void *)0)), 0));
11650 break;
11651 }
11652 }
11653 }
11654 else if(value->type == 3)
11655 {
11656 char temp[1024];
11657
11658 ReadString(temp, value->__anon1.__anon2.string);
11659 ((void (*)(void *, void *))(void *)prop->Set)(inst->data, temp);
11660 }
11661 }
11662 }
11663 else if(!deepMember && type && _class->type == 3)
11664 {
11665 if(prop)
11666 {
11667 if(value->type == 2)
11668 {
11669 if(type->kind == 8)
11670 {
11671 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
11672
11673 if(_class->type == 3)
11674 {
11675 if(!_class->dataType)
11676 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
11677 type = _class->dataType;
11678 }
11679 }
11680 switch(type->kind)
11681 {
11682 case 6:
11683 {
11684 float fValue;
11685 float (* Set)(float) = (void *)prop->Set;
11686
11687 GetFloat(member->initializer->__anon1.exp, &fValue);
11688 exp->__anon1.__anon1.constant = PrintFloat(Set(fValue));
11689 exp->type = 2;
11690 break;
11691 }
11692 case 7:
11693 {
11694 double dValue;
11695 double (* Set)(double) = (void *)prop->Set;
11696
11697 GetDouble(member->initializer->__anon1.exp, &dValue);
11698 exp->__anon1.__anon1.constant = PrintDouble(Set(dValue));
11699 exp->type = 2;
11700 break;
11701 }
11702 }
11703 }
11704 }
11705 }
11706 else if(!deepMember && type && _class->type == 2)
11707 {
11708 if(prop)
11709 {
11710 if(value->type == 1 && value->__anon1.instance->data)
11711 {
11712 unsigned int (* Set)(void *) = (void *)prop->Set;
11713
11714 bits = Set(value->__anon1.instance->data);
11715 }
11716 else if(value->type == 2)
11717 {
11718 }
11719 }
11720 else if(dataMember)
11721 {
11722 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)dataMember;
11723 struct Type * type;
11724 uint64 part = 0;
11725
11726 bits = (bits & ~bitMember->mask);
11727 if(!bitMember->dataType)
11728 bitMember->dataType = ProcessTypeString(bitMember->dataTypeString, 0);
11729 type = bitMember->dataType;
11730 if(type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered)
11731 {
11732 if(!type->__anon1._class->__anon1.registered->dataType)
11733 type->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type->__anon1._class->__anon1.registered->dataTypeString, 0);
11734 type = type->__anon1._class->__anon1.registered->dataType;
11735 }
11736 switch(type->kind)
11737 {
11738 case 24:
11739 case 1:
11740 {
11741 unsigned char v;
11742
11743 type->isSigned ? GetChar(value, (char *)&v) : GetUChar(value, &v);
11744 part = (uint64)v;
11745 break;
11746 }
11747 case 2:
11748 {
11749 unsigned short v;
11750
11751 type->isSigned ? GetShort(value, (short *)&v) : GetUShort(value, &v);
11752 part = (uint64)v;
11753 break;
11754 }
11755 case 3:
11756 case 5:
11757 {
11758 unsigned int v;
11759
11760 type->isSigned ? GetInt(value, (int *)&v) : GetUInt(value, &v);
11761 part = (uint64)v;
11762 break;
11763 }
11764 case 4:
11765 {
11766 uint64 v;
11767
11768 type->isSigned ? GetInt64(value, (long long *)&v) : GetUInt64(value, &v);
11769 part = v;
11770 break;
11771 }
11772 case 22:
11773 {
11774 uintptr_t v;
11775
11776 type->isSigned ? GetIntPtr(value, (intptr_t *)&v) : GetUIntPtr(value, &v);
11777 part = (uint64)v;
11778 break;
11779 }
11780 case 23:
11781 {
11782 size_t v;
11783
11784 type->isSigned ? GetIntSize(value, (ssize_t *)&v) : GetUIntSize(value, &v);
11785 part = (uint64)v;
11786 break;
11787 }
11788 }
11789 bits |= part << bitMember->pos;
11790 }
11791 }
11792 }
11793 else
11794 {
11795 if(_class && _class->type == 3)
11796 {
11797 ComputeExpression(member->initializer->__anon1.exp);
11798 exp->__anon1.__anon1.constant = member->initializer->__anon1.exp->__anon1.__anon1.constant;
11799 exp->type = 2;
11800 member->initializer->__anon1.exp->__anon1.__anon1.constant = (((void *)0));
11801 }
11802 }
11803 }
11804 }
11805 break;
11806 }
11807 }
11808 }
11809 }
11810 if(_class && _class->type == 2)
11811 {
11812 exp->__anon1.__anon1.constant = PrintHexUInt(bits);
11813 exp->type = 2;
11814 }
11815 if(exp->type != 1)
11816 {
11817 FreeInstance(inst);
11818 }
11819 }
11820
11821 static unsigned int Promote(struct Operand * op, int kind, unsigned int isSigned)
11822 {
11823 unsigned int result = 0;
11824
11825 switch(kind)
11826 {
11827 case 2:
11828 if(op->kind == 1 || op->kind == 15 || op->kind == 24)
11829 result = isSigned ? GetOpShort(op, &op->__anon1.s) : GetOpUShort(op, &op->__anon1.us);
11830 break;
11831 case 3:
11832 case 5:
11833 if(op->kind == 1 || op->kind == 2 || op->kind == 15 || op->kind == 24)
11834 result = isSigned ? GetOpInt(op, &op->__anon1.i) : GetOpUInt(op, &op->__anon1.ui);
11835 break;
11836 case 4:
11837 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
11838 result = isSigned ? GetOpInt64(op, &op->__anon1.i64) : GetOpUInt64(op, &op->__anon1.ui64);
11839 break;
11840 case 6:
11841 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
11842 result = GetOpFloat(op, &op->__anon1.f);
11843 break;
11844 case 7:
11845 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
11846 result = GetOpDouble(op, &op->__anon1.d);
11847 break;
11848 case 13:
11849 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
11850 result = GetOpUInt64(op, &op->__anon1.ui64);
11851 break;
11852 case 15:
11853 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
11854 result = isSigned ? GetOpInt(op, &op->__anon1.i) : GetOpUInt(op, &op->__anon1.ui);
11855 break;
11856 case 22:
11857 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 5 || op->kind == 15 || op->kind == 24)
11858 result = isSigned ? GetOpInt64(op, &op->__anon1.i64) : GetOpUInt64(op, &op->__anon1.ui64);
11859 break;
11860 case 23:
11861 if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 5 || op->kind == 15 || op->kind == 24)
11862 result = isSigned ? GetOpInt64(op, &op->__anon1.i64) : GetOpUInt64(op, &op->__anon1.ui64);
11863 break;
11864 }
11865 return result;
11866 }
11867
11868 void CallOperator(struct Expression * exp, struct Expression * exp1, struct Expression * exp2, struct Operand * op1, struct Operand * op2)
11869 {
11870 if(exp->__anon1.op.op == SIZEOF)
11871 {
11872 FreeExpContents(exp);
11873 exp->type = 2;
11874 exp->__anon1.__anon1.constant = PrintUInt(ComputeTypeSize(op1->type));
11875 }
11876 else
11877 {
11878 if(!exp->__anon1.op.exp1)
11879 {
11880 switch(exp->__anon1.op.op)
11881 {
11882 case '+':
11883 {
11884 struct Expression * exp2 = exp->__anon1.op.exp2;
11885
11886 exp->__anon1.op.exp2 = (((void *)0));
11887 FreeExpContents(exp);
11888 FreeType(exp->expType);
11889 FreeType(exp->destType);
11890 *exp = *exp2;
11891 ((exp2 ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)exp2) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(exp2)) : 0), exp2 = 0);
11892 break;
11893 }
11894 case '-':
11895 if(op1->ops.Neg)
11896 {
11897 FreeExpContents(exp);
11898 op1->ops.Neg(exp, op1);
11899 }
11900 break;
11901 case '~':
11902 if(op1->ops.BitNot)
11903 {
11904 FreeExpContents(exp);
11905 op1->ops.BitNot(exp, op1);
11906 }
11907 break;
11908 case '!':
11909 if(op1->ops.Not)
11910 {
11911 FreeExpContents(exp);
11912 op1->ops.Not(exp, op1);
11913 }
11914 break;
11915 }
11916 }
11917 else
11918 {
11919 if(op1 && op2 && op1->type && op2->type && op1->kind != op2->kind)
11920 {
11921 if(Promote(op2, op1->kind, op1->type->isSigned))
11922 op2->kind = op1->kind, op2->ops = op1->ops;
11923 else if(Promote(op1, op2->kind, op2->type->isSigned))
11924 op1->kind = op2->kind, op1->ops = op2->ops;
11925 }
11926 switch(exp->__anon1.op.op)
11927 {
11928 case '+':
11929 if(op1->ops.Add)
11930 {
11931 FreeExpContents(exp);
11932 op1->ops.Add(exp, op1, op2);
11933 }
11934 break;
11935 case '-':
11936 if(op1->ops.Sub)
11937 {
11938 FreeExpContents(exp);
11939 op1->ops.Sub(exp, op1, op2);
11940 }
11941 break;
11942 case '*':
11943 if(op1->ops.Mul)
11944 {
11945 FreeExpContents(exp);
11946 op1->ops.Mul(exp, op1, op2);
11947 }
11948 break;
11949 case '/':
11950 if(op1->ops.Div)
11951 {
11952 FreeExpContents(exp);
11953 op1->ops.Div(exp, op1, op2);
11954 }
11955 break;
11956 case '%':
11957 if(op1->ops.Mod)
11958 {
11959 FreeExpContents(exp);
11960 op1->ops.Mod(exp, op1, op2);
11961 }
11962 break;
11963 case '&':
11964 if(exp->__anon1.op.exp2)
11965 {
11966 if(op1->ops.BitAnd)
11967 {
11968 FreeExpContents(exp);
11969 op1->ops.BitAnd(exp, op1, op2);
11970 }
11971 }
11972 break;
11973 case '|':
11974 if(op1->ops.BitOr)
11975 {
11976 FreeExpContents(exp);
11977 op1->ops.BitOr(exp, op1, op2);
11978 }
11979 break;
11980 case '^':
11981 if(op1->ops.BitXor)
11982 {
11983 FreeExpContents(exp);
11984 op1->ops.BitXor(exp, op1, op2);
11985 }
11986 break;
11987 case LEFT_OP:
11988 if(op1->ops.LShift)
11989 {
11990 FreeExpContents(exp);
11991 op1->ops.LShift(exp, op1, op2);
11992 }
11993 break;
11994 case RIGHT_OP:
11995 if(op1->ops.RShift)
11996 {
11997 FreeExpContents(exp);
11998 op1->ops.RShift(exp, op1, op2);
11999 }
12000 break;
12001 case EQ_OP:
12002 if(op1->ops.Equ)
12003 {
12004 FreeExpContents(exp);
12005 op1->ops.Equ(exp, op1, op2);
12006 }
12007 break;
12008 case NE_OP:
12009 if(op1->ops.Nqu)
12010 {
12011 FreeExpContents(exp);
12012 op1->ops.Nqu(exp, op1, op2);
12013 }
12014 break;
12015 case AND_OP:
12016 if(op1->ops.And)
12017 {
12018 FreeExpContents(exp);
12019 op1->ops.And(exp, op1, op2);
12020 }
12021 break;
12022 case OR_OP:
12023 if(op1->ops.Or)
12024 {
12025 FreeExpContents(exp);
12026 op1->ops.Or(exp, op1, op2);
12027 }
12028 break;
12029 case '>':
12030 if(op1->ops.Grt)
12031 {
12032 FreeExpContents(exp);
12033 op1->ops.Grt(exp, op1, op2);
12034 }
12035 break;
12036 case '<':
12037 if(op1->ops.Sma)
12038 {
12039 FreeExpContents(exp);
12040 op1->ops.Sma(exp, op1, op2);
12041 }
12042 break;
12043 case GE_OP:
12044 if(op1->ops.GrtEqu)
12045 {
12046 FreeExpContents(exp);
12047 op1->ops.GrtEqu(exp, op1, op2);
12048 }
12049 break;
12050 case LE_OP:
12051 if(op1->ops.SmaEqu)
12052 {
12053 FreeExpContents(exp);
12054 op1->ops.SmaEqu(exp, op1, op2);
12055 }
12056 break;
12057 }
12058 }
12059 }
12060 }
12061
12062 void PrintTypeNoConst(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
12063
12064 extern struct Expression * MkExpIdentifier(struct Identifier * id);
12065
12066 void ComputeExpression(struct Expression * exp)
12067 {
12068 switch(exp->type)
12069 {
12070 case 1:
12071 {
12072 ComputeInstantiation(exp);
12073 break;
12074 }
12075 case 4:
12076 {
12077 struct Expression * exp1, * exp2 = (((void *)0));
12078 struct Operand op1 =
12079 {
12080 0, 0, 0,
12081 .__anon1 = {
12082 .c = 0
12083 },
12084 {
12085 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
12086 }
12087 };
12088 struct Operand op2 =
12089 {
12090 0, 0, 0,
12091 .__anon1 = {
12092 .c = 0
12093 },
12094 {
12095 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
12096 }
12097 };
12098
12099 if(exp->__anon1.op.exp2)
12100 {
12101 struct Expression * e = exp->__anon1.op.exp2;
12102
12103 while((e->type == 5 || e->type == 32 || e->type == 23) && e->__anon1.list)
12104 {
12105 if(e->type == 5 || e->type == 32 || e->type == 23)
12106 {
12107 if(e->type == 23)
12108 e = (*((struct Statement *)(*e->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last;
12109 else
12110 e = (*e->__anon1.list).last;
12111 }
12112 }
12113 if(exp->__anon1.op.op == 261 && e && e->expType)
12114 {
12115 if(e->type == 3 && e->__anon1.__anon2.string)
12116 {
12117 char * string = e->__anon1.__anon2.string;
12118 int len = strlen(string);
12119 char * tmp = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len - 2 + 1));
12120
12121 len = UnescapeString(tmp, string + 1, len - 2);
12122 (__ecereNameSpace__ecere__com__eSystem_Delete(tmp), tmp = 0);
12123 FreeExpContents(exp);
12124 exp->type = 2;
12125 exp->__anon1.__anon1.constant = PrintUInt(len + 1);
12126 }
12127 else
12128 {
12129 struct Type * type = e->expType;
12130
12131 type->refCount++;
12132 FreeExpContents(exp);
12133 exp->type = 2;
12134 exp->__anon1.__anon1.constant = PrintUInt(ComputeTypeSize(type));
12135 FreeType(type);
12136 }
12137 break;
12138 }
12139 else
12140 ComputeExpression(exp->__anon1.op.exp2);
12141 }
12142 if(exp->__anon1.op.exp1)
12143 {
12144 ComputeExpression(exp->__anon1.op.exp1);
12145 exp1 = exp->__anon1.op.exp1;
12146 exp2 = exp->__anon1.op.exp2;
12147 op1 = GetOperand(exp1);
12148 if(op1.type)
12149 op1.type->refCount++;
12150 if(exp2)
12151 {
12152 op2 = GetOperand(exp2);
12153 if(op2.type)
12154 op2.type->refCount++;
12155 }
12156 }
12157 else
12158 {
12159 exp1 = exp->__anon1.op.exp2;
12160 op1 = GetOperand(exp1);
12161 if(op1.type)
12162 op1.type->refCount++;
12163 }
12164 CallOperator(exp, exp1, exp2, &op1, &op2);
12165 if(op1.type)
12166 FreeType(op1.type);
12167 if(op2.type)
12168 FreeType(op2.type);
12169 break;
12170 }
12171 case 5:
12172 case 32:
12173 {
12174 struct Expression * e, * n;
12175
12176 for(e = (*exp->__anon1.list).first; e; e = n)
12177 {
12178 n = e->next;
12179 if(!n)
12180 {
12181 struct __ecereNameSpace__ecere__sys__OldList * list = exp->__anon1.list;
12182 struct Expression * prev = exp->prev;
12183 struct Expression * next = exp->next;
12184
12185 ComputeExpression(e);
12186 FreeType(exp->expType);
12187 FreeType(exp->destType);
12188 *exp = *e;
12189 exp->prev = prev;
12190 exp->next = next;
12191 ((e ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
12192 (__ecereNameSpace__ecere__com__eSystem_Delete(list), list = 0);
12193 }
12194 else
12195 {
12196 FreeExpression(e);
12197 }
12198 }
12199 break;
12200 }
12201 case 8:
12202 {
12203 struct Expression * memberExp = exp->__anon1.member.exp;
12204 struct Identifier * memberID = exp->__anon1.member.member;
12205 struct Type * type;
12206
12207 ComputeExpression(exp->__anon1.member.exp);
12208 type = exp->__anon1.member.exp->expType;
12209 if(type)
12210 {
12211 struct __ecereNameSpace__ecere__com__Class * _class = (exp->__anon1.member.member && exp->__anon1.member.member->classSym) ? exp->__anon1.member.member->classSym->__anon1.registered : (((type->kind == 8 || type->kind == 19) && type->__anon1._class) ? type->__anon1._class->__anon1.registered : (((void *)0)));
12212 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
12213 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
12214 struct __ecereNameSpace__ecere__com__Class * convertTo = (((void *)0));
12215
12216 if(type->kind == 19 && exp->__anon1.member.exp->type == 24)
12217 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "ecere::com::Class");
12218 if(!_class)
12219 {
12220 char string[256];
12221 struct Symbol * classSym;
12222
12223 string[0] = '\0';
12224 PrintTypeNoConst(type, string, 0, 1);
12225 classSym = FindClass(string);
12226 _class = classSym ? classSym->__anon1.registered : (((void *)0));
12227 }
12228 if(exp->__anon1.member.member)
12229 {
12230 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, privateModule);
12231 if(!prop)
12232 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, privateModule, (((void *)0)), (((void *)0)));
12233 }
12234 if(!prop && !member && _class && exp->__anon1.member.member)
12235 {
12236 struct Symbol * classSym = FindClass(exp->__anon1.member.member->string);
12237
12238 convertTo = _class;
12239 _class = classSym ? classSym->__anon1.registered : (((void *)0));
12240 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, convertTo->fullName, privateModule);
12241 }
12242 if(prop)
12243 {
12244 if(prop->compiled)
12245 {
12246 struct Type * type = prop->dataType;
12247
12248 if(_class->type == 3)
12249 {
12250 if(type->kind == 8)
12251 {
12252 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
12253
12254 if(_class->type == 3)
12255 {
12256 if(!_class->dataType)
12257 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
12258 type = _class->dataType;
12259 }
12260 }
12261 switch(type->kind)
12262 {
12263 case 6:
12264 {
12265 float value;
12266 float (* Get)(float) = (void *)prop->Get;
12267
12268 GetFloat(exp->__anon1.member.exp, &value);
12269 exp->__anon1.__anon1.constant = PrintFloat(Get ? Get(value) : value);
12270 exp->type = 2;
12271 break;
12272 }
12273 case 7:
12274 {
12275 double value;
12276 double (* Get)(double);
12277
12278 GetDouble(exp->__anon1.member.exp, &value);
12279 if(convertTo)
12280 Get = (void *)prop->Set;
12281 else
12282 Get = (void *)prop->Get;
12283 exp->__anon1.__anon1.constant = PrintDouble(Get ? Get(value) : value);
12284 exp->type = 2;
12285 break;
12286 }
12287 }
12288 }
12289 else
12290 {
12291 if(convertTo)
12292 {
12293 struct Expression * value = exp->__anon1.member.exp;
12294 struct Type * type;
12295
12296 if(!prop->dataType)
12297 ProcessPropertyType(prop);
12298 type = prop->dataType;
12299 if(!type)
12300 {
12301 }
12302 else if(_class->type == 1)
12303 {
12304 switch(type->kind)
12305 {
12306 case 8:
12307 {
12308 struct __ecereNameSpace__ecere__com__Class * propertyClass = type->__anon1._class->__anon1.registered;
12309
12310 if(propertyClass->type == 1 && value->type == 1)
12311 {
12312 void (* Set)(void *, void *) = (void *)prop->Set;
12313
12314 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12315 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12316 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12317 exp->__anon1.instance->loc = exp->loc;
12318 exp->type = 1;
12319 Set(exp->__anon1.instance->data, value->__anon1.instance->data);
12320 PopulateInstance(exp->__anon1.instance);
12321 }
12322 break;
12323 }
12324 case 3:
12325 {
12326 int intValue;
12327 void (* Set)(void *, int) = (void *)prop->Set;
12328
12329 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12330 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12331 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12332 exp->__anon1.instance->loc = exp->loc;
12333 exp->type = 1;
12334 GetInt(value, &intValue);
12335 Set(exp->__anon1.instance->data, intValue);
12336 PopulateInstance(exp->__anon1.instance);
12337 break;
12338 }
12339 case 4:
12340 {
12341 long long intValue;
12342 void (* Set)(void *, long long) = (void *)prop->Set;
12343
12344 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12345 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12346 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12347 exp->__anon1.instance->loc = exp->loc;
12348 exp->type = 1;
12349 GetInt64(value, &intValue);
12350 Set(exp->__anon1.instance->data, intValue);
12351 PopulateInstance(exp->__anon1.instance);
12352 break;
12353 }
12354 case 22:
12355 {
12356 intptr_t intValue;
12357 void (* Set)(void *, intptr_t) = (void *)prop->Set;
12358
12359 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12360 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12361 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12362 exp->__anon1.instance->loc = exp->loc;
12363 exp->type = 1;
12364 GetIntPtr(value, &intValue);
12365 Set(exp->__anon1.instance->data, intValue);
12366 PopulateInstance(exp->__anon1.instance);
12367 break;
12368 }
12369 case 23:
12370 {
12371 ssize_t intValue;
12372 void (* Set)(void *, ssize_t) = (void *)prop->Set;
12373
12374 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12375 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12376 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12377 exp->__anon1.instance->loc = exp->loc;
12378 exp->type = 1;
12379 GetIntSize(value, &intValue);
12380 Set(exp->__anon1.instance->data, intValue);
12381 PopulateInstance(exp->__anon1.instance);
12382 break;
12383 }
12384 case 6:
12385 {
12386 float floatValue;
12387 void (* Set)(void *, float) = (void *)prop->Set;
12388
12389 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12390 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12391 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12392 exp->__anon1.instance->loc = exp->loc;
12393 exp->type = 1;
12394 GetFloat(value, &floatValue);
12395 Set(exp->__anon1.instance->data, floatValue);
12396 PopulateInstance(exp->__anon1.instance);
12397 break;
12398 }
12399 case 7:
12400 {
12401 double doubleValue;
12402 void (* Set)(void *, double) = (void *)prop->Set;
12403
12404 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12405 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12406 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12407 exp->__anon1.instance->loc = exp->loc;
12408 exp->type = 1;
12409 GetDouble(value, &doubleValue);
12410 Set(exp->__anon1.instance->data, doubleValue);
12411 PopulateInstance(exp->__anon1.instance);
12412 break;
12413 }
12414 }
12415 }
12416 else if(_class->type == 2)
12417 {
12418 switch(type->kind)
12419 {
12420 case 8:
12421 {
12422 struct __ecereNameSpace__ecere__com__Class * propertyClass = type->__anon1._class->__anon1.registered;
12423
12424 if(propertyClass->type == 1 && value->__anon1.instance->data)
12425 {
12426 unsigned int (* Set)(void *) = (void *)prop->Set;
12427 unsigned int bits = Set(value->__anon1.instance->data);
12428
12429 exp->__anon1.__anon1.constant = PrintHexUInt(bits);
12430 exp->type = 2;
12431 break;
12432 }
12433 else if(_class->type == 2)
12434 {
12435 unsigned int value;
12436 unsigned int (* Set)(unsigned int) = (void *)prop->Set;
12437 unsigned int bits;
12438
12439 GetUInt(exp->__anon1.member.exp, &value);
12440 bits = Set(value);
12441 exp->__anon1.__anon1.constant = PrintHexUInt(bits);
12442 exp->type = 2;
12443 }
12444 }
12445 }
12446 }
12447 }
12448 else
12449 {
12450 if(_class->type == 2)
12451 {
12452 unsigned int value;
12453
12454 GetUInt(exp->__anon1.member.exp, &value);
12455 switch(type->kind)
12456 {
12457 case 8:
12458 {
12459 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
12460
12461 if(_class->type == 1)
12462 {
12463 void (* Get)(unsigned int, void *) = (void *)prop->Get;
12464
12465 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12466 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12467 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12468 exp->__anon1.instance->loc = exp->loc;
12469 exp->type = 1;
12470 Get(value, exp->__anon1.instance->data);
12471 PopulateInstance(exp->__anon1.instance);
12472 }
12473 else if(_class->type == 2)
12474 {
12475 unsigned int (* Get)(unsigned int) = (void *)prop->Get;
12476 uint64 bits = Get(value);
12477
12478 exp->__anon1.__anon1.constant = PrintHexUInt64(bits);
12479 exp->type = 2;
12480 }
12481 break;
12482 }
12483 }
12484 }
12485 else if(_class->type == 1)
12486 {
12487 unsigned char * value = (exp->__anon1.member.exp->type == 1) ? exp->__anon1.member.exp->__anon1.instance->data : (((void *)0));
12488
12489 switch(type->kind)
12490 {
12491 case 8:
12492 {
12493 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
12494
12495 if(_class->type == 1 && value)
12496 {
12497 void (* Get)(void *, void *) = (void *)prop->Get;
12498
12499 exp->__anon1.instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
12500 exp->__anon1.instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
12501 exp->__anon1.instance->_class = MkSpecifierName(_class->fullName);
12502 exp->__anon1.instance->loc = exp->loc;
12503 exp->type = 1;
12504 Get(value, exp->__anon1.instance->data);
12505 PopulateInstance(exp->__anon1.instance);
12506 }
12507 break;
12508 }
12509 }
12510 }
12511 }
12512 }
12513 }
12514 else
12515 {
12516 exp->isConstant = 0;
12517 }
12518 }
12519 else if(member)
12520 {
12521 }
12522 }
12523 if(exp->type != 8)
12524 {
12525 FreeExpression(memberExp);
12526 FreeIdentifier(memberID);
12527 }
12528 break;
12529 }
12530 case 10:
12531 {
12532 struct Type * type = ProcessType(exp->__anon1.typeName->qualifiers, exp->__anon1.typeName->declarator);
12533
12534 FreeExpContents(exp);
12535 exp->__anon1.__anon1.constant = PrintUInt(ComputeTypeSize(type));
12536 exp->type = 2;
12537 FreeType(type);
12538 break;
12539 }
12540 case 15:
12541 {
12542 struct Symbol * classSym = exp->__anon1._class->__anon1.__anon1.symbol;
12543
12544 if(classSym && classSym->__anon1.registered)
12545 {
12546 if(classSym->__anon1.registered->fixed)
12547 {
12548 FreeSpecifier(exp->__anon1._class);
12549 exp->__anon1.__anon1.constant = PrintUInt(classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->structSize : classSym->__anon1.registered->structSize);
12550 exp->type = 2;
12551 }
12552 else
12553 {
12554 char className[1024];
12555
12556 strcpy(className, "__ecereClass_");
12557 FullClassNameCat(className, classSym->string, 1);
12558 DeclareClass(classSym, className);
12559 FreeExpContents(exp);
12560 exp->type = 9;
12561 exp->__anon1.member.exp = MkExpIdentifier(MkIdentifier(className));
12562 exp->__anon1.member.member = MkIdentifier("structSize");
12563 }
12564 }
12565 break;
12566 }
12567 case 11:
12568 {
12569 struct Type * type;
12570 struct Expression * e = exp;
12571
12572 if(exp->type == 11)
12573 {
12574 if(exp->__anon1.cast.exp)
12575 ComputeExpression(exp->__anon1.cast.exp);
12576 e = exp->__anon1.cast.exp;
12577 }
12578 if(e && exp->expType)
12579 {
12580 type = exp->expType;
12581 if(type->kind == 8)
12582 {
12583 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1._class->__anon1.registered;
12584
12585 if(_class && (_class->type == 3 || _class->type == 2))
12586 {
12587 if(!_class->dataType)
12588 _class->dataType = ProcessTypeString(_class->dataTypeString, 0);
12589 type = _class->dataType;
12590 }
12591 }
12592 switch(type->kind)
12593 {
12594 case 24:
12595 case 1:
12596 if(type->isSigned)
12597 {
12598 char value = (char)0;
12599
12600 if(GetChar(e, &value))
12601 {
12602 FreeExpContents(exp);
12603 exp->__anon1.__anon1.constant = PrintChar(value);
12604 exp->type = 2;
12605 }
12606 }
12607 else
12608 {
12609 unsigned char value = (unsigned char)0;
12610
12611 if(GetUChar(e, &value))
12612 {
12613 FreeExpContents(exp);
12614 exp->__anon1.__anon1.constant = PrintUChar(value);
12615 exp->type = 2;
12616 }
12617 }
12618 break;
12619 case 2:
12620 if(type->isSigned)
12621 {
12622 short value = (short)0;
12623
12624 if(GetShort(e, &value))
12625 {
12626 FreeExpContents(exp);
12627 exp->__anon1.__anon1.constant = PrintShort(value);
12628 exp->type = 2;
12629 }
12630 }
12631 else
12632 {
12633 unsigned short value = (unsigned short)0;
12634
12635 if(GetUShort(e, &value))
12636 {
12637 FreeExpContents(exp);
12638 exp->__anon1.__anon1.constant = PrintUShort(value);
12639 exp->type = 2;
12640 }
12641 }
12642 break;
12643 case 3:
12644 if(type->isSigned)
12645 {
12646 int value = 0;
12647
12648 if(GetInt(e, &value))
12649 {
12650 FreeExpContents(exp);
12651 exp->__anon1.__anon1.constant = PrintInt(value);
12652 exp->type = 2;
12653 }
12654 }
12655 else
12656 {
12657 unsigned int value = 0;
12658
12659 if(GetUInt(e, &value))
12660 {
12661 FreeExpContents(exp);
12662 exp->__anon1.__anon1.constant = PrintUInt(value);
12663 exp->type = 2;
12664 }
12665 }
12666 break;
12667 case 4:
12668 if(type->isSigned)
12669 {
12670 long long value = 0;
12671
12672 if(GetInt64(e, &value))
12673 {
12674 FreeExpContents(exp);
12675 exp->__anon1.__anon1.constant = PrintInt64(value);
12676 exp->type = 2;
12677 }
12678 }
12679 else
12680 {
12681 uint64 value = 0;
12682
12683 if(GetUInt64(e, &value))
12684 {
12685 FreeExpContents(exp);
12686 exp->__anon1.__anon1.constant = PrintUInt64(value);
12687 exp->type = 2;
12688 }
12689 }
12690 break;
12691 case 22:
12692 if(type->isSigned)
12693 {
12694 intptr_t value = 0;
12695
12696 if(GetIntPtr(e, &value))
12697 {
12698 FreeExpContents(exp);
12699 exp->__anon1.__anon1.constant = PrintInt64((long long)value);
12700 exp->type = 2;
12701 }
12702 }
12703 else
12704 {
12705 uintptr_t value = 0;
12706
12707 if(GetUIntPtr(e, &value))
12708 {
12709 FreeExpContents(exp);
12710 exp->__anon1.__anon1.constant = PrintUInt64((uint64)value);
12711 exp->type = 2;
12712 }
12713 }
12714 break;
12715 case 23:
12716 if(type->isSigned)
12717 {
12718 ssize_t value = 0;
12719
12720 if(GetIntSize(e, &value))
12721 {
12722 FreeExpContents(exp);
12723 exp->__anon1.__anon1.constant = PrintInt64((long long)value);
12724 exp->type = 2;
12725 }
12726 }
12727 else
12728 {
12729 size_t value = 0;
12730
12731 if(GetUIntSize(e, &value))
12732 {
12733 FreeExpContents(exp);
12734 exp->__anon1.__anon1.constant = PrintUInt64((uint64)value);
12735 exp->type = 2;
12736 }
12737 }
12738 break;
12739 case 6:
12740 {
12741 float value = 0;
12742
12743 if(GetFloat(e, &value))
12744 {
12745 FreeExpContents(exp);
12746 exp->__anon1.__anon1.constant = PrintFloat(value);
12747 exp->type = 2;
12748 }
12749 break;
12750 }
12751 case 7:
12752 {
12753 double value = 0;
12754
12755 if(GetDouble(e, &value))
12756 {
12757 FreeExpContents(exp);
12758 exp->__anon1.__anon1.constant = PrintDouble(value);
12759 exp->type = 2;
12760 }
12761 break;
12762 }
12763 }
12764 }
12765 break;
12766 }
12767 case 12:
12768 {
12769 struct Operand op1 =
12770 {
12771 0, 0, 0,
12772 .__anon1 = {
12773 .c = 0
12774 },
12775 {
12776 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
12777 }
12778 };
12779 struct Operand op2 =
12780 {
12781 0, 0, 0,
12782 .__anon1 = {
12783 .c = 0
12784 },
12785 {
12786 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
12787 }
12788 };
12789 struct Operand op3 =
12790 {
12791 0, 0, 0,
12792 .__anon1 = {
12793 .c = 0
12794 },
12795 {
12796 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
12797 }
12798 };
12799
12800 if(exp->__anon1.cond.exp)
12801 ComputeExpression((*exp->__anon1.cond.exp).last);
12802 if(exp->__anon1.cond.elseExp)
12803 ComputeExpression(exp->__anon1.cond.elseExp);
12804 if(exp->__anon1.cond.cond)
12805 ComputeExpression(exp->__anon1.cond.cond);
12806 op1 = GetOperand(exp->__anon1.cond.cond);
12807 if(op1.type)
12808 op1.type->refCount++;
12809 op2 = GetOperand((*exp->__anon1.cond.exp).last);
12810 if(op2.type)
12811 op2.type->refCount++;
12812 op3 = GetOperand(exp->__anon1.cond.elseExp);
12813 if(op3.type)
12814 op3.type->refCount++;
12815 if(op1.ops.Cond)
12816 {
12817 FreeExpContents(exp);
12818 op1.ops.Cond(exp, &op1, &op2, &op3);
12819 }
12820 if(op1.type)
12821 FreeType(op1.type);
12822 if(op2.type)
12823 FreeType(op2.type);
12824 if(op3.type)
12825 FreeType(op3.type);
12826 break;
12827 }
12828 }
12829 }
12830
12831 void ApplyAnyObjectLogic(struct Expression * e);
12832
12833 static unsigned int CheckExpressionType(struct Expression * exp, struct Type * destType, unsigned int skipUnitBla, unsigned int warnConst)
12834 {
12835 unsigned int result = 1;
12836
12837 if(destType)
12838 {
12839 struct __ecereNameSpace__ecere__sys__OldList converts =
12840 {
12841 0, 0, 0, 0, 0
12842 };
12843 struct Conversion * convert;
12844
12845 if(destType->kind == 0)
12846 return 0;
12847 if(!MatchTypeExpression(exp, destType, &converts, skipUnitBla, warnConst))
12848 result = 0;
12849 if(converts.count)
12850 {
12851 for(convert = converts.first; convert; convert = convert->next)
12852 {
12853 unsigned int empty = !(convert->isGet ? (void *)convert->convert->Get : (void *)convert->convert->Set);
12854
12855 if(!empty)
12856 {
12857 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
12858 int objectType = exp->expType ? exp->expType->classObjectType : 0;
12859
12860 *newExp = *exp;
12861 newExp->prev = (((void *)0));
12862 newExp->next = (((void *)0));
12863 newExp->destType = (((void *)0));
12864 if(convert->isGet)
12865 {
12866 exp->type = 8;
12867 exp->addedThis = 1;
12868 exp->__anon1.member.exp = newExp;
12869 FreeType(exp->__anon1.member.exp->expType);
12870 exp->__anon1.member.exp->expType = MkClassType(convert->convert->_class->fullName);
12871 exp->__anon1.member.exp->expType->classObjectType = objectType;
12872 exp->__anon1.member.member = MkIdentifier(convert->convert->dataTypeString);
12873 exp->__anon1.member.memberType = 1;
12874 exp->expType = convert->resultType ? convert->resultType : convert->convert->dataType;
12875 exp->needCast = 1;
12876 if(exp->expType)
12877 exp->expType->refCount++;
12878 ApplyAnyObjectLogic(exp->__anon1.member.exp);
12879 }
12880 else
12881 {
12882 {
12883 exp->type = 8;
12884 exp->addedThis = 1;
12885 exp->__anon1.member.exp = newExp;
12886 if(newExp->expType && newExp->expType->kind == 8 && newExp->expType->__anon1._class && newExp->expType->__anon1._class->__anon1.registered && newExp->expType->__anon1._class->__anon1.registered->type == 5)
12887 {
12888 newExp->byReference = 1;
12889 }
12890 FreeType(exp->__anon1.member.exp->expType);
12891 exp->__anon1.member.exp->expType = (((void *)0));
12892 if(convert->convert->dataType)
12893 {
12894 exp->__anon1.member.exp->expType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
12895 CopyTypeInto(exp->__anon1.member.exp->expType, convert->convert->dataType);
12896 exp->__anon1.member.exp->expType->refCount = 1;
12897 exp->__anon1.member.exp->expType->classObjectType = objectType;
12898 ApplyAnyObjectLogic(exp->__anon1.member.exp);
12899 }
12900 exp->__anon1.member.member = MkIdentifier(convert->convert->_class->fullName);
12901 exp->__anon1.member.memberType = 4;
12902 exp->expType = convert->resultType ? convert->resultType : MkClassType(convert->convert->_class->fullName);
12903 exp->needCast = 1;
12904 if(convert->resultType)
12905 convert->resultType->refCount++;
12906 }
12907 }
12908 }
12909 else
12910 {
12911 FreeType(exp->expType);
12912 if(convert->isGet)
12913 {
12914 exp->expType = convert->resultType ? convert->resultType : convert->convert->dataType;
12915 if(exp->destType->casted)
12916 exp->needCast = 1;
12917 if(exp->expType)
12918 exp->expType->refCount++;
12919 }
12920 else
12921 {
12922 exp->expType = convert->resultType ? convert->resultType : MkClassType(convert->convert->_class->fullName);
12923 if(exp->destType->casted)
12924 exp->needCast = 1;
12925 if(convert->resultType)
12926 convert->resultType->refCount++;
12927 }
12928 }
12929 }
12930 if(exp->isConstant && inCompiler)
12931 ComputeExpression(exp);
12932 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&converts, (void *)(FreeConvert));
12933 }
12934 if(!result && exp->expType && converts.count)
12935 {
12936 result = MatchTypes(exp->expType, exp->destType, (((void *)0)), (((void *)0)), (((void *)0)), 1, 1, 0, 0, warnConst);
12937 }
12938 if(!result && exp->expType && exp->destType)
12939 {
12940 if((exp->destType->kind == 8 && exp->expType->kind == 13 && exp->expType->__anon1.type->kind == 8 && exp->expType->__anon1.type->__anon1._class == exp->destType->__anon1._class && exp->destType->__anon1._class->__anon1.registered && exp->destType->__anon1._class->__anon1.registered->type == 1) || (exp->expType->kind == 8 && exp->destType->kind == 13 && exp->destType->__anon1.type->kind == 8 && exp->destType->__anon1.type->__anon1._class == exp->expType->__anon1._class && exp->expType->__anon1._class->__anon1.registered && exp->expType->__anon1._class->__anon1.registered->type == 1))
12941 result = 1;
12942 }
12943 }
12944 return result;
12945 }
12946
12947 extern struct Expression * GetNonBracketsExp(struct Expression * exp);
12948
12949 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
12950
12951 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
12952
12953 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
12954
12955 unsigned int __ecereProp_Type_Get_isPointerType(struct Type * this);
12956
12957 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_Type_isPointerType;
12958
12959 void CheckTemplateTypes(struct Expression * exp)
12960 {
12961 struct Expression * nbExp = GetNonBracketsExp(exp);
12962
12963 if(exp->destType && exp->destType->passAsTemplate && exp->expType && exp->expType->kind != 20 && !exp->expType->passAsTemplate && (nbExp == exp || nbExp->type != 11))
12964 {
12965 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
12966 struct Context * context;
12967
12968 *newExp = *exp;
12969 if(exp->destType)
12970 exp->destType->refCount++;
12971 if(exp->expType)
12972 exp->expType->refCount++;
12973 newExp->prev = (((void *)0));
12974 newExp->next = (((void *)0));
12975 switch(exp->expType->kind)
12976 {
12977 case 7:
12978 if(exp->destType->classObjectType)
12979 {
12980 if(exp->destType)
12981 exp->destType->refCount--;
12982 if(exp->expType)
12983 exp->expType->refCount--;
12984 ((newExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newExp)) : 0), newExp = 0);
12985 }
12986 else
12987 {
12988 struct __ecereNameSpace__ecere__sys__OldList * specs;
12989 struct __ecereNameSpace__ecere__sys__OldList * unionDefs = MkList();
12990 struct __ecereNameSpace__ecere__sys__OldList * statements = MkList();
12991
12992 context = PushContext();
12993 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifier(DOUBLE)), MkListOne(MkDeclaratorIdentifier(MkIdentifier("d"))), (((void *)0)))));
12994 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifierName("uint64")), MkListOne(MkDeclaratorIdentifier(MkIdentifier("i"))), (((void *)0)))));
12995 specs = MkListOne(MkStructOrUnion(4, (((void *)0)), unionDefs));
12996 exp->type = 23;
12997 exp->__anon1.compound = MkCompoundStmt(MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internal_union")), (((void *)0)))))), statements);
12998 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("d")), '=', newExp))));
12999 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("i")))));
13000 exp->__anon1.compound->__anon1.compound.context = context;
13001 PopContext(context);
13002 }
13003 break;
13004 default:
13005 exp->type = 11;
13006 exp->__anon1.cast.typeName = MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0)));
13007 if(__ecereProp_Type_Get_isPointerType(exp->expType))
13008 exp->__anon1.cast.exp = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uintptr")), (((void *)0))), MkExpBrackets(MkListOne(newExp)));
13009 else
13010 exp->__anon1.cast.exp = MkExpBrackets(MkListOne(newExp));
13011 exp->needCast = 1;
13012 break;
13013 }
13014 }
13015 else if(exp->expType && exp->expType->passAsTemplate && exp->destType && ((unsigned int)((exp->usage & 0x1) >> 0)) && exp->destType->kind != 20 && !exp->destType->passAsTemplate)
13016 {
13017 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
13018 struct Context * context;
13019
13020 *newExp = *exp;
13021 if(exp->destType)
13022 exp->destType->refCount++;
13023 if(exp->expType)
13024 exp->expType->refCount++;
13025 newExp->prev = (((void *)0));
13026 newExp->next = (((void *)0));
13027 switch(exp->expType->kind)
13028 {
13029 case 7:
13030 if(exp->destType->classObjectType)
13031 {
13032 if(exp->destType)
13033 exp->destType->refCount--;
13034 if(exp->expType)
13035 exp->expType->refCount--;
13036 ((newExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newExp)) : 0), newExp = 0);
13037 }
13038 else
13039 {
13040 struct __ecereNameSpace__ecere__sys__OldList * specs;
13041 struct __ecereNameSpace__ecere__sys__OldList * unionDefs = MkList();
13042 struct __ecereNameSpace__ecere__sys__OldList * statements = MkList();
13043
13044 context = PushContext();
13045 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifier(DOUBLE)), MkListOne(MkDeclaratorIdentifier(MkIdentifier("d"))), (((void *)0)))));
13046 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifierName("uint64")), MkListOne(MkDeclaratorIdentifier(MkIdentifier("i"))), (((void *)0)))));
13047 specs = MkListOne(MkStructOrUnion(4, (((void *)0)), unionDefs));
13048 exp->type = 23;
13049 exp->__anon1.compound = MkCompoundStmt(MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internal_union")), (((void *)0)))))), statements);
13050 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("i")), '=', newExp))));
13051 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("d")))));
13052 exp->__anon1.compound->__anon1.compound.context = context;
13053 PopContext(context);
13054 }
13055 break;
13056 case 8:
13057 {
13058 if(exp->expType->__anon1._class && exp->expType->__anon1._class->__anon1.registered && exp->expType->__anon1._class->__anon1.registered->type == 1)
13059 {
13060 exp->type = 5;
13061 if(__ecereProp_Type_Get_isPointerType(exp->expType))
13062 newExp = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uintptr")), (((void *)0))), newExp);
13063 exp->__anon1.list = MkListOne(MkExpOp((((void *)0)), '*', MkExpCast(MkTypeName(MkListOne(MkSpecifierName(exp->expType->__anon1._class->string)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), newExp)));
13064 ProcessExpressionType((*exp->__anon1.list).first);
13065 break;
13066 }
13067 else
13068 {
13069 exp->type = 5;
13070 if(__ecereProp_Type_Get_isPointerType(exp->expType))
13071 {
13072 exp->needTemplateCast = 2;
13073 newExp->needCast = 1;
13074 newExp->needTemplateCast = 2;
13075 newExp = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uintptr")), (((void *)0))), newExp);
13076 }
13077 exp->__anon1.list = MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName(exp->expType->__anon1._class->string)), (((void *)0))), newExp));
13078 exp->needTemplateCast = 2;
13079 newExp->needCast = 1;
13080 newExp->needTemplateCast = 2;
13081 ProcessExpressionType((*exp->__anon1.list).first);
13082 break;
13083 }
13084 }
13085 default:
13086 {
13087 if(exp->expType->kind == 20)
13088 {
13089 struct Type * type = ProcessTemplateParameterType(exp->expType->__anon1.templateParameter);
13090
13091 if(type)
13092 {
13093 FreeType(exp->destType);
13094 FreeType(exp->expType);
13095 ((newExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newExp)) : 0), newExp = 0);
13096 break;
13097 }
13098 }
13099 if(newExp->type == 8 && newExp->__anon1.member.memberType == 3)
13100 {
13101 exp->type = 4;
13102 exp->__anon1.op.op = '*';
13103 exp->__anon1.op.exp1 = (((void *)0));
13104 exp->__anon1.op.exp2 = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpBrackets(MkListOne(MkExpOp((((void *)0)), '&', newExp))));
13105 }
13106 else
13107 {
13108 char typeString[1024];
13109 struct Declarator * decl;
13110 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
13111
13112 typeString[0] = '\0';
13113 PrintType(exp->expType, typeString, 0, 0);
13114 decl = SpecDeclFromString(typeString, specs, (((void *)0)));
13115 exp->type = 11;
13116 exp->__anon1.cast.typeName = MkTypeName(specs, decl);
13117 exp->__anon1.cast.exp = MkExpBrackets(MkListOne(newExp));
13118 exp->__anon1.cast.exp->needCast = 1;
13119 }
13120 break;
13121 }
13122 }
13123 }
13124 }
13125
13126 extern int strncmp(const char * , const char * , size_t n);
13127
13128 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindPrefix(struct __ecereNameSpace__ecere__sys__BinaryTree * this, const char *  key);
13129
13130 static struct Symbol * ScanWithNameSpace(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, const char * nameSpace, const char * name)
13131 {
13132 int nsLen = strlen(nameSpace);
13133 struct Symbol * symbol;
13134
13135 for(symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindPrefix(tree, nameSpace); symbol; symbol = (struct Symbol *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)symbol)))
13136 {
13137 char * s = symbol->string;
13138
13139 if(!strncmp(s, nameSpace, nsLen))
13140 {
13141 int c;
13142 char * namePart;
13143
13144 for(c = strlen(s) - 1; c >= 0; c--)
13145 if(s[c] == ':')
13146 break;
13147 namePart = s + c + 1;
13148 if(!strcmp(namePart, name))
13149 {
13150 return symbol;
13151 }
13152 }
13153 else
13154 break;
13155 }
13156 return (((void *)0));
13157 }
13158
13159 static struct Symbol * FindWithNameSpace(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, const char * name)
13160 {
13161 int c;
13162 char nameSpace[1024];
13163 const char * namePart;
13164 unsigned int gotColon = 0;
13165
13166 nameSpace[0] = '\0';
13167 for(c = strlen(name) - 1; c >= 0; c--)
13168 if(name[c] == ':')
13169 {
13170 gotColon = 1;
13171 break;
13172 }
13173 namePart = name + c + 1;
13174 while(c >= 0 && name[c] == ':')
13175 c--;
13176 if(c >= 0)
13177 {
13178 struct Symbol * symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(tree, name);
13179
13180 if(symbol)
13181 return symbol;
13182 memcpy(nameSpace, name, c + 1);
13183 nameSpace[c + 1] = (char)0;
13184 return ScanWithNameSpace(tree, nameSpace, namePart);
13185 }
13186 else if(gotColon)
13187 {
13188 struct Symbol * symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(tree, namePart);
13189
13190 return symbol;
13191 }
13192 else
13193 {
13194 struct Symbol * symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(tree, namePart);
13195
13196 if(symbol)
13197 return symbol;
13198 return ScanWithNameSpace(tree, "", namePart);
13199 }
13200 return (((void *)0));
13201 }
13202
13203 static void ProcessDeclaration(struct Declaration * decl);
13204
13205 struct Symbol * FindSymbol(const char * name, struct Context * startContext, struct Context * endContext, unsigned int isStruct, unsigned int globalNameSpace)
13206 {
13207 struct Context * ctx;
13208 struct Symbol * symbol = (((void *)0));
13209
13210 for(ctx = startContext; ctx && !symbol; ctx = ctx->parent)
13211 {
13212 if(ctx == globalContext && !globalNameSpace && ctx->hasNameSpace)
13213 {
13214 symbol = (((void *)0));
13215 if(thisNameSpace)
13216 {
13217 char curName[1024];
13218
13219 strcpy(curName, thisNameSpace);
13220 strcat(curName, "::");
13221 strcat(curName, name);
13222 symbol = FindWithNameSpace(isStruct ? &ctx->structSymbols : &ctx->symbols, curName);
13223 }
13224 if(!symbol)
13225 symbol = FindWithNameSpace(isStruct ? &ctx->structSymbols : &ctx->symbols, name);
13226 }
13227 else
13228 symbol = (struct Symbol *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString((isStruct ? &ctx->structSymbols : &ctx->symbols), name);
13229 if(symbol || ctx == endContext)
13230 break;
13231 }
13232 if(inCompiler && curExternal && symbol && ctx == globalContext && curExternal->symbol && symbol->id > curExternal->symbol->idCode && symbol->__anon2.__anon1.pointerExternal)
13233 {
13234 if(symbol->__anon2.__anon1.pointerExternal->type == 0)
13235 {
13236 struct FunctionDefinition * function = symbol->__anon2.__anon1.pointerExternal->__anon1.function;
13237 struct Context * tmpContext = curContext;
13238
13239 curContext = (((void *)0));
13240 symbol->__anon2.__anon1.pointerExternal = MkExternalDeclaration(MkDeclaration(CopyList(function->specifiers, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(CopyDeclarator(function->declarator), (((void *)0))))));
13241 curContext = tmpContext;
13242 symbol->__anon2.__anon1.pointerExternal->symbol = symbol;
13243 DeclareType(symbol->type, 1, 1);
13244 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, symbol->__anon2.__anon1.pointerExternal);
13245 symbol->id = curExternal->symbol->idCode;
13246 }
13247 else if(symbol->__anon2.__anon1.pointerExternal->type == 1 && curExternal->symbol->idCode < symbol->__anon2.__anon1.pointerExternal->symbol->id)
13248 {
13249 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), symbol->__anon2.__anon1.pointerExternal, curExternal->prev);
13250 symbol->id = curExternal->symbol->idCode;
13251 }
13252 }
13253 return symbol;
13254 }
13255
13256 static void GetTypeSpecs(struct Type * type, struct __ecereNameSpace__ecere__sys__OldList * specs)
13257 {
13258 if(!type->isSigned && type->kind != 22 && type->kind != 23)
13259 ListAdd(specs, MkSpecifier(UNSIGNED));
13260 switch(type->kind)
13261 {
13262 case 8:
13263 {
13264 if(type->__anon1._class->__anon1.registered)
13265 {
13266 if(!type->__anon1._class->__anon1.registered->dataType)
13267 type->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type->__anon1._class->__anon1.registered->dataTypeString, 0);
13268 GetTypeSpecs(type->__anon1._class->__anon1.registered->dataType, specs);
13269 }
13270 break;
13271 }
13272 case 7:
13273 ListAdd(specs, MkSpecifier(DOUBLE));
13274 break;
13275 case 6:
13276 ListAdd(specs, MkSpecifier(FLOAT));
13277 break;
13278 case 1:
13279 ListAdd(specs, MkSpecifier(CHAR));
13280 break;
13281 case 24:
13282 ListAdd(specs, MkSpecifier(_BOOL));
13283 break;
13284 case 2:
13285 ListAdd(specs, MkSpecifier(SHORT));
13286 break;
13287 case 4:
13288 ListAdd(specs, MkSpecifier(INT64));
13289 break;
13290 case 22:
13291 ListAdd(specs, MkSpecifierName(type->isSigned ? "intptr" : "uintptr"));
13292 break;
13293 case 23:
13294 ListAdd(specs, MkSpecifierName(type->isSigned ? "intsize" : "uintsize"));
13295 break;
13296 case 3:
13297 default:
13298 ListAdd(specs, MkSpecifier(INT));
13299 break;
13300 }
13301 }
13302
13303 static void PrintArraySize(struct Type * arrayType, char * string)
13304 {
13305 char size[256];
13306
13307 size[0] = '\0';
13308 strcat(size, "[");
13309 if(arrayType->__anon1.__anon4.enumClass)
13310 strcat(size, arrayType->__anon1.__anon4.enumClass->string);
13311 else if(arrayType->__anon1.__anon4.arraySizeExp)
13312 PrintExpression(arrayType->__anon1.__anon4.arraySizeExp, size);
13313 strcat(size, "]");
13314 strcat(string, size);
13315 }
13316
13317 static void PrintTypeSpecs(struct Type * type, char * string, unsigned int fullName, unsigned int printConst)
13318 {
13319 if(type)
13320 {
13321 if(printConst && type->constant)
13322 strcat(string, "const ");
13323 switch(type->kind)
13324 {
13325 case 8:
13326 {
13327 struct Symbol * c = type->__anon1._class;
13328
13329 if(type->classObjectType == 2)
13330 strcat(string, "typed_object");
13331 else if(type->classObjectType == 3)
13332 strcat(string, "any_object");
13333 else
13334 {
13335 if(c && c->string)
13336 strcat(string, (fullName || !c->__anon1.registered) ? c->string : c->__anon1.registered->name);
13337 }
13338 if(type->byReference)
13339 strcat(string, " &");
13340 break;
13341 }
13342 case 0:
13343 strcat(string, "void");
13344 break;
13345 case 3:
13346 strcat(string, type->isSigned ? "int" : "uint");
13347 break;
13348 case 4:
13349 strcat(string, type->isSigned ? "int64" : "uint64");
13350 break;
13351 case 22:
13352 strcat(string, type->isSigned ? "intptr" : "uintptr");
13353 break;
13354 case 23:
13355 strcat(string, type->isSigned ? "intsize" : "uintsize");
13356 break;
13357 case 1:
13358 strcat(string, type->isSigned ? "char" : "byte");
13359 break;
13360 case 24:
13361 strcat(string, "_Bool");
13362 break;
13363 case 2:
13364 strcat(string, type->isSigned ? "short" : "uint16");
13365 break;
13366 case 6:
13367 strcat(string, "float");
13368 break;
13369 case 7:
13370 strcat(string, "double");
13371 break;
13372 case 9:
13373 if(type->__anon1.__anon1.enumName)
13374 {
13375 strcat(string, "struct ");
13376 strcat(string, type->__anon1.__anon1.enumName);
13377 }
13378 else if(type->typeName)
13379 strcat(string, type->typeName);
13380 else
13381 {
13382 struct Type * member;
13383
13384 strcat(string, "struct { ");
13385 for(member = type->__anon1.__anon1.members.first; member; member = member->next)
13386 {
13387 PrintType(member, string, 1, fullName);
13388 strcat(string, "; ");
13389 }
13390 strcat(string, "}");
13391 }
13392 break;
13393 case 10:
13394 if(type->__anon1.__anon1.enumName)
13395 {
13396 strcat(string, "union ");
13397 strcat(string, type->__anon1.__anon1.enumName);
13398 }
13399 else if(type->typeName)
13400 strcat(string, type->typeName);
13401 else
13402 {
13403 strcat(string, "union ");
13404 strcat(string, "(unnamed)");
13405 }
13406 break;
13407 case 15:
13408 if(type->__anon1.__anon1.enumName)
13409 {
13410 strcat(string, "enum ");
13411 strcat(string, type->__anon1.__anon1.enumName);
13412 }
13413 else if(type->typeName)
13414 strcat(string, type->typeName);
13415 else
13416 strcat(string, "int");
13417 break;
13418 case 14:
13419 strcat(string, "...");
13420 break;
13421 case 19:
13422 strcat(string, "subclass(");
13423 strcat(string, type->__anon1._class ? type->__anon1._class->string : "int");
13424 strcat(string, ")");
13425 break;
13426 case 20:
13427 strcat(string, type->__anon1.templateParameter->identifier->string);
13428 break;
13429 case 21:
13430 strcat(string, "thisclass");
13431 break;
13432 case 17:
13433 strcat(string, "__builtin_va_list");
13434 break;
13435 }
13436 }
13437 }
13438
13439 extern char *  __ecereNameSpace__ecere__sys__RSearchString(const char *  buffer, const char *  subStr, int maxLen, unsigned int matchCase, unsigned int matchWord);
13440
13441 static void PrintName(struct Type * type, char * string, unsigned int fullName)
13442 {
13443 if(type->name && type->name[0])
13444 {
13445 if(fullName)
13446 strcat(string, type->name);
13447 else
13448 {
13449 char * name = __ecereNameSpace__ecere__sys__RSearchString(type->name, "::", strlen(type->name), 1, 0);
13450
13451 if(name)
13452 name += 2;
13453 else
13454 name = type->name;
13455 strcat(string, name);
13456 }
13457 }
13458 }
13459
13460 static void PrintAttribs(struct Type * type, char * string)
13461 {
13462 if(type)
13463 {
13464 if(type->dllExport)
13465 strcat(string, "dllexport ");
13466 if(type->attrStdcall)
13467 strcat(string, "stdcall ");
13468 }
13469 }
13470
13471 static void PrePrintType(struct Type * type, char * string, unsigned int fullName, struct Type * parentType, unsigned int printConst)
13472 {
13473 if(type->kind == 12 || type->kind == 13 || type->kind == 11 || type->kind == 16)
13474 {
13475 if((type->kind == 11 || type->kind == 16) && (!parentType || parentType->kind != 13))
13476 PrintAttribs(type, string);
13477 if(printConst && type->constant && (type->kind == 11 || type->kind == 16))
13478 strcat(string, " const");
13479 PrePrintType(type->kind == 16 ? type->__anon1.__anon3.method->dataType : type->__anon1.type, string, fullName, type, printConst);
13480 if(type->kind == 13 && (type->__anon1.type->kind == 12 || type->__anon1.type->kind == 11 || type->__anon1.type->kind == 16))
13481 strcat(string, " (");
13482 if(type->kind == 13)
13483 {
13484 if(type->__anon1.type->kind == 11 || type->__anon1.type->kind == 16)
13485 PrintAttribs(type->__anon1.type, string);
13486 }
13487 if(type->kind == 13)
13488 {
13489 if(type->__anon1.type->kind == 11 || type->__anon1.type->kind == 16 || type->__anon1.type->kind == 12)
13490 strcat(string, "*");
13491 else
13492 strcat(string, " *");
13493 }
13494 if(printConst && type->constant && type->kind == 13)
13495 strcat(string, " const");
13496 }
13497 else
13498 PrintTypeSpecs(type, string, fullName, printConst);
13499 }
13500
13501 static void PostPrintType(struct Type * type, char * string, unsigned int fullName)
13502 {
13503 if(type->kind == 13 && (type->__anon1.type->kind == 12 || type->__anon1.type->kind == 11 || type->__anon1.type->kind == 16))
13504 strcat(string, ")");
13505 if(type->kind == 12)
13506 PrintArraySize(type, string);
13507 else if(type->kind == 11)
13508 {
13509 struct Type * param;
13510
13511 strcat(string, "(");
13512 for(param = type->__anon1.__anon2.params.first; param; param = param->next)
13513 {
13514 PrintType(param, string, 1, fullName);
13515 if(param->next)
13516 strcat(string, ", ");
13517 }
13518 strcat(string, ")");
13519 }
13520 if(type->kind == 12 || type->kind == 13 || type->kind == 11 || type->kind == 16)
13521 PostPrintType(type->kind == 16 ? type->__anon1.__anon3.method->dataType : type->__anon1.type, string, fullName);
13522 }
13523
13524 static void _PrintType(struct Type * type, char * string, unsigned int printName, unsigned int fullName, unsigned int printConst)
13525 {
13526 PrePrintType(type, string, fullName, (((void *)0)), printConst);
13527 if(type->__anon1.__anon2.thisClass || (printName && type->name && type->name[0]))
13528 strcat(string, " ");
13529 if((type->__anon1.__anon2.thisClass || type->__anon1.__anon2.staticMethod))
13530 {
13531 struct Symbol * _class = type->__anon1.__anon2.thisClass;
13532
13533 if((type->classObjectType == 2 || type->classObjectType == 1) || (_class && !strcmp(_class->string, "class")))
13534 {
13535 if(type->classObjectType == 1)
13536 strcat(string, "class");
13537 else
13538 strcat(string, type->byReference ? "typed_object&" : "typed_object");
13539 }
13540 else if(_class && _class->string)
13541 {
13542 char * s = _class->string;
13543
13544 if(fullName)
13545 strcat(string, s);
13546 else
13547 {
13548 char * name = __ecereNameSpace__ecere__sys__RSearchString(s, "::", strlen(s), 1, 0);
13549
13550 if(name)
13551 name += 2;
13552 else
13553 name = s;
13554 strcat(string, name);
13555 }
13556 }
13557 strcat(string, "::");
13558 }
13559 if(printName && type->name)
13560 PrintName(type, string, fullName);
13561 PostPrintType(type, string, fullName);
13562 if(type->bitFieldCount)
13563 {
13564 char count[100];
13565
13566 sprintf(count, ":%d", type->bitFieldCount);
13567 strcat(string, count);
13568 }
13569 }
13570
13571 void PrintType(struct Type * type, char * string, unsigned int printName, unsigned int fullName)
13572 {
13573 _PrintType(type, string, printName, fullName, 1);
13574 }
13575
13576 void PrintTypeNoConst(struct Type * type, char * string, unsigned int printName, unsigned int fullName)
13577 {
13578 _PrintType(type, string, printName, fullName, 0);
13579 }
13580
13581 static struct Type * FindMember(struct Type * type, char * string)
13582 {
13583 struct Type * memberType;
13584
13585 for(memberType = type->__anon1.__anon1.members.first; memberType; memberType = memberType->next)
13586 {
13587 if(!memberType->name)
13588 {
13589 struct Type * subType = FindMember(memberType, string);
13590
13591 if(subType)
13592 return subType;
13593 }
13594 else if(!strcmp(memberType->name, string))
13595 return memberType;
13596 }
13597 return (((void *)0));
13598 }
13599
13600 struct Type * FindMemberAndOffset(struct Type * type, char * string, unsigned int * offset)
13601 {
13602 struct Type * memberType;
13603
13604 for(memberType = type->__anon1.__anon1.members.first; memberType; memberType = memberType->next)
13605 {
13606 if(!memberType->name)
13607 {
13608 struct Type * subType = FindMember(memberType, string);
13609
13610 if(subType)
13611 {
13612 *offset += memberType->offset;
13613 return subType;
13614 }
13615 }
13616 else if(!strcmp(memberType->name, string))
13617 {
13618 *offset += memberType->offset;
13619 return memberType;
13620 }
13621 }
13622 return (((void *)0));
13623 }
13624
13625 extern unsigned int parseError;
13626
13627 unsigned int GetParseError()
13628 {
13629 return parseError;
13630 }
13631
13632 extern struct __ecereNameSpace__ecere__com__Instance * fileInput;
13633
13634 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Write;
13635
13636 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__File;
13637
13638 struct Expression * ParseExpressionString(char * expression)
13639 {
13640 parseError = 0;
13641 fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
13642 ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  buffer, unsigned int size, unsigned int count))__extension__ ({
13643 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
13644
13645 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
13646 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Write])(fileInput, expression, 1, strlen(expression));
13647 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))__extension__ ({
13648 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
13649
13650 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
13651 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek])(fileInput, 0, 0);
13652 echoOn = 0;
13653 parsedExpression = (((void *)0));
13654 resetScanner();
13655 expression_yyparse();
13656 (__ecereNameSpace__ecere__com__eInstance_DecRef(fileInput), fileInput = 0);
13657 return parsedExpression;
13658 }
13659
13660 extern char *  QMkString(const char *  source);
13661
13662 static unsigned int ResolveIdWithClass(struct Expression * exp, struct __ecereNameSpace__ecere__com__Class * _class, unsigned int skipIDClassCheck)
13663 {
13664 struct Identifier * id = exp->__anon1.__anon1.identifier;
13665 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
13666 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
13667 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
13668 struct __ecereNameSpace__ecere__com__ClassProperty * classProp = (((void *)0));
13669
13670 if(_class && _class->type == 4)
13671 {
13672 struct __ecereNameSpace__ecere__sys__NamedLink64 * value = (((void *)0));
13673 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
13674
13675 if(enumClass)
13676 {
13677 struct __ecereNameSpace__ecere__com__Class * baseClass;
13678
13679 for(baseClass = _class; baseClass && baseClass->type == 4; baseClass = baseClass->base)
13680 {
13681 struct __ecereNameSpace__ecere__com__EnumClassData * e = (baseClass ? ((void *)(((char *)baseClass->data) + enumClass->offsetClass)) : (((void *)0)));
13682
13683 for(value = e->values.first; value; value = value->next)
13684 {
13685 if(!strcmp(value->name, id->string))
13686 break;
13687 }
13688 if(value)
13689 {
13690 char constant[256];
13691
13692 FreeExpContents(exp);
13693 exp->type = 2;
13694 exp->isConstant = 1;
13695 if(!strcmp(baseClass->dataTypeString, "int") || !strcmp(baseClass->dataTypeString, "int64") || !strcmp(baseClass->dataTypeString, "char") || !strcmp(baseClass->dataTypeString, "short"))
13696 sprintf(constant, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), value->data);
13697 else
13698 sprintf(constant, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), value->data);
13699 exp->__anon1.__anon1.constant = __ecereNameSpace__ecere__sys__CopyString(constant);
13700 exp->expType = MkClassType(baseClass->fullName);
13701 break;
13702 }
13703 }
13704 }
13705 if(value)
13706 return 1;
13707 }
13708 if((method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, id->string, privateModule)))
13709 {
13710 ProcessMethodType(method);
13711 exp->expType = __extension__ ({
13712 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
13713
13714 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 16, __ecereInstance1->__anon1.__anon3.method = method, __ecereInstance1->__anon1.__anon3.methodClass = (skipIDClassCheck || (id && id->_class)) ? _class : (((void *)0)), __ecereInstance1;
13715 });
13716 return 1;
13717 }
13718 else if((prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, privateModule)))
13719 {
13720 if(!prop->dataType)
13721 ProcessPropertyType(prop);
13722 exp->expType = prop->dataType;
13723 if(prop->dataType)
13724 prop->dataType->refCount++;
13725 return 1;
13726 }
13727 else if((member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, id->string, privateModule, (((void *)0)), (((void *)0)))))
13728 {
13729 if(!member->dataType)
13730 member->dataType = ProcessTypeString(member->dataTypeString, 0);
13731 exp->expType = member->dataType;
13732 if(member->dataType)
13733 member->dataType->refCount++;
13734 return 1;
13735 }
13736 else if((classProp = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, id->string)))
13737 {
13738 if(!classProp->dataType)
13739 classProp->dataType = ProcessTypeString(classProp->dataTypeString, 0);
13740 if(classProp->constant)
13741 {
13742 FreeExpContents(exp);
13743 exp->isConstant = 1;
13744 if(classProp->dataType->kind == 13 && classProp->dataType->__anon1.type->kind == 1)
13745 {
13746 exp->type = 3;
13747 exp->__anon1.__anon1.constant = QMkString((char *)(uintptr_t)classProp->Get(_class));
13748 }
13749 else
13750 {
13751 char constant[256];
13752
13753 exp->type = 2;
13754 sprintf(constant, "%d", (int)classProp->Get(_class));
13755 exp->__anon1.__anon1.constant = __ecereNameSpace__ecere__sys__CopyString(constant);
13756 }
13757 }
13758 else
13759 {
13760 }
13761 exp->expType = classProp->dataType;
13762 if(classProp->dataType)
13763 classProp->dataType->refCount++;
13764 return 1;
13765 }
13766 return 0;
13767 }
13768
13769 static struct GlobalData * ScanGlobalData(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace, char * name)
13770 {
13771 struct __ecereNameSpace__ecere__sys__BinaryTree * tree = &nameSpace->functions;
13772 struct GlobalData * data = (struct GlobalData *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString((&*tree), name);
13773 struct __ecereNameSpace__ecere__com__NameSpace * child;
13774
13775 if(!data)
13776 {
13777 for(child = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&nameSpace->nameSpaces); child; child = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)child)))
13778 {
13779 data = ScanGlobalData(child, name);
13780 if(data)
13781 break;
13782 }
13783 }
13784 return data;
13785 }
13786
13787 extern struct __ecereNameSpace__ecere__com__NameSpace *  globalData;
13788
13789 extern char *  strncpy(char * , const char * , size_t n);
13790
13791 static struct GlobalData * FindGlobalData(char * name)
13792 {
13793 int start = 0, c;
13794 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
13795
13796 nameSpace = globalData;
13797 for(c = 0; name[c]; c++)
13798 {
13799 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
13800 {
13801 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
13802 char * spaceName = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (c - start + 1));
13803
13804 strncpy(spaceName, name + start, c - start);
13805 spaceName[c - start] = '\0';
13806 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
13807 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
13808 if(!newSpace)
13809 return (((void *)0));
13810 nameSpace = newSpace;
13811 if(name[c] == ':')
13812 c++;
13813 start = c + 1;
13814 }
13815 }
13816 if(c - start)
13817 {
13818 return ScanGlobalData(nameSpace, name + start);
13819 }
13820 return (((void *)0));
13821 }
13822
13823 static int definedExpStackPos;
13824
13825 static void * definedExpStack[512];
13826
13827 void ReplaceExpContents(struct Expression * checkedExp, struct Expression * newExp)
13828 {
13829 struct Expression * prev = checkedExp->prev, * next = checkedExp->next;
13830
13831 FreeExpContents(checkedExp);
13832 FreeType(checkedExp->expType);
13833 FreeType(checkedExp->destType);
13834 *checkedExp = *newExp;
13835 ((newExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newExp)) : 0), newExp = 0);
13836 checkedExp->prev = prev;
13837 checkedExp->next = next;
13838 }
13839
13840 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
13841
13842 extern int printf(const char * , ...);
13843
13844 void __ecereMethod_Expression_Clear();
13845
13846 void ApplyAnyObjectLogic(struct Expression * e)
13847 {
13848 struct Type * destType = e->destType;
13849
13850 if(destType && (destType->classObjectType == 3))
13851 {
13852 if(e && e->expType)
13853 {
13854 struct Type * type = e->expType;
13855 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
13856
13857 if(type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered)
13858 {
13859 _class = type->__anon1._class->__anon1.registered;
13860 }
13861 else if(type->kind == 19)
13862 {
13863 _class = FindClass("ecere::com::Class")->__anon1.registered;
13864 }
13865 else
13866 {
13867 char string[1024] = "";
13868 struct Symbol * classSym;
13869
13870 PrintTypeNoConst(type, string, 0, 1);
13871 classSym = FindClass(string);
13872 if(classSym)
13873 _class = classSym->__anon1.registered;
13874 }
13875 if((_class && (_class->type == 4 || _class->type == 3 || _class->type == 2 || _class->type == 1000) && strcmp(_class->fullName, "class") && strcmp(_class->fullName, "uintptr") && strcmp(_class->fullName, "intptr")) || (!e->expType->classObjectType && (((type->kind != 13 && type->kind != 22 && type->kind != 19 && (type->kind != 8 || !type->__anon1._class || !type->__anon1._class->__anon1.registered || type->__anon1._class->__anon1.registered->type == 1))) || destType->byReference)))
13876 {
13877 if(!_class || strcmp(_class->fullName, "char *"))
13878 {
13879 struct Expression * checkedExp = e, * newExp;
13880
13881 while(((checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23) && checkedExp->__anon1.list) || checkedExp->type == 11)
13882 {
13883 if(checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23)
13884 {
13885 if(checkedExp->type == 23)
13886 {
13887 checkedExp = (*((struct Statement *)(*checkedExp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last;
13888 }
13889 else
13890 checkedExp = (*checkedExp->__anon1.list).last;
13891 }
13892 else if(checkedExp->type == 11)
13893 checkedExp = checkedExp->__anon1.cast.exp;
13894 }
13895 if(checkedExp && checkedExp->type == 4 && checkedExp->__anon1.op.op == '*' && !checkedExp->__anon1.op.exp1)
13896 {
13897 newExp = checkedExp->__anon1.op.exp2;
13898 checkedExp->__anon1.op.exp2 = (((void *)0));
13899 FreeExpContents(checkedExp);
13900 if(e->expType && e->expType->passAsTemplate)
13901 {
13902 char size[100];
13903
13904 ComputeTypeSize(e->expType);
13905 sprintf(size, "%d", e->expType->size);
13906 newExp = MkExpBrackets(MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), newExp), '+', MkExpCall(MkExpIdentifier(MkIdentifier("__ENDIAN_PAD")), MkListOne(MkExpConstant(size))))));
13907 }
13908 ReplaceExpContents(checkedExp, newExp);
13909 e->byReference = 1;
13910 }
13911 else if(!e->byReference || (_class && _class->type == 5))
13912 {
13913 struct Expression * checkedExp;
13914
13915 {
13916 unsigned int hasAddress = e->type == 0 || (e->type == 8 && e->__anon1.member.memberType == 3) || (e->type == 9 && e->__anon1.member.memberType == 3) || (e->type == 4 && !e->__anon1.op.exp1 && e->__anon1.op.op == '*') || e->type == 6;
13917
13918 if(_class && _class->type != 5 && _class->type != 0 && _class->type != 1 && !hasAddress)
13919 {
13920 struct Context * context = PushContext();
13921 struct Declarator * decl;
13922 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
13923 char typeString[1024];
13924 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
13925
13926 typeString[0] = '\0';
13927 *newExp = *e;
13928 newExp->prev = (((void *)0));
13929 newExp->next = (((void *)0));
13930 newExp->expType = (((void *)0));
13931 PrintTypeNoConst(e->expType, typeString, 0, 1);
13932 decl = SpecDeclFromString(typeString, specs, (((void *)0)));
13933 newExp->destType = ProcessType(specs, decl);
13934 curContext = context;
13935 if(curCompound)
13936 {
13937 char name[100];
13938 struct __ecereNameSpace__ecere__sys__OldList * stmts = MkList();
13939
13940 e->type = 23;
13941 sprintf(name, "__internalValue%03X", internalValueCounter++);
13942 if(!curCompound->__anon1.compound.declarations)
13943 curCompound->__anon1.compound.declarations = MkList();
13944 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->__anon1.compound.declarations), (((void *)0)), MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(name)), (((void *)0))))));
13945 ListAdd(stmts, MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', newExp))));
13946 ListAdd(stmts, MkExpressionStmt(MkListOne(MkExpIdentifier(MkIdentifier(name)))));
13947 e->__anon1.compound = MkCompoundStmt((((void *)0)), stmts);
13948 }
13949 else
13950 printf("libec: compiler error, curCompound is null in ApplyAnyObjectLogic\n");
13951 {
13952 struct Type * type = e->destType;
13953
13954 e->destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
13955 CopyTypeInto(e->destType, type);
13956 e->destType->refCount = 1;
13957 e->destType->classObjectType = 0;
13958 FreeType(type);
13959 }
13960 e->__anon1.compound->__anon1.compound.context = context;
13961 PopContext(context);
13962 curContext = context->parent;
13963 }
13964 }
13965 checkedExp = e;
13966 while(((checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23) && checkedExp->__anon1.list) || checkedExp->type == 11)
13967 {
13968 if(checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23)
13969 {
13970 if(checkedExp->type == 23)
13971 {
13972 checkedExp = (*((struct Statement *)(*checkedExp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last;
13973 }
13974 else
13975 checkedExp = (*checkedExp->__anon1.list).last;
13976 }
13977 else if(checkedExp->type == 11)
13978 checkedExp = checkedExp->__anon1.cast.exp;
13979 }
13980 {
13981 struct Expression * operand = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
13982
13983 *operand = *checkedExp;
13984 __ecereMethod_Expression_Clear(checkedExp);
13985 checkedExp->destType = ProcessTypeString("void *", 0);
13986 checkedExp->expType = checkedExp->destType;
13987 checkedExp->destType->refCount++;
13988 checkedExp->type = 4;
13989 checkedExp->__anon1.op.op = '&';
13990 checkedExp->__anon1.op.exp1 = (((void *)0));
13991 checkedExp->__anon1.op.exp2 = operand;
13992 }
13993 }
13994 }
13995 }
13996 }
13997 }
13998 {
13999 }
14000 if((!destType || destType->kind == 14 || destType->kind == 0) && e->expType && (e->expType->classObjectType == 3 || e->expType->classObjectType == 2) && (e->expType->byReference || (e->expType->kind == 8 && e->expType->__anon1._class && e->expType->__anon1._class->__anon1.registered && (e->expType->__anon1._class->__anon1.registered->type == 2 || e->expType->__anon1._class->__anon1.registered->type == 4 || e->expType->__anon1._class->__anon1.registered->type == 3))))
14001 {
14002 if(e->expType->classObjectType && destType && destType->classObjectType)
14003 {
14004 return ;
14005 }
14006 else
14007 {
14008 struct Expression * thisExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
14009
14010 *thisExp = *e;
14011 thisExp->prev = (((void *)0));
14012 thisExp->next = (((void *)0));
14013 __ecereMethod_Expression_Clear(e);
14014 e->type = 5;
14015 e->__anon1.list = MkListOne(MkExpOp((((void *)0)), '*', thisExp->type == 0 ? thisExp : MkExpBrackets(MkListOne(thisExp))));
14016 if(thisExp->expType->kind == 8 && thisExp->expType->__anon1._class && thisExp->expType->__anon1._class->__anon1.registered && thisExp->expType->__anon1._class->__anon1.registered->type == 5)
14017 ((struct Expression *)(*e->__anon1.list).first)->byReference = 1;
14018 {
14019 e->expType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14020 CopyTypeInto(e->expType, thisExp->expType);
14021 e->expType->byReference = 0;
14022 e->expType->refCount = 1;
14023 if(e->expType->kind == 8 && e->expType->__anon1._class && e->expType->__anon1._class->__anon1.registered && (e->expType->__anon1._class->__anon1.registered->type == 2 || e->expType->__anon1._class->__anon1.registered->type == 4 || e->expType->__anon1._class->__anon1.registered->type == 3))
14024 {
14025 e->expType->classObjectType = 0;
14026 }
14027 }
14028 }
14029 }
14030 else if(destType && e->expType && (e->expType->classObjectType == 3 || e->expType->classObjectType == 2) && !destType->classObjectType && destType->kind != 0)
14031 {
14032 if(destType->kind == 14)
14033 {
14034 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unspecified type\n", (((void *)0))));
14035 }
14036 else if(!(destType->truth && e->expType->kind == 8 && e->expType->__anon1._class && e->expType->__anon1._class->__anon1.registered && e->expType->__anon1._class->__anon1.registered->type == 1))
14037 {
14038 unsigned int byReference = e->expType->byReference;
14039 struct Expression * thisExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
14040 struct Declarator * decl;
14041 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
14042 char typeString[1024];
14043 struct Type * type;
14044 int backupClassObjectType;
14045 unsigned int backupByReference;
14046
14047 if(e->expType->kind == 8 && e->expType->__anon1._class && e->expType->__anon1._class->__anon1.registered && strcmp(e->expType->__anon1._class->__anon1.registered->name, "class"))
14048 type = e->expType;
14049 else
14050 type = destType;
14051 backupClassObjectType = type->classObjectType;
14052 backupByReference = type->byReference;
14053 type->classObjectType = 0;
14054 type->byReference = 0;
14055 typeString[0] = '\0';
14056 PrintType(type, typeString, 0, 1);
14057 decl = SpecDeclFromString(typeString, specs, (((void *)0)));
14058 type->classObjectType = backupClassObjectType;
14059 type->byReference = backupByReference;
14060 *thisExp = *e;
14061 thisExp->prev = (((void *)0));
14062 thisExp->next = (((void *)0));
14063 __ecereMethod_Expression_Clear(e);
14064 if((type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered && (type->__anon1._class->__anon1.registered->type == 1000 || type->__anon1._class->__anon1.registered->type == 2 || type->__anon1._class->__anon1.registered->type == 4 || type->__anon1._class->__anon1.registered->type == 3)) || (type->kind != 13 && type->kind != 22 && type->kind != 12 && type->kind != 8) || (!destType->byReference && byReference && (destType->kind != 13 || type->kind != 13)))
14065 {
14066 e->type = 4;
14067 e->__anon1.op.op = '*';
14068 e->__anon1.op.exp1 = (((void *)0));
14069 e->__anon1.op.exp2 = MkExpCast(MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl)), thisExp);
14070 e->expType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14071 CopyTypeInto(e->expType, type);
14072 e->expType->byReference = 0;
14073 e->expType->refCount = 1;
14074 }
14075 else
14076 {
14077 e->type = 11;
14078 e->__anon1.cast.typeName = MkTypeName(specs, decl);
14079 e->__anon1.cast.exp = thisExp;
14080 e->byReference = 1;
14081 e->expType = type;
14082 type->refCount++;
14083 }
14084 e->destType = destType;
14085 destType->refCount++;
14086 }
14087 }
14088 }
14089
14090 void ApplyLocation(struct Expression * exp, struct Location * loc)
14091 {
14092 exp->loc = *loc;
14093 switch(exp->type)
14094 {
14095 case 4:
14096 if(exp->__anon1.op.exp1)
14097 ApplyLocation(exp->__anon1.op.exp1, loc);
14098 if(exp->__anon1.op.exp2)
14099 ApplyLocation(exp->__anon1.op.exp2, loc);
14100 break;
14101 case 5:
14102 if(exp->__anon1.list)
14103 {
14104 struct Expression * e;
14105
14106 for(e = (*exp->__anon1.list).first; e; e = e->next)
14107 ApplyLocation(e, loc);
14108 }
14109 break;
14110 case 6:
14111 if(exp->__anon1.index.index)
14112 {
14113 struct Expression * e;
14114
14115 for(e = (*exp->__anon1.index.index).first; e; e = e->next)
14116 ApplyLocation(e, loc);
14117 }
14118 if(exp->__anon1.index.exp)
14119 ApplyLocation(exp->__anon1.index.exp, loc);
14120 break;
14121 case 7:
14122 if(exp->__anon1.call.arguments)
14123 {
14124 struct Expression * arg;
14125
14126 for(arg = (*exp->__anon1.call.arguments).first; arg; arg = arg->next)
14127 ApplyLocation(arg, loc);
14128 }
14129 if(exp->__anon1.call.exp)
14130 ApplyLocation(exp->__anon1.call.exp, loc);
14131 break;
14132 case 8:
14133 case 9:
14134 if(exp->__anon1.member.exp)
14135 ApplyLocation(exp->__anon1.member.exp, loc);
14136 break;
14137 case 11:
14138 if(exp->__anon1.cast.exp)
14139 ApplyLocation(exp->__anon1.cast.exp, loc);
14140 break;
14141 case 12:
14142 if(exp->__anon1.cond.exp)
14143 {
14144 struct Expression * e;
14145
14146 for(e = (*exp->__anon1.cond.exp).first; e; e = e->next)
14147 ApplyLocation(e, loc);
14148 }
14149 if(exp->__anon1.cond.cond)
14150 ApplyLocation(exp->__anon1.cond.cond, loc);
14151 if(exp->__anon1.cond.elseExp)
14152 ApplyLocation(exp->__anon1.cond.elseExp, loc);
14153 break;
14154 case 34:
14155 if(exp->__anon1.vaArg.exp)
14156 ApplyLocation(exp->__anon1.vaArg.exp, loc);
14157 break;
14158 default:
14159 break;
14160 }
14161 }
14162
14163 extern char *  strstr(const char * , const char * );
14164
14165 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
14166
14167 struct __ecereNameSpace__ecere__com__DefinedExpression
14168 {
14169 struct __ecereNameSpace__ecere__com__DefinedExpression * prev;
14170 struct __ecereNameSpace__ecere__com__DefinedExpression * next;
14171 const char *  name;
14172 const char *  value;
14173 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
14174 } __attribute__ ((gcc_struct));
14175
14176 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_FindDefine(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
14177
14178 extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_FindFunction(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
14179
14180 extern unsigned int __ecereNameSpace__ecere__sys__UTF8GetChar(const char *  string, int *  numBytes);
14181
14182 extern struct Expression * GetTemplateArgExp(struct TemplateParameter * param, struct __ecereNameSpace__ecere__com__Class * curClass, unsigned int pointer);
14183
14184 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
14185
14186 extern struct Expression * MkExpClass(struct __ecereNameSpace__ecere__sys__OldList *  specifiers, struct Declarator * decl);
14187
14188 static void ProcessStatement(struct Statement * stmt);
14189
14190 extern struct Expression * MkExpExtensionInitializer(struct TypeName * typeName, struct Initializer * initializer);
14191
14192 extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
14193
14194 extern char *  __ecereNameSpace__ecere__com__PrintString(struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...);
14195
14196 extern const char *  sourceFile;
14197
14198 extern unsigned int IsVoidPtrCast(struct TypeName * typeName);
14199
14200 extern struct Expression * MoveExpContents(struct Expression * exp);
14201
14202 unsigned int __ecereProp_Type_Get_specConst(struct Type * this);
14203
14204 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_Type_specConst;
14205
14206 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear(struct __ecereNameSpace__ecere__sys__OldList * this);
14207
14208 void ProcessExpressionType(struct Expression * exp)
14209 {
14210 unsigned int unresolved = 0;
14211 struct Location oldyylloc = yylloc;
14212 unsigned int notByReference = 0;
14213
14214 if(!exp || exp->expType)
14215 return ;
14216 yylloc = exp->loc;
14217 switch(exp->type)
14218 {
14219 case 0:
14220 {
14221 struct Identifier * id = exp->__anon1.__anon1.identifier;
14222
14223 if(!id || !topContext)
14224 return ;
14225 if(id->_class && id->_class->__anon1.__anon1.name)
14226 {
14227 id->classSym = id->_class->__anon1.__anon1.symbol;
14228 }
14229 if(!strcmp(id->string, "__runtimePlatform"))
14230 {
14231 exp->expType = ProcessTypeString("ecere::com::Platform", 1);
14232 break;
14233 }
14234 else if(strstr(id->string, "__ecereClass") == id->string)
14235 {
14236 exp->expType = ProcessTypeString("ecere::com::Class", 1);
14237 break;
14238 }
14239 else if(id->_class && (id->classSym || (id->_class->__anon1.__anon1.name && !strcmp(id->_class->__anon1.__anon1.name, "property"))))
14240 {
14241 ReplaceClassMembers(exp, thisClass);
14242 if(exp->type != 0)
14243 {
14244 ProcessExpressionType(exp);
14245 break;
14246 }
14247 if(id->classSym && ResolveIdWithClass(exp, id->classSym->__anon1.registered, 0))
14248 break;
14249 }
14250 else
14251 {
14252 struct Symbol * symbol = FindSymbol(id->string, curContext, topContext, 0, id->_class && id->_class->__anon1.__anon1.name == (((void *)0)));
14253
14254 if(!symbol)
14255 {
14256 if(exp->destType && CheckExpressionType(exp, exp->destType, 0, 0))
14257 break;
14258 else
14259 {
14260 if(thisClass)
14261 {
14262 ReplaceClassMembers(exp, thisClass ? thisClass : currentClass);
14263 if(exp->type != 0)
14264 {
14265 ProcessExpressionType(exp);
14266 break;
14267 }
14268 }
14269 else if(currentClass && !id->_class)
14270 {
14271 if(ResolveIdWithClass(exp, currentClass, 1))
14272 break;
14273 }
14274 symbol = FindSymbol(id->string, topContext->parent, globalContext, 0, id->_class && id->_class->__anon1.__anon1.name == (((void *)0)));
14275 }
14276 }
14277 if(symbol)
14278 {
14279 struct Type * type = symbol->type;
14280 struct __ecereNameSpace__ecere__com__Class * _class = (type && type->kind == 8 && type->__anon1._class) ? type->__anon1._class->__anon1.registered : (((void *)0));
14281
14282 if(_class && !strcmp(id->string, "this") && !type->classObjectType)
14283 {
14284 struct Context * context = SetupTemplatesContext(_class);
14285
14286 type = ReplaceThisClassType(_class);
14287 FinishTemplatesContext(context);
14288 if(type)
14289 type->refCount = 0;
14290 }
14291 FreeSpecifier(id->_class);
14292 id->_class = (((void *)0));
14293 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
14294 id->string = __ecereNameSpace__ecere__sys__CopyString(symbol->string);
14295 id->classSym = (((void *)0));
14296 exp->expType = type;
14297 if(type)
14298 type->refCount++;
14299 if(type && (type->kind == 15))
14300 exp->isConstant = 1;
14301 if(symbol->isParam || !strcmp(id->string, "this"))
14302 {
14303 if(_class && _class->type == 1 && !type->declaredWithStruct)
14304 exp->byReference = 1;
14305 }
14306 if(symbol->isIterator)
14307 {
14308 if(symbol->isIterator == 3)
14309 {
14310 exp->type = 5;
14311 exp->__anon1.list = MkListOne(MkExpOp((((void *)0)), '*', MkExpIdentifier(exp->__anon1.__anon1.identifier)));
14312 ((struct Expression *)(*exp->__anon1.list).first)->__anon1.op.exp2->expType = exp->expType;
14313 exp->expType = (((void *)0));
14314 ProcessExpressionType(exp);
14315 }
14316 else if(symbol->isIterator != 4)
14317 {
14318 exp->type = 8;
14319 exp->__anon1.member.exp = MkExpIdentifier(exp->__anon1.__anon1.identifier);
14320 exp->__anon1.member.exp->expType = exp->expType;
14321 exp->__anon1.member.member = MkIdentifier("data");
14322 exp->expType = (((void *)0));
14323 ProcessExpressionType(exp);
14324 }
14325 }
14326 break;
14327 }
14328 else
14329 {
14330 struct __ecereNameSpace__ecere__com__DefinedExpression * definedExp = (((void *)0));
14331
14332 if(thisNameSpace && !(id->_class && !id->_class->__anon1.__anon1.name))
14333 {
14334 char name[1024];
14335
14336 strcpy(name, thisNameSpace);
14337 strcat(name, "::");
14338 strcat(name, id->string);
14339 definedExp = __ecereNameSpace__ecere__com__eSystem_FindDefine(privateModule, name);
14340 }
14341 if(!definedExp)
14342 definedExp = __ecereNameSpace__ecere__com__eSystem_FindDefine(privateModule, id->string);
14343 if(definedExp)
14344 {
14345 int c;
14346
14347 for(c = 0; c < definedExpStackPos; c++)
14348 if(definedExpStack[c] == definedExp)
14349 break;
14350 if(c == definedExpStackPos && c < sizeof (definedExpStack) / sizeof(void *))
14351 {
14352 struct Location backupYylloc = yylloc;
14353 struct __ecereNameSpace__ecere__com__Instance * backInput = fileInput;
14354
14355 definedExpStack[definedExpStackPos++] = definedExp;
14356 fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
14357 ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  buffer, unsigned int size, unsigned int count))__extension__ ({
14358 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
14359
14360 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
14361 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Write])(fileInput, definedExp->value, 1, strlen(definedExp->value));
14362 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))__extension__ ({
14363 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
14364
14365 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
14366 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek])(fileInput, 0, 0);
14367 echoOn = 0;
14368 parsedExpression = (((void *)0));
14369 resetScanner();
14370 expression_yyparse();
14371 (__ecereNameSpace__ecere__com__eInstance_DecRef(fileInput), fileInput = 0);
14372 if(backInput)
14373 fileInput = backInput;
14374 yylloc = backupYylloc;
14375 if(parsedExpression)
14376 {
14377 FreeIdentifier(id);
14378 exp->type = 5;
14379 exp->__anon1.list = MkListOne(parsedExpression);
14380 ApplyLocation(parsedExpression, &yylloc);
14381 ProcessExpressionType(exp);
14382 definedExpStackPos--;
14383 return ;
14384 }
14385 definedExpStackPos--;
14386 }
14387 else
14388 {
14389 if(inCompiler)
14390 {
14391 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Recursion in defined expression %s\n", (((void *)0))), id->string);
14392 }
14393 }
14394 }
14395 else
14396 {
14397 struct GlobalData * data = (((void *)0));
14398
14399 if(thisNameSpace && !(id->_class && !id->_class->__anon1.__anon1.name))
14400 {
14401 char name[1024];
14402
14403 strcpy(name, thisNameSpace);
14404 strcat(name, "::");
14405 strcat(name, id->string);
14406 data = FindGlobalData(name);
14407 }
14408 if(!data)
14409 data = FindGlobalData(id->string);
14410 if(data)
14411 {
14412 DeclareGlobalData(data);
14413 exp->expType = data->dataType;
14414 if(data->dataType)
14415 data->dataType->refCount++;
14416 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
14417 id->string = __ecereNameSpace__ecere__sys__CopyString(data->fullName);
14418 FreeSpecifier(id->_class);
14419 id->_class = (((void *)0));
14420 break;
14421 }
14422 else
14423 {
14424 struct __ecereNameSpace__ecere__com__GlobalFunction * function = (((void *)0));
14425
14426 if(thisNameSpace && !(id->_class && !id->_class->__anon1.__anon1.name))
14427 {
14428 char name[1024];
14429
14430 strcpy(name, thisNameSpace);
14431 strcat(name, "::");
14432 strcat(name, id->string);
14433 function = __ecereNameSpace__ecere__com__eSystem_FindFunction(privateModule, name);
14434 }
14435 if(!function)
14436 function = __ecereNameSpace__ecere__com__eSystem_FindFunction(privateModule, id->string);
14437 if(function)
14438 {
14439 char name[1024];
14440
14441 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
14442 id->string = __ecereNameSpace__ecere__sys__CopyString(function->name);
14443 name[0] = (char)0;
14444 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)function->module + structSize_Instance)))->importType != 1 && (!function->dataType || !function->dataType->dllExport))
14445 strcpy(name, "__ecereFunction_");
14446 FullClassNameCat(name, id->string, 0);
14447 if(DeclareFunction(function, name))
14448 {
14449 (__ecereNameSpace__ecere__com__eSystem_Delete(id->string), id->string = 0);
14450 id->string = __ecereNameSpace__ecere__sys__CopyString(name);
14451 }
14452 exp->expType = function->dataType;
14453 if(function->dataType)
14454 function->dataType->refCount++;
14455 FreeSpecifier(id->_class);
14456 id->_class = (((void *)0));
14457 break;
14458 }
14459 }
14460 }
14461 }
14462 }
14463 unresolved = 1;
14464 break;
14465 }
14466 case 1:
14467 {
14468 if(!exp->__anon1.instance->_class)
14469 {
14470 if(exp->destType && exp->destType->kind == 8 && exp->destType->__anon1._class)
14471 {
14472 exp->__anon1.instance->_class = MkSpecifierName(exp->destType->__anon1._class->string);
14473 }
14474 }
14475 ProcessInstantiationType(exp->__anon1.instance);
14476 exp->isConstant = exp->__anon1.instance->isConstant;
14477 if(exp->__anon1.instance->_class)
14478 {
14479 exp->expType = MkClassType(exp->__anon1.instance->_class->__anon1.__anon1.name);
14480 }
14481 break;
14482 }
14483 case 2:
14484 {
14485 if(!exp->expType)
14486 {
14487 char * constant = exp->__anon1.__anon1.constant;
14488 struct Type * type = (type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), type->refCount = 1, type->constant = 1, type);
14489
14490 exp->expType = type;
14491 if(constant[0] == '\'')
14492 {
14493 if((int)((unsigned char *)constant)[1] > 127)
14494 {
14495 int nb;
14496 unsigned int ch = __ecereNameSpace__ecere__sys__UTF8GetChar(constant + 1, &nb);
14497
14498 if(nb < 2)
14499 ch = constant[1];
14500 (__ecereNameSpace__ecere__com__eSystem_Delete(constant), constant = 0);
14501 exp->__anon1.__anon1.constant = PrintUInt(ch);
14502 type->kind = 8;
14503 type->__anon1._class = FindClass("unichar");
14504 type->isSigned = 0;
14505 }
14506 else
14507 {
14508 type->kind = 1;
14509 type->isSigned = 1;
14510 }
14511 }
14512 else
14513 {
14514 char * dot = strchr(constant, '.');
14515 unsigned int isHex = (constant[0] == '0' && (constant[1] == 'x' || constant[1] == 'X'));
14516 char * exponent;
14517
14518 if(isHex)
14519 {
14520 exponent = strchr(constant, 'p');
14521 if(!exponent)
14522 exponent = strchr(constant, 'P');
14523 }
14524 else
14525 {
14526 exponent = strchr(constant, 'e');
14527 if(!exponent)
14528 exponent = strchr(constant, 'E');
14529 }
14530 if(dot || exponent)
14531 {
14532 if(strchr(constant, 'f') || strchr(constant, 'F'))
14533 type->kind = 6;
14534 else
14535 type->kind = 7;
14536 type->isSigned = 1;
14537 }
14538 else
14539 {
14540 unsigned int isSigned = constant[0] == '-';
14541 char * endP = (((void *)0));
14542 long long i64 = strtoll(constant, &endP, 0);
14543 uint64 ui64 = strtoull(constant, &endP, 0);
14544 unsigned int is64Bit = endP && (!strcmp(endP, "LL") || !strcmp(endP, "ll"));
14545
14546 if(isSigned)
14547 {
14548 if(i64 < (((int)0x80000000)))
14549 is64Bit = 1;
14550 }
14551 else
14552 {
14553 if(ui64 > (((int)0x7fffffff)))
14554 {
14555 if(ui64 > (0xffffffff))
14556 {
14557 is64Bit = 1;
14558 if(ui64 <= (((long long)0x7fffffffffffffffLL)) && (constant[0] != '0' || !constant[1]))
14559 isSigned = 1;
14560 }
14561 }
14562 else if(constant[0] != '0' || !constant[1])
14563 isSigned = 1;
14564 }
14565 type->kind = is64Bit ? 4 : 3;
14566 type->isSigned = isSigned;
14567 }
14568 }
14569 exp->isConstant = 1;
14570 if(exp->destType && exp->destType->kind == 7)
14571 type->kind = 7;
14572 else if(exp->destType && exp->destType->kind == 6)
14573 type->kind = 6;
14574 else if(exp->destType && exp->destType->kind == 4)
14575 type->kind = 4;
14576 }
14577 break;
14578 }
14579 case 3:
14580 {
14581 exp->isConstant = 1;
14582 exp->expType = __extension__ ({
14583 struct Type * __ecereInstance2 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14584
14585 __ecereInstance2->refCount = 1, __ecereInstance2->kind = 13, __ecereInstance2->__anon1.type = __extension__ ({
14586 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14587
14588 __ecereInstance1->refCount = 1, __ecereInstance1->kind = exp->__anon1.__anon2.wideString ? 2 : 1, __ecereInstance1->constant = 1, __ecereInstance1->isSigned = exp->__anon1.__anon2.wideString ? 0 : 1, __ecereInstance1;
14589 }), __ecereInstance2;
14590 });
14591 break;
14592 }
14593 case 13:
14594 case 26:
14595 ProcessExpressionType(exp->__anon1._new.size);
14596 exp->expType = __extension__ ({
14597 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14598
14599 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 13, __ecereInstance1->__anon1.type = ProcessType(exp->__anon1._new.typeName->qualifiers, exp->__anon1._new.typeName->declarator), __ecereInstance1;
14600 });
14601 DeclareType(exp->expType->__anon1.type, 0, 0);
14602 break;
14603 case 14:
14604 case 27:
14605 ProcessExpressionType(exp->__anon1._renew.size);
14606 ProcessExpressionType(exp->__anon1._renew.exp);
14607 exp->expType = __extension__ ({
14608 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14609
14610 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 13, __ecereInstance1->__anon1.type = ProcessType(exp->__anon1._renew.typeName->qualifiers, exp->__anon1._renew.typeName->declarator), __ecereInstance1;
14611 });
14612 DeclareType(exp->expType->__anon1.type, 0, 0);
14613 break;
14614 case 4:
14615 {
14616 unsigned int assign = 0, boolResult = 0, boolOps = 0;
14617 struct Type * type1 = (((void *)0)), * type2 = (((void *)0));
14618 unsigned int useDestType = 0, useSideType = 0;
14619 struct Location oldyylloc = yylloc;
14620 unsigned int useSideUnit = 0;
14621 struct __ecereNameSpace__ecere__com__Class * destClass = (exp->destType && exp->destType->kind == 8 && exp->destType->__anon1._class) ? exp->destType->__anon1._class->__anon1.registered : (((void *)0));
14622 struct Type * dummy = (dummy = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), dummy->count = 1, dummy->refCount = 1, dummy);
14623
14624 switch(exp->__anon1.op.op)
14625 {
14626 case '=':
14627 case MUL_ASSIGN:
14628 case DIV_ASSIGN:
14629 case MOD_ASSIGN:
14630 case ADD_ASSIGN:
14631 case SUB_ASSIGN:
14632 case LEFT_ASSIGN:
14633 case RIGHT_ASSIGN:
14634 case AND_ASSIGN:
14635 case XOR_ASSIGN:
14636 case OR_ASSIGN:
14637 assign = 1;
14638 break;
14639 case '!':
14640 break;
14641 case AND_OP:
14642 case OR_OP:
14643 boolOps = 1;
14644 boolResult = 1;
14645 break;
14646 case EQ_OP:
14647 case '<':
14648 case '>':
14649 case LE_OP:
14650 case GE_OP:
14651 case NE_OP:
14652 boolResult = 1;
14653 useSideType = 1;
14654 break;
14655 case '+':
14656 case '-':
14657 useSideUnit = 1;
14658 useSideType = 1;
14659 useDestType = 1;
14660 break;
14661 case LEFT_OP:
14662 case RIGHT_OP:
14663 useSideType = 1;
14664 useDestType = 1;
14665 break;
14666 case '|':
14667 case '^':
14668 useSideType = 1;
14669 useDestType = 1;
14670 break;
14671 case '/':
14672 case '%':
14673 useSideType = 1;
14674 useDestType = 1;
14675 break;
14676 case '&':
14677 case '*':
14678 if(exp->__anon1.op.exp1)
14679 {
14680 useSideType = 1;
14681 useDestType = 1;
14682 }
14683 break;
14684 }
14685 if(exp->__anon1.op.op == '&')
14686 {
14687 if(!exp->__anon1.op.exp1 && exp->__anon1.op.exp2 && exp->__anon1.op.exp2->type == 0 && exp->__anon1.op.exp2->__anon1.__anon1.identifier)
14688 {
14689 struct Identifier * id = exp->__anon1.op.exp2->__anon1.__anon1.identifier;
14690 struct Symbol * symbol = FindSymbol(id->string, curContext, topContext, 0, id->_class && id->_class->__anon1.__anon1.name == (((void *)0)));
14691
14692 if(symbol && symbol->isIterator == 2)
14693 {
14694 exp->type = 8;
14695 exp->__anon1.member.exp = exp->__anon1.op.exp2;
14696 exp->__anon1.member.member = MkIdentifier("key");
14697 exp->expType = (((void *)0));
14698 exp->__anon1.op.exp2->expType = symbol->type;
14699 symbol->type->refCount++;
14700 ProcessExpressionType(exp);
14701 FreeType(dummy);
14702 break;
14703 }
14704 }
14705 }
14706 if(exp->__anon1.op.exp1)
14707 {
14708 if(exp->__anon1.op.exp2 && useSideUnit && useDestType && destClass && destClass->type == 3 && destClass->base->type != 3)
14709 useDestType = 0;
14710 if(destClass && useDestType && ((destClass->type == 3 && useSideUnit) || destClass->type == 4 || destClass->type == 2))
14711 {
14712 if(exp->__anon1.op.exp1->destType)
14713 FreeType(exp->__anon1.op.exp1->destType);
14714 exp->__anon1.op.exp1->destType = exp->destType;
14715 exp->__anon1.op.exp1->opDestType = 1;
14716 if(exp->destType)
14717 exp->destType->refCount++;
14718 }
14719 else if(!assign)
14720 {
14721 if(exp->__anon1.op.exp1->destType)
14722 FreeType(exp->__anon1.op.exp1->destType);
14723 exp->__anon1.op.exp1->destType = dummy;
14724 dummy->refCount++;
14725 }
14726 if(exp->__anon1.op.exp1->destType && exp->__anon1.op.op != '=')
14727 exp->__anon1.op.exp1->destType->count++;
14728 ProcessExpressionType(exp->__anon1.op.exp1);
14729 if(exp->__anon1.op.exp1->destType && exp->__anon1.op.op != '=')
14730 exp->__anon1.op.exp1->destType->count--;
14731 exp->__anon1.op.exp1->opDestType = 0;
14732 if(!exp->__anon1.op.exp2 && (exp->__anon1.op.op == INC_OP || exp->__anon1.op.op == DEC_OP) && exp->__anon1.op.exp1->expType && exp->__anon1.op.exp1->expType->kind == 8 && exp->__anon1.op.exp1->expType->__anon1._class && exp->__anon1.op.exp1->expType->__anon1._class->__anon1.registered && exp->__anon1.op.exp1->expType->__anon1._class->__anon1.registered->type == 3)
14733 {
14734 exp->__anon1.op.exp2 = MkExpConstant("1");
14735 exp->__anon1.op.op = exp->__anon1.op.op == INC_OP ? ADD_ASSIGN : SUB_ASSIGN;
14736 assign = 1;
14737 }
14738 if(exp->__anon1.op.exp1->destType == dummy)
14739 {
14740 FreeType(dummy);
14741 exp->__anon1.op.exp1->destType = (((void *)0));
14742 }
14743 type1 = exp->__anon1.op.exp1->expType;
14744 }
14745 if(exp->__anon1.op.exp2)
14746 {
14747 char expString[10240];
14748
14749 expString[0] = '\0';
14750 if(exp->__anon1.op.exp2->type == 1 && !exp->__anon1.op.exp2->__anon1.instance->_class)
14751 {
14752 if(exp->__anon1.op.exp1)
14753 {
14754 exp->__anon1.op.exp2->destType = exp->__anon1.op.exp1->expType;
14755 if(exp->__anon1.op.exp1->expType)
14756 exp->__anon1.op.exp1->expType->refCount++;
14757 }
14758 else
14759 {
14760 exp->__anon1.op.exp2->destType = exp->destType;
14761 if(!exp->__anon1.op.exp1 || exp->__anon1.op.op != '&')
14762 exp->__anon1.op.exp2->opDestType = 1;
14763 if(exp->destType)
14764 exp->destType->refCount++;
14765 }
14766 if(type1)
14767 type1->refCount++;
14768 exp->expType = type1;
14769 }
14770 else if(assign)
14771 {
14772 if(inCompiler)
14773 PrintExpression(exp->__anon1.op.exp2, expString);
14774 if(type1 && type1->kind == 13)
14775 {
14776 if(exp->__anon1.op.op == MUL_ASSIGN || exp->__anon1.op.op == DIV_ASSIGN || exp->__anon1.op.op == MOD_ASSIGN || exp->__anon1.op.op == LEFT_ASSIGN || exp->__anon1.op.op == RIGHT_ASSIGN || exp->__anon1.op.op == AND_ASSIGN || exp->__anon1.op.op == OR_ASSIGN)
14777 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "operator %s illegal on pointer\n", (((void *)0))), exp->__anon1.op.op);
14778 else if(exp->__anon1.op.op == '=')
14779 {
14780 if(exp->__anon1.op.exp2->destType)
14781 FreeType(exp->__anon1.op.exp2->destType);
14782 exp->__anon1.op.exp2->destType = type1;
14783 if(type1)
14784 type1->refCount++;
14785 }
14786 }
14787 else
14788 {
14789 if(exp->__anon1.op.op == MUL_ASSIGN || exp->__anon1.op.op == DIV_ASSIGN || exp->__anon1.op.op == MOD_ASSIGN || exp->__anon1.op.op == LEFT_ASSIGN || exp->__anon1.op.op == RIGHT_ASSIGN)
14790 ;
14791 else
14792 {
14793 if(exp->__anon1.op.exp2->destType)
14794 FreeType(exp->__anon1.op.exp2->destType);
14795 exp->__anon1.op.exp2->destType = type1;
14796 if(type1)
14797 type1->refCount++;
14798 }
14799 }
14800 if(type1)
14801 type1->refCount++;
14802 exp->expType = type1;
14803 }
14804 else if(destClass && ((destClass->type == 3 && useDestType && useSideUnit) || (destClass->type == 4 && useDestType)))
14805 {
14806 if(exp->__anon1.op.exp2->destType)
14807 FreeType(exp->__anon1.op.exp2->destType);
14808 exp->__anon1.op.exp2->destType = exp->destType;
14809 if(exp->__anon1.op.op != '&')
14810 exp->__anon1.op.exp2->opDestType = 1;
14811 if(exp->destType)
14812 exp->destType->refCount++;
14813 }
14814 else
14815 {
14816 if(exp->__anon1.op.exp2->destType)
14817 FreeType(exp->__anon1.op.exp2->destType);
14818 exp->__anon1.op.exp2->destType = dummy;
14819 dummy->refCount++;
14820 }
14821 if(type1 && boolResult && useSideType && type1->kind == 8 && type1->__anon1._class && type1->__anon1._class->__anon1.registered && (type1->__anon1._class->__anon1.registered->type == 2 || type1->__anon1._class->__anon1.registered->type == 4))
14822 {
14823 FreeType(exp->__anon1.op.exp2->destType);
14824 exp->__anon1.op.exp2->destType = type1;
14825 type1->refCount++;
14826 }
14827 if(exp->__anon1.op.exp2->destType && exp->__anon1.op.op != '=')
14828 exp->__anon1.op.exp2->destType->count++;
14829 if(exp->__anon1.op.op == SIZEOF)
14830 {
14831 struct Expression * e = exp->__anon1.op.exp2;
14832
14833 while((e->type == 5 || e->type == 32 || e->type == 23) && e->__anon1.list)
14834 {
14835 if(e->type == 5 || e->type == 32 || e->type == 23)
14836 {
14837 if(e->type == 23)
14838 e = (*((struct Statement *)(*e->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last;
14839 else
14840 e = (*e->__anon1.list).last;
14841 }
14842 }
14843 if(e->type == 11 && e->__anon1.cast.exp)
14844 e->__anon1.cast.exp->needCast = 1;
14845 }
14846 ProcessExpressionType(exp->__anon1.op.exp2);
14847 exp->__anon1.op.exp2->opDestType = 0;
14848 if(exp->__anon1.op.exp2->destType && exp->__anon1.op.op != '=')
14849 exp->__anon1.op.exp2->destType->count--;
14850 if(assign && type1 && type1->kind == 13 && exp->__anon1.op.exp2->expType)
14851 {
14852 if(exp->__anon1.op.exp2->expType->kind == 23 || exp->__anon1.op.exp2->expType->kind == 22 || exp->__anon1.op.exp2->expType->kind == 4 || exp->__anon1.op.exp2->expType->kind == 3 || exp->__anon1.op.exp2->expType->kind == 2 || exp->__anon1.op.exp2->expType->kind == 1)
14853 {
14854 if(exp->__anon1.op.op != '=' && type1->__anon1.type->kind == 0)
14855 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
14856 }
14857 else if(exp->__anon1.op.exp2->expType->kind == 13 || exp->__anon1.op.exp2->expType->kind == 12 || exp->__anon1.op.exp2->expType->kind == 11 || exp->__anon1.op.exp2->expType->kind == 16 || (type1->__anon1.type->kind == 0 && exp->__anon1.op.exp2->expType->kind == 8 && exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered && (exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered->type == 0 || exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered->type == 1 || exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered->type == 5)))
14858 {
14859 if(exp->__anon1.op.op == ADD_ASSIGN)
14860 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
14861 }
14862 else if((exp->__anon1.op.exp2->expType->kind == 8 && type1->kind == 13 && type1->__anon1.type->kind == 8 && type1->__anon1.type->__anon1._class == exp->__anon1.op.exp2->expType->__anon1._class && exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered && exp->__anon1.op.exp2->expType->__anon1._class->__anon1.registered->type == 1))
14863 {
14864 if(exp->__anon1.op.op == ADD_ASSIGN)
14865 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
14866 }
14867 else if(inCompiler)
14868 {
14869 char type1String[1024];
14870 char type2String[1024];
14871
14872 type1String[0] = '\0';
14873 type2String[0] = '\0';
14874 PrintType(exp->__anon1.op.exp2->expType, type1String, 0, 1);
14875 PrintType(type1, type2String, 0, 1);
14876 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
14877 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1String, type2String);
14878 }
14879 }
14880 if(exp->__anon1.op.exp2->destType == dummy)
14881 {
14882 FreeType(dummy);
14883 exp->__anon1.op.exp2->destType = (((void *)0));
14884 }
14885 if(exp->__anon1.op.op == '-' && !exp->__anon1.op.exp1 && exp->__anon1.op.exp2->expType && !exp->__anon1.op.exp2->expType->isSigned)
14886 {
14887 type2 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14888 type2->refCount = 1;
14889 CopyTypeInto(type2, exp->__anon1.op.exp2->expType);
14890 type2->isSigned = 1;
14891 }
14892 else if(exp->__anon1.op.op == '~' && !exp->__anon1.op.exp1 && exp->__anon1.op.exp2->expType && (!exp->__anon1.op.exp2->expType->isSigned || exp->__anon1.op.exp2->expType->kind != 3))
14893 {
14894 type2 = __extension__ ({
14895 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14896
14897 __ecereInstance1->kind = 3, __ecereInstance1;
14898 });
14899 type2->refCount = 1;
14900 type2->isSigned = 1;
14901 }
14902 else
14903 {
14904 type2 = exp->__anon1.op.exp2->expType;
14905 if(type2)
14906 type2->refCount++;
14907 }
14908 }
14909 dummy->kind = 0;
14910 if(exp->__anon1.op.op == SIZEOF)
14911 {
14912 exp->expType = __extension__ ({
14913 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
14914
14915 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 23, __ecereInstance1;
14916 });
14917 exp->isConstant = 1;
14918 }
14919 else if(exp->__anon1.op.op == '*' && !exp->__anon1.op.exp1)
14920 {
14921 exp->expType = Dereference(type2);
14922 if(type2 && type2->kind == 8)
14923 notByReference = 1;
14924 }
14925 else if(exp->__anon1.op.op == '&' && !exp->__anon1.op.exp1)
14926 exp->expType = Reference(type2);
14927 else if(!assign)
14928 {
14929 if(boolOps)
14930 {
14931 if(exp->__anon1.op.exp1)
14932 {
14933 if(exp->__anon1.op.exp1->destType)
14934 FreeType(exp->__anon1.op.exp1->destType);
14935 exp->__anon1.op.exp1->destType = MkClassType("bool");
14936 exp->__anon1.op.exp1->destType->truth = 1;
14937 if(!exp->__anon1.op.exp1->expType)
14938 ProcessExpressionType(exp->__anon1.op.exp1);
14939 else
14940 CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0);
14941 FreeType(exp->__anon1.op.exp1->expType);
14942 exp->__anon1.op.exp1->expType = MkClassType("bool");
14943 exp->__anon1.op.exp1->expType->truth = 1;
14944 }
14945 if(exp->__anon1.op.exp2)
14946 {
14947 if(exp->__anon1.op.exp2->destType)
14948 FreeType(exp->__anon1.op.exp2->destType);
14949 exp->__anon1.op.exp2->destType = MkClassType("bool");
14950 exp->__anon1.op.exp2->destType->truth = 1;
14951 if(!exp->__anon1.op.exp2->expType)
14952 ProcessExpressionType(exp->__anon1.op.exp2);
14953 else
14954 CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0);
14955 FreeType(exp->__anon1.op.exp2->expType);
14956 exp->__anon1.op.exp2->expType = MkClassType("bool");
14957 exp->__anon1.op.exp2->expType->truth = 1;
14958 }
14959 }
14960 else if(exp->__anon1.op.exp1 && exp->__anon1.op.exp2 && ((useSideType) || ((!type1 || type1->kind != 8 || !strcmp(type1->__anon1._class->string, "String")) && (!type2 || type2->kind != 8 || !strcmp(type2->__anon1._class->string, "String")))))
14961 {
14962 if(type1 && type2 && ((type1->kind == 8 && type1->__anon1._class && strcmp(type1->__anon1._class->string, "String")) == (type2->kind == 8 && type2->__anon1._class && strcmp(type2->__anon1._class->string, "String"))))
14963 {
14964 if(exp->__anon1.op.op == '-' && ((type1->kind == 8 && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 4) || (type2->kind == 8 && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 4)))
14965 {
14966 struct Type * intType;
14967
14968 if(!type1->__anon1._class->__anon1.registered->dataType)
14969 type1->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type1->__anon1._class->__anon1.registered->dataTypeString, 0);
14970 if(!type2->__anon1._class->__anon1.registered->dataType)
14971 type2->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type2->__anon1._class->__anon1.registered->dataTypeString, 0);
14972 intType = ProcessTypeString((type1->__anon1._class->__anon1.registered->dataType->kind == 4 || type2->__anon1._class->__anon1.registered->dataType->kind == 4) ? "int64" : "int", 0);
14973 if(exp->__anon1.op.exp1->destType)
14974 FreeType(exp->__anon1.op.exp1->destType);
14975 if(exp->__anon1.op.exp2->destType)
14976 FreeType(exp->__anon1.op.exp2->destType);
14977 exp->__anon1.op.exp1->destType = intType;
14978 exp->__anon1.op.exp2->destType = intType;
14979 intType->refCount++;
14980 }
14981 else
14982 {
14983 if(exp->__anon1.op.exp2->destType)
14984 FreeType(exp->__anon1.op.exp2->destType);
14985 exp->__anon1.op.exp2->destType = type1;
14986 type1->refCount++;
14987 if(exp->__anon1.op.exp1->destType)
14988 FreeType(exp->__anon1.op.exp1->destType);
14989 exp->__anon1.op.exp1->destType = type2;
14990 type2->refCount++;
14991 }
14992 if(!boolResult && type1->kind == 8 && (!exp->destType || exp->destType->kind != 8) && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 3 && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 3 && type1->__anon1._class->__anon1.registered != type2->__anon1._class->__anon1.registered)
14993 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "operating on %s and %s with an untyped result, assuming %s\n", (((void *)0))), type1->__anon1._class->string, type2->__anon1._class->string, type1->__anon1._class->string);
14994 if(type1->kind == 13 && type1->__anon1.type->kind == 20 && type2->kind != 13)
14995 {
14996 struct Expression * argExp = GetTemplateArgExp(type1->__anon1.type->__anon1.templateParameter, thisClass, 1);
14997
14998 if(argExp)
14999 {
15000 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
15001
15002 exp->__anon1.op.exp1 = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), exp->__anon1.op.exp1)));
15003 ProcessExpressionType(exp->__anon1.op.exp1);
15004 if(type2->kind != 13)
15005 {
15006 ProcessExpressionType(classExp);
15007 exp->__anon1.op.exp2 = MkExpBrackets(MkListOne(MkExpOp(exp->__anon1.op.exp2, '*', MkExpMember(classExp, MkIdentifier("typeSize")))));
15008 if(!exp->__anon1.op.exp2->expType)
15009 {
15010 if(type2)
15011 FreeType(type2);
15012 type2 = exp->__anon1.op.exp2->expType = ProcessTypeString("int", 0);
15013 type2->refCount++;
15014 }
15015 ProcessExpressionType(exp->__anon1.op.exp2);
15016 }
15017 }
15018 }
15019 if(!boolResult && ((type1->kind == 13 || type1->kind == 12 || (type1->kind == 8 && !strcmp(type1->__anon1._class->string, "String"))) && (type2->kind == 23 || type2->kind == 22 || type2->kind == 4 || type2->kind == 3 || type2->kind == 2 || type2->kind == 1)))
15020 {
15021 if(type1->kind != 8 && type1->__anon1.type->kind == 0)
15022 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
15023 exp->expType = type1;
15024 if(type1)
15025 type1->refCount++;
15026 }
15027 else if(!boolResult && ((type2->kind == 13 || type2->kind == 12 || (type2->kind == 8 && !strcmp(type2->__anon1._class->string, "String"))) && (type1->kind == 23 || type1->kind == 22 || type1->kind == 4 || type1->kind == 3 || type1->kind == 2 || type1->kind == 1)))
15028 {
15029 if(type2->kind != 8 && type2->__anon1.type->kind == 0)
15030 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
15031 exp->expType = type2;
15032 if(type2)
15033 type2->refCount++;
15034 }
15035 else if((type1->kind == 13 && type2->kind != 13 && type2->kind != 12 && type2->kind != 11 && type2->kind != 16 && type2->kind != 8 && type2->kind != 19) || (type2->kind == 13 && type1->kind != 13 && type1->kind != 12 && type1->kind != 11 && type1->kind != 16 && type1->kind != 8 && type1->kind != 19))
15036 {
15037 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "different levels of indirection\n", (((void *)0))));
15038 }
15039 else
15040 {
15041 unsigned int success = 0;
15042
15043 if(type1->kind == 13 && type2->kind == 13)
15044 {
15045 if(exp->__anon1.op.op == '+')
15046 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
15047 else if(exp->__anon1.op.op == '-')
15048 {
15049 if(MatchTypes(type1->__anon1.type, type2->__anon1.type, (((void *)0)), (((void *)0)), (((void *)0)), 0, 0, 0, 0, 0))
15050 {
15051 exp->expType = __extension__ ({
15052 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
15053
15054 __ecereInstance1->kind = 3, __ecereInstance1->refCount = 1, __ecereInstance1;
15055 });
15056 success = 1;
15057 if(type1->__anon1.type->kind == 20)
15058 {
15059 struct Expression * argExp = GetTemplateArgExp(type1->__anon1.type->__anon1.templateParameter, thisClass, 1);
15060
15061 if(argExp)
15062 {
15063 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
15064
15065 ProcessExpressionType(classExp);
15066 exp->type = 5;
15067 exp->__anon1.list = MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpBrackets(MkListOne(exp->__anon1.op.exp1))), exp->__anon1.op.op, MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpBrackets(MkListOne(exp->__anon1.op.exp2)))))), '/', MkExpMember(classExp, MkIdentifier("typeSize"))));
15068 ProcessExpressionType(((struct Expression *)(*exp->__anon1.list).first)->__anon1.op.exp2);
15069 FreeType(dummy);
15070 return ;
15071 }
15072 }
15073 }
15074 }
15075 }
15076 if(!success && exp->__anon1.op.exp1->type == 2)
15077 {
15078 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0))
15079 {
15080 if(exp->expType)
15081 FreeType(exp->expType);
15082 exp->expType = exp->__anon1.op.exp1->destType;
15083 if(exp->__anon1.op.exp1->destType)
15084 exp->__anon1.op.exp1->destType->refCount++;
15085 success = 1;
15086 }
15087 else if(CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0))
15088 {
15089 if(exp->expType)
15090 FreeType(exp->expType);
15091 exp->expType = exp->__anon1.op.exp2->destType;
15092 if(exp->__anon1.op.exp2->destType)
15093 exp->__anon1.op.exp2->destType->refCount++;
15094 success = 1;
15095 }
15096 }
15097 else if(!success)
15098 {
15099 if(CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0))
15100 {
15101 if(exp->expType)
15102 FreeType(exp->expType);
15103 exp->expType = exp->__anon1.op.exp2->destType;
15104 if(exp->__anon1.op.exp2->destType)
15105 exp->__anon1.op.exp2->destType->refCount++;
15106 success = 1;
15107 }
15108 else if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0))
15109 {
15110 if(exp->expType)
15111 FreeType(exp->expType);
15112 exp->expType = exp->__anon1.op.exp1->destType;
15113 if(exp->__anon1.op.exp1->destType)
15114 exp->__anon1.op.exp1->destType->refCount++;
15115 success = 1;
15116 }
15117 }
15118 if(!success)
15119 {
15120 char expString1[10240];
15121 char expString2[10240];
15122 char type1[1024];
15123 char type2[1024];
15124
15125 expString1[0] = '\0';
15126 expString2[0] = '\0';
15127 type1[0] = '\0';
15128 type2[0] = '\0';
15129 if(inCompiler)
15130 {
15131 PrintExpression(exp->__anon1.op.exp1, expString1);
15132 __ecereNameSpace__ecere__sys__ChangeCh(expString1, '\n', ' ');
15133 PrintExpression(exp->__anon1.op.exp2, expString2);
15134 __ecereNameSpace__ecere__sys__ChangeCh(expString2, '\n', ' ');
15135 PrintType(exp->__anon1.op.exp1->expType, type1, 0, 1);
15136 PrintType(exp->__anon1.op.exp2->expType, type2, 0, 1);
15137 }
15138 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1, expString2, type2);
15139 }
15140 }
15141 }
15142 else if(!boolResult && (!useSideUnit) && type2 && type1 && type2->kind == 8 && type1->kind != 8 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 3)
15143 {
15144 if(exp->__anon1.op.exp1->destType)
15145 FreeType(exp->__anon1.op.exp1->destType);
15146 exp->__anon1.op.exp1->destType = type2->__anon1._class->__anon1.registered->dataType;
15147 if(type2->__anon1._class->__anon1.registered->dataType)
15148 type2->__anon1._class->__anon1.registered->dataType->refCount++;
15149 CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0);
15150 exp->expType = type2;
15151 if(type2)
15152 type2->refCount++;
15153 }
15154 else if(!boolResult && (!useSideUnit) && type1 && type2 && type1->kind == 8 && type2->kind != 8 && type1->__anon1._class && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 3)
15155 {
15156 if(exp->__anon1.op.exp2->destType)
15157 FreeType(exp->__anon1.op.exp2->destType);
15158 exp->__anon1.op.exp2->destType = type1->__anon1._class->__anon1.registered->dataType;
15159 if(type1->__anon1._class->__anon1.registered->dataType)
15160 type1->__anon1._class->__anon1.registered->dataType->refCount++;
15161 CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0);
15162 exp->expType = type1;
15163 if(type1)
15164 type1->refCount++;
15165 }
15166 else if(type1)
15167 {
15168 unsigned int valid = 0;
15169
15170 if(!boolResult && useSideUnit && type1 && type1->kind == 8 && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 3 && type2 && type2->kind != 8)
15171 {
15172 if(exp->__anon1.op.exp2->destType)
15173 FreeType(exp->__anon1.op.exp2->destType);
15174 if(!type1->__anon1._class->__anon1.registered->dataType)
15175 type1->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type1->__anon1._class->__anon1.registered->dataTypeString, 0);
15176 exp->__anon1.op.exp2->destType = type1->__anon1._class->__anon1.registered->dataType;
15177 exp->__anon1.op.exp2->destType->refCount++;
15178 CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0);
15179 if(type2)
15180 FreeType(type2);
15181 type2 = exp->__anon1.op.exp2->destType;
15182 if(type2)
15183 type2->refCount++;
15184 exp->expType = type2;
15185 type2->refCount++;
15186 }
15187 if(!boolResult && useSideUnit && type2 && type2->kind == 8 && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 3 && type1 && type1->kind != 8)
15188 {
15189 if(exp->__anon1.op.exp1->destType)
15190 FreeType(exp->__anon1.op.exp1->destType);
15191 if(!type2->__anon1._class->__anon1.registered->dataType)
15192 type2->__anon1._class->__anon1.registered->dataType = ProcessTypeString(type2->__anon1._class->__anon1.registered->dataTypeString, 0);
15193 exp->__anon1.op.exp1->destType = type2->__anon1._class->__anon1.registered->dataType;
15194 exp->__anon1.op.exp1->destType->refCount++;
15195 CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0);
15196 type1 = exp->__anon1.op.exp1->destType;
15197 exp->expType = type1;
15198 type1->refCount++;
15199 }
15200 if(!boolResult || exp->__anon1.op.op == '>' || exp->__anon1.op.op == '<' || exp->__anon1.op.op == GE_OP || exp->__anon1.op.op == LE_OP)
15201 {
15202 unsigned int op1IsEnum = type1 && type1->kind == 8 && type1->__anon1._class && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 4;
15203 unsigned int op2IsEnum = type2 && type2->kind == 8 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 4;
15204
15205 if(exp->__anon1.op.op == '*' || exp->__anon1.op.op == '/' || exp->__anon1.op.op == '-' || exp->__anon1.op.op == '|' || exp->__anon1.op.op == '^')
15206 {
15207 if(op1IsEnum && exp->__anon1.op.exp2->expType)
15208 {
15209 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp2->expType, 0, 0))
15210 {
15211 if(exp->expType)
15212 FreeType(exp->expType);
15213 exp->expType = exp->__anon1.op.exp2->expType;
15214 if(exp->__anon1.op.exp2->expType)
15215 exp->__anon1.op.exp2->expType->refCount++;
15216 valid = 1;
15217 }
15218 }
15219 else if(op2IsEnum && exp->__anon1.op.exp1->expType)
15220 {
15221 if(CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp1->expType, 0, 0))
15222 {
15223 if(exp->expType)
15224 FreeType(exp->expType);
15225 exp->expType = exp->__anon1.op.exp1->expType;
15226 if(exp->__anon1.op.exp1->expType)
15227 exp->__anon1.op.exp1->expType->refCount++;
15228 valid = 1;
15229 }
15230 }
15231 }
15232 else
15233 {
15234 if(op1IsEnum && exp->__anon1.op.exp2->expType)
15235 {
15236 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp2->expType, 0, 0))
15237 {
15238 if(exp->expType)
15239 FreeType(exp->expType);
15240 exp->expType = exp->__anon1.op.exp1->expType;
15241 if(exp->__anon1.op.exp1->expType)
15242 exp->__anon1.op.exp1->expType->refCount++;
15243 valid = 1;
15244 }
15245 }
15246 else if(op2IsEnum && exp->__anon1.op.exp1->expType)
15247 {
15248 if(CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp1->expType, 0, 0))
15249 {
15250 if(exp->expType)
15251 FreeType(exp->expType);
15252 exp->expType = exp->__anon1.op.exp2->expType;
15253 if(exp->__anon1.op.exp2->expType)
15254 exp->__anon1.op.exp2->expType->refCount++;
15255 valid = 1;
15256 }
15257 }
15258 }
15259 }
15260 if(!valid)
15261 {
15262 if(type2 && type2->kind == 8 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 3 && (type1->kind != 8 || !type1->__anon1._class || !type1->__anon1._class->__anon1.registered || type1->__anon1._class->__anon1.registered->type != 3))
15263 {
15264 if(exp->__anon1.op.exp1->destType)
15265 FreeType(exp->__anon1.op.exp1->destType);
15266 exp->__anon1.op.exp1->destType = type2;
15267 type2->refCount++;
15268 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0))
15269 {
15270 if(exp->expType)
15271 FreeType(exp->expType);
15272 exp->expType = exp->__anon1.op.exp1->destType;
15273 if(exp->__anon1.op.exp1->destType)
15274 exp->__anon1.op.exp1->destType->refCount++;
15275 }
15276 }
15277 else
15278 {
15279 if(exp->__anon1.op.exp2->destType)
15280 FreeType(exp->__anon1.op.exp2->destType);
15281 exp->__anon1.op.exp2->destType = type1;
15282 type1->refCount++;
15283 if(CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0))
15284 {
15285 if(exp->expType)
15286 FreeType(exp->expType);
15287 exp->expType = exp->__anon1.op.exp2->destType;
15288 if(exp->__anon1.op.exp2->destType)
15289 exp->__anon1.op.exp2->destType->refCount++;
15290 }
15291 else if(type1 && type2)
15292 {
15293 char expString1[10240];
15294 char expString2[10240];
15295 char type1String[1024];
15296 char type2String[1024];
15297
15298 expString1[0] = '\0';
15299 expString2[0] = '\0';
15300 type1String[0] = '\0';
15301 type2String[0] = '\0';
15302 if(inCompiler)
15303 {
15304 PrintExpression(exp->__anon1.op.exp1, expString1);
15305 __ecereNameSpace__ecere__sys__ChangeCh(expString1, '\n', ' ');
15306 PrintExpression(exp->__anon1.op.exp2, expString2);
15307 __ecereNameSpace__ecere__sys__ChangeCh(expString2, '\n', ' ');
15308 PrintType(exp->__anon1.op.exp1->expType, type1String, 0, 1);
15309 PrintType(exp->__anon1.op.exp2->expType, type2String, 0, 1);
15310 }
15311 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1String, expString2, type2String);
15312 if(type1->kind == 8 && type1->__anon1._class && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 4)
15313 {
15314 exp->expType = exp->__anon1.op.exp1->expType;
15315 if(exp->__anon1.op.exp1->expType)
15316 exp->__anon1.op.exp1->expType->refCount++;
15317 }
15318 else if(type2->kind == 8 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 4)
15319 {
15320 exp->expType = exp->__anon1.op.exp2->expType;
15321 if(exp->__anon1.op.exp2->expType)
15322 exp->__anon1.op.exp2->expType->refCount++;
15323 }
15324 }
15325 }
15326 }
15327 }
15328 else if(type2)
15329 {
15330 if(type2->kind == 8 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 4)
15331 {
15332 struct Type * oldType = exp->__anon1.op.exp1->expType;
15333
15334 exp->__anon1.op.exp1->expType = (((void *)0));
15335 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0))
15336 FreeType(oldType);
15337 else
15338 exp->__anon1.op.exp1->expType = oldType;
15339 }
15340 if(exp->__anon1.op.exp1->destType)
15341 FreeType(exp->__anon1.op.exp1->destType);
15342 exp->__anon1.op.exp1->destType = type2;
15343 type2->refCount++;
15344 if(CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0))
15345 {
15346 if(exp->expType)
15347 FreeType(exp->expType);
15348 exp->expType = exp->__anon1.op.exp1->destType;
15349 if(exp->__anon1.op.exp1->destType)
15350 exp->__anon1.op.exp1->destType->refCount++;
15351 }
15352 }
15353 }
15354 else if(type2 && (!type1 || (type2->kind == 8 && type1->kind != 8)))
15355 {
15356 if(type1 && type2->__anon1._class && type2->__anon1._class->__anon1.registered && type2->__anon1._class->__anon1.registered->type == 3)
15357 {
15358 if(exp->__anon1.op.exp1->destType)
15359 FreeType(exp->__anon1.op.exp1->destType);
15360 exp->__anon1.op.exp1->destType = type2->__anon1._class->__anon1.registered->dataType;
15361 if(type2->__anon1._class->__anon1.registered->dataType)
15362 type2->__anon1._class->__anon1.registered->dataType->refCount++;
15363 CheckExpressionType(exp->__anon1.op.exp1, exp->__anon1.op.exp1->destType, 0, 0);
15364 }
15365 if(exp->__anon1.op.op == '!')
15366 {
15367 exp->expType = MkClassType("bool");
15368 exp->expType->truth = 1;
15369 }
15370 else
15371 {
15372 exp->expType = type2;
15373 if(type2)
15374 type2->refCount++;
15375 }
15376 }
15377 else if(type1 && (!type2 || (type1->kind == 8 && type2->kind != 8)))
15378 {
15379 if(type2 && type1->__anon1._class && type1->__anon1._class->__anon1.registered && type1->__anon1._class->__anon1.registered->type == 3)
15380 {
15381 if(exp->__anon1.op.exp2->destType)
15382 FreeType(exp->__anon1.op.exp2->destType);
15383 exp->__anon1.op.exp2->destType = type1->__anon1._class->__anon1.registered->dataType;
15384 if(type1->__anon1._class->__anon1.registered->dataType)
15385 type1->__anon1._class->__anon1.registered->dataType->refCount++;
15386 CheckExpressionType(exp->__anon1.op.exp2, exp->__anon1.op.exp2->destType, 0, 0);
15387 }
15388 exp->expType = type1;
15389 if(type1)
15390 type1->refCount++;
15391 }
15392 }
15393 yylloc = exp->loc;
15394 if(exp->__anon1.op.exp1 && !exp->__anon1.op.exp1->expType)
15395 {
15396 char expString[10000];
15397
15398 expString[0] = '\0';
15399 if(inCompiler)
15400 {
15401 PrintExpression(exp->__anon1.op.exp1, expString);
15402 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
15403 }
15404 if(expString[0])
15405 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
15406 }
15407 if(exp->__anon1.op.exp2 && !exp->__anon1.op.exp2->expType)
15408 {
15409 char expString[10240];
15410
15411 expString[0] = '\0';
15412 if(inCompiler)
15413 {
15414 PrintExpression(exp->__anon1.op.exp2, expString);
15415 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
15416 }
15417 if(expString[0])
15418 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
15419 }
15420 if(boolResult)
15421 {
15422 FreeType(exp->expType);
15423 exp->expType = MkClassType("bool");
15424 exp->expType->truth = 1;
15425 }
15426 if(exp->__anon1.op.op != SIZEOF)
15427 exp->isConstant = (!exp->__anon1.op.exp1 || exp->__anon1.op.exp1->isConstant) && (!exp->__anon1.op.exp2 || exp->__anon1.op.exp2->isConstant);
15428 if(exp->__anon1.op.op == SIZEOF && exp->__anon1.op.exp2->expType)
15429 {
15430 DeclareType(exp->__anon1.op.exp2->expType, 0, 0);
15431 }
15432 if(exp->__anon1.op.op == DELETE && exp->__anon1.op.exp2 && exp->__anon1.op.exp2->expType && __ecereProp_Type_Get_specConst(exp->__anon1.op.exp2->expType))
15433 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "deleting const qualified object\n", (((void *)0))));
15434 yylloc = oldyylloc;
15435 FreeType(dummy);
15436 if(type2)
15437 FreeType(type2);
15438 break;
15439 }
15440 case 5:
15441 case 32:
15442 {
15443 struct Expression * e;
15444
15445 exp->isConstant = 1;
15446 for(e = (*exp->__anon1.list).first; e; e = e->next)
15447 {
15448 unsigned int inced = 0;
15449
15450 if(!e->next)
15451 {
15452 FreeType(e->destType);
15453 e->opDestType = exp->opDestType;
15454 e->destType = exp->destType;
15455 if(e->destType)
15456 {
15457 exp->destType->refCount++;
15458 e->destType->count++;
15459 inced = 1;
15460 }
15461 }
15462 ProcessExpressionType(e);
15463 if(inced)
15464 exp->destType->count--;
15465 if(!exp->expType && !e->next)
15466 {
15467 exp->expType = e->expType;
15468 if(e->expType)
15469 e->expType->refCount++;
15470 }
15471 if(!e->isConstant)
15472 exp->isConstant = 0;
15473 }
15474 e = (*exp->__anon1.list).first;
15475 if(!e->next && e->type == 8)
15476 {
15477 struct Expression * next = exp->next, * prev = exp->prev;
15478
15479 FreeType(exp->expType);
15480 FreeType(exp->destType);
15481 (__ecereNameSpace__ecere__com__eSystem_Delete(exp->__anon1.list), exp->__anon1.list = 0);
15482 *exp = *e;
15483 exp->prev = prev;
15484 exp->next = next;
15485 ((e ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
15486 ProcessExpressionType(exp);
15487 }
15488 break;
15489 }
15490 case 6:
15491 {
15492 struct Expression * e;
15493
15494 exp->isConstant = 1;
15495 ProcessExpressionType(exp->__anon1.index.exp);
15496 if(!exp->__anon1.index.exp->isConstant)
15497 exp->isConstant = 0;
15498 if(exp->__anon1.index.exp->expType)
15499 {
15500 struct Type * source = exp->__anon1.index.exp->expType;
15501
15502 if(source->kind == 8 && source->__anon1._class && source->__anon1._class->__anon1.registered)
15503 {
15504 struct __ecereNameSpace__ecere__com__Class * _class = source->__anon1._class->__anon1.registered;
15505 struct __ecereNameSpace__ecere__com__Class * c = _class->templateClass ? _class->templateClass : _class;
15506
15507 if(_class != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(c, containerClass) && _class->templateArgs)
15508 {
15509 exp->expType = ProcessTypeString(_class->templateArgs[2].__anon1.__anon1.dataTypeString, 0);
15510 if(exp->__anon1.index.index && (*exp->__anon1.index.index).last)
15511 {
15512 struct Type * type = ProcessTypeString(_class->templateArgs[1].__anon1.__anon1.dataTypeString, 0);
15513
15514 if(type->kind == 8)
15515 type->constant = 1;
15516 else if(type->kind == 13)
15517 {
15518 struct Type * t = type;
15519
15520 while(t->kind == 13)
15521 t = t->__anon1.type;
15522 t->constant = 1;
15523 }
15524 ((struct Expression *)(*exp->__anon1.index.index).last)->destType = type;
15525 }
15526 }
15527 }
15528 }
15529 for(e = (*exp->__anon1.index.index).first; e; e = e->next)
15530 {
15531 if(!e->next && exp->__anon1.index.exp->expType && exp->__anon1.index.exp->expType->kind == 12 && exp->__anon1.index.exp->expType->__anon1.__anon4.enumClass)
15532 {
15533 if(e->destType)
15534 FreeType(e->destType);
15535 e->destType = MkClassType(exp->__anon1.index.exp->expType->__anon1.__anon4.enumClass->string);
15536 }
15537 ProcessExpressionType(e);
15538 if(!e->next)
15539 {
15540 }
15541 if(!e->isConstant)
15542 exp->isConstant = 0;
15543 }
15544 if(!exp->expType)
15545 exp->expType = Dereference(exp->__anon1.index.exp->expType);
15546 if(exp->expType)
15547 DeclareType(exp->expType, 0, 0);
15548 break;
15549 }
15550 case 7:
15551 {
15552 struct Expression * e;
15553 struct Type * functionType;
15554 struct Type * methodType = (((void *)0));
15555 char name[1024];
15556
15557 name[0] = '\0';
15558 if(inCompiler)
15559 {
15560 PrintExpression(exp->__anon1.call.exp, name);
15561 if(exp->__anon1.call.exp->expType && !exp->__anon1.call.exp->expType->__anon1.__anon2.returnType)
15562 {
15563 PrintExpression(exp->__anon1.call.exp, name);
15564 }
15565 }
15566 if(exp->__anon1.call.exp->type == 0)
15567 {
15568 struct Expression * idExp = exp->__anon1.call.exp;
15569 struct Identifier * id = idExp->__anon1.__anon1.identifier;
15570
15571 if(!strcmp(id->string, "__builtin_frame_address"))
15572 {
15573 exp->expType = ProcessTypeString("void *", 1);
15574 if(exp->__anon1.call.arguments && (*exp->__anon1.call.arguments).first)
15575 ProcessExpressionType((*exp->__anon1.call.arguments).first);
15576 break;
15577 }
15578 else if(!strcmp(id->string, "__ENDIAN_PAD"))
15579 {
15580 exp->expType = ProcessTypeString("int", 1);
15581 if(exp->__anon1.call.arguments && (*exp->__anon1.call.arguments).first)
15582 ProcessExpressionType((*exp->__anon1.call.arguments).first);
15583 break;
15584 }
15585 else if(!strcmp(id->string, "Max") || !strcmp(id->string, "Min") || !strcmp(id->string, "Sgn") || !strcmp(id->string, "Abs"))
15586 {
15587 struct Expression * a = (((void *)0));
15588 struct Expression * b = (((void *)0));
15589 struct Expression * tempExp1 = (((void *)0)), * tempExp2 = (((void *)0));
15590
15591 if((!strcmp(id->string, "Max") || !strcmp(id->string, "Min")) && (*exp->__anon1.call.arguments).count == 2)
15592 {
15593 a = (*exp->__anon1.call.arguments).first;
15594 b = (*exp->__anon1.call.arguments).last;
15595 tempExp1 = a;
15596 tempExp2 = b;
15597 }
15598 else if((*exp->__anon1.call.arguments).count == 1)
15599 {
15600 a = (*exp->__anon1.call.arguments).first;
15601 tempExp1 = a;
15602 }
15603 if(a)
15604 {
15605 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear((&*exp->__anon1.call.arguments));
15606 idExp->__anon1.__anon1.identifier = (((void *)0));
15607 FreeExpContents(exp);
15608 ProcessExpressionType(a);
15609 if(b)
15610 ProcessExpressionType(b);
15611 exp->type = 5;
15612 exp->__anon1.list = MkList();
15613 if(a->expType && (!b || b->expType))
15614 {
15615 if((!a->isConstant && a->type != 0) || (b && !b->isConstant && b->type != 0))
15616 {
15617 if(inCompiler)
15618 {
15619 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
15620 struct __ecereNameSpace__ecere__sys__OldList * decls = MkList();
15621 struct Declaration * decl;
15622 char temp1[1024], temp2[1024];
15623
15624 GetTypeSpecs(a->expType, specs);
15625 if(a && !a->isConstant && a->type != 0)
15626 {
15627 sprintf(temp1, "__simpleStruct%d", curContext->simpleID++);
15628 ListAdd(decls, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(temp1)), (((void *)0))));
15629 tempExp1 = QMkExpId(temp1);
15630 tempExp1->expType = a->expType;
15631 if(a->expType)
15632 a->expType->refCount++;
15633 ListAdd(exp->__anon1.list, MkExpOp(CopyExpression(tempExp1), '=', a));
15634 }
15635 if(b && !b->isConstant && b->type != 0)
15636 {
15637 sprintf(temp2, "__simpleStruct%d", curContext->simpleID++);
15638 ListAdd(decls, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(temp2)), (((void *)0))));
15639 tempExp2 = QMkExpId(temp2);
15640 tempExp2->expType = b->expType;
15641 if(b->expType)
15642 b->expType->refCount++;
15643 ListAdd(exp->__anon1.list, MkExpOp(CopyExpression(tempExp2), '=', b));
15644 }
15645 decl = MkDeclaration(specs, decls);
15646 if(!curCompound->__anon1.compound.declarations)
15647 curCompound->__anon1.compound.declarations = MkList();
15648 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->__anon1.compound.declarations), (((void *)0)), decl);
15649 }
15650 }
15651 }
15652 if(!strcmp(id->string, "Max") || !strcmp(id->string, "Min"))
15653 {
15654 int op = (!strcmp(id->string, "Max")) ? '>' : '<';
15655
15656 ListAdd(exp->__anon1.list, MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(tempExp1), op, CopyExpression(tempExp2)))), MkListOne(CopyExpression(tempExp1)), CopyExpression(tempExp2)));
15657 exp->expType = a->expType;
15658 if(a->expType)
15659 a->expType->refCount++;
15660 }
15661 else if(!strcmp(id->string, "Abs"))
15662 {
15663 ListAdd(exp->__anon1.list, MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(tempExp1), '<', MkExpConstant("0")))), MkListOne(MkExpOp((((void *)0)), '-', CopyExpression(tempExp1))), CopyExpression(tempExp1)));
15664 exp->expType = a->expType;
15665 if(a->expType)
15666 a->expType->refCount++;
15667 }
15668 else if(!strcmp(id->string, "Sgn"))
15669 {
15670 ListAdd(exp->__anon1.list, MkExpCondition(MkExpBrackets(MkListOne(MkExpOp((((void *)0)), '!', CopyExpression(tempExp1)))), MkListOne(MkExpConstant("0")), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(tempExp1), '<', MkExpConstant("0")))), MkListOne(MkExpConstant("-1")), MkExpConstant("1"))))));
15671 exp->expType = ProcessTypeString("int", 0);
15672 }
15673 FreeExpression(tempExp1);
15674 if(tempExp2)
15675 FreeExpression(tempExp2);
15676 FreeIdentifier(id);
15677 break;
15678 }
15679 }
15680 }
15681 {
15682 struct Type * dummy = (dummy = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), dummy->count = 1, dummy->refCount = 1, dummy);
15683
15684 if(!exp->__anon1.call.exp->destType)
15685 {
15686 exp->__anon1.call.exp->destType = dummy;
15687 dummy->refCount++;
15688 }
15689 ProcessExpressionType(exp->__anon1.call.exp);
15690 if(exp->__anon1.call.exp->destType == dummy)
15691 {
15692 FreeType(dummy);
15693 exp->__anon1.call.exp->destType = (((void *)0));
15694 }
15695 FreeType(dummy);
15696 }
15697 functionType = exp->__anon1.call.exp->expType;
15698 if(functionType && functionType->kind == 16)
15699 {
15700 methodType = functionType;
15701 functionType = methodType->__anon1.__anon3.method->dataType;
15702 if(exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass)
15703 {
15704 char typeString[1024];
15705
15706 typeString[0] = '\0';
15707 {
15708 struct Symbol * back = functionType->__anon1.__anon2.thisClass;
15709
15710 functionType->__anon1.__anon2.thisClass = (((void *)0));
15711 PrintType(functionType, typeString, 1, 1);
15712 functionType->__anon1.__anon2.thisClass = back;
15713 }
15714 if(strstr(typeString, "thisclass"))
15715 {
15716 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
15717 struct Declarator * decl;
15718
15719 {
15720 struct Context * context = SetupTemplatesContext(exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass);
15721
15722 decl = SpecDeclFromString(typeString, specs, (((void *)0)));
15723 if(thisClass != (exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass->templateClass ? exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass->templateClass : exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass))
15724 thisClassParams = 0;
15725 ReplaceThisClassSpecifiers(specs, exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass);
15726 {
15727 struct __ecereNameSpace__ecere__com__Class * backupThisClass = thisClass;
15728
15729 thisClass = exp->__anon1.call.exp->expType->__anon1.__anon3.usedClass;
15730 ProcessDeclarator(decl);
15731 thisClass = backupThisClass;
15732 }
15733 thisClassParams = 1;
15734 functionType = ProcessType(specs, decl);
15735 functionType->refCount = 0;
15736 FinishTemplatesContext(context);
15737 }
15738 FreeList(specs, (void *)(FreeSpecifier));
15739 FreeDeclarator(decl);
15740 }
15741 }
15742 }
15743 if(functionType && functionType->kind == 13 && functionType->__anon1.type && functionType->__anon1.type->kind == 11)
15744 {
15745 struct Type * type = functionType->__anon1.type;
15746
15747 if(!functionType->refCount)
15748 {
15749 functionType->__anon1.type = (((void *)0));
15750 FreeType(functionType);
15751 }
15752 functionType = type;
15753 }
15754 if(functionType && functionType->kind != 11)
15755 {
15756 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "called object %s is not a function\n", (((void *)0))), name);
15757 }
15758 else if(functionType)
15759 {
15760 unsigned int emptyParams = 0, noParams = 0;
15761 struct Expression * e = exp->__anon1.call.arguments ? (*exp->__anon1.call.arguments).first : (((void *)0));
15762 struct Type * type = functionType->__anon1.__anon2.params.first;
15763 struct Expression * memberExp = (exp->__anon1.call.exp->type == 8) ? exp->__anon1.call.exp : (((void *)0));
15764 int extra = 0;
15765 struct Location oldyylloc = yylloc;
15766
15767 if(!type)
15768 emptyParams = 1;
15769 if(functionType->extraParam && e && functionType->__anon1.__anon2.thisClass)
15770 {
15771 e->destType = MkClassType(functionType->__anon1.__anon2.thisClass->string);
15772 e = e->next;
15773 }
15774 if(!functionType->__anon1.__anon2.staticMethod && !functionType->extraParam)
15775 {
15776 if(memberExp && memberExp->__anon1.member.exp && memberExp->__anon1.member.exp->expType && memberExp->__anon1.member.exp->expType->kind == 19 && memberExp->__anon1.member.exp->expType->__anon1._class)
15777 {
15778 type = MkClassType(memberExp->__anon1.member.exp->expType->__anon1._class->string);
15779 if(e)
15780 {
15781 e->destType = type;
15782 e = e->next;
15783 type = functionType->__anon1.__anon2.params.first;
15784 }
15785 else
15786 type->refCount = 0;
15787 }
15788 else if(!memberExp && (functionType->__anon1.__anon2.thisClass || (methodType && methodType->__anon1.__anon3.methodClass)))
15789 {
15790 type = MkClassType(functionType->__anon1.__anon2.thisClass ? functionType->__anon1.__anon2.thisClass->string : (methodType ? methodType->__anon1.__anon3.methodClass->fullName : (((void *)0))));
15791 type->byReference = functionType->byReference;
15792 type->typedByReference = functionType->typedByReference;
15793 if(e)
15794 {
15795 if(e->next && type->kind == 8 && (functionType && functionType->__anon1.__anon2.thisClass) && functionType->classObjectType == 2)
15796 e = e->next;
15797 e->destType = type;
15798 e = e->next;
15799 type = functionType->__anon1.__anon2.params.first;
15800 }
15801 else
15802 type->refCount = 0;
15803 }
15804 }
15805 if(type && type->kind == 0)
15806 {
15807 noParams = 1;
15808 if(!type->refCount)
15809 FreeType(type);
15810 type = (((void *)0));
15811 }
15812 for(; e; e = e->next)
15813 {
15814 if(!type && !emptyParams)
15815 {
15816 yylloc = e->loc;
15817 if(methodType && methodType->__anon1.__anon3.methodClass)
15818 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->__anon1.__anon3.methodClass->fullName, methodType->__anon1.__anon3.method->name, (*exp->__anon1.call.arguments).count, noParams ? 0 : functionType->__anon1.__anon2.params.count);
15819 else
15820 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, (*exp->__anon1.call.arguments).count, noParams ? 0 : functionType->__anon1.__anon2.params.count);
15821 break;
15822 }
15823 if(methodType && type && type->kind == 20 && type->__anon1.templateParameter->type == 0)
15824 {
15825 struct Type * templatedType = (((void *)0));
15826 struct __ecereNameSpace__ecere__com__Class * _class = methodType->__anon1.__anon3.usedClass;
15827 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
15828 int id = 0;
15829
15830 if(_class && _class->templateArgs)
15831 {
15832 struct __ecereNameSpace__ecere__com__Class * sClass;
15833
15834 for(sClass = _class; sClass; sClass = sClass->base)
15835 {
15836 if(sClass->templateClass)
15837 sClass = sClass->templateClass;
15838 id = 0;
15839 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
15840 {
15841 if(curParam->type == 0 && !strcmp(type->__anon1.templateParameter->identifier->string, curParam->name))
15842 {
15843 struct __ecereNameSpace__ecere__com__Class * nextClass;
15844
15845 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
15846 {
15847 if(nextClass->templateClass)
15848 nextClass = nextClass->templateClass;
15849 id += nextClass->templateParams.count;
15850 }
15851 break;
15852 }
15853 id++;
15854 }
15855 if(curParam)
15856 break;
15857 }
15858 }
15859 if(curParam && _class->templateArgs[id].__anon1.__anon1.dataTypeString)
15860 {
15861 unsigned int constant = type->constant;
15862 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg = _class->templateArgs[id];
15863
15864 {
15865 struct Context * context = SetupTemplatesContext(_class);
15866
15867 templatedType = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
15868 FinishTemplatesContext(context);
15869 }
15870 if(templatedType->kind == 8 && constant)
15871 templatedType->constant = 1;
15872 else if(templatedType->kind == 13)
15873 {
15874 struct Type * t = templatedType->__anon1.type;
15875
15876 while(t->kind == 13)
15877 t = t->__anon1.type;
15878 if(constant)
15879 t->constant = constant;
15880 }
15881 e->destType = templatedType;
15882 if(templatedType)
15883 {
15884 templatedType->passAsTemplate = 1;
15885 }
15886 }
15887 else
15888 {
15889 e->destType = type;
15890 if(type)
15891 type->refCount++;
15892 }
15893 }
15894 else
15895 {
15896 if(type && type->kind == 14 && type->prev && type->prev->kind == 8 && type->prev->classObjectType)
15897 {
15898 e->destType = type->prev;
15899 e->destType->refCount++;
15900 }
15901 else
15902 {
15903 e->destType = type;
15904 if(type)
15905 type->refCount++;
15906 }
15907 }
15908 if(type && type->kind != 14)
15909 {
15910 struct Type * next = type->next;
15911
15912 if(!type->refCount)
15913 FreeType(type);
15914 type = next;
15915 }
15916 }
15917 if(type && type->kind != 14)
15918 {
15919 if(methodType && methodType->__anon1.__anon3.methodClass)
15920 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->__anon1.__anon3.methodClass->fullName, methodType->__anon1.__anon3.method->name, exp->__anon1.call.arguments ? (*exp->__anon1.call.arguments).count : 0, functionType->__anon1.__anon2.params.count + extra);
15921 else
15922 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, exp->__anon1.call.arguments ? (*exp->__anon1.call.arguments).count : 0, functionType->__anon1.__anon2.params.count + extra);
15923 }
15924 yylloc = oldyylloc;
15925 if(type && !type->refCount)
15926 FreeType(type);
15927 }
15928 else
15929 {
15930 functionType = __extension__ ({
15931 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
15932
15933 __ecereInstance1->refCount = 0, __ecereInstance1->kind = 11, __ecereInstance1;
15934 });
15935 if(exp->__anon1.call.exp->type == 0)
15936 {
15937 char * string = exp->__anon1.call.exp->__anon1.__anon1.identifier->string;
15938
15939 if(inCompiler)
15940 {
15941 struct Symbol * symbol;
15942 struct Location oldyylloc = yylloc;
15943
15944 yylloc = exp->__anon1.call.exp->__anon1.__anon1.identifier->loc;
15945 if(strstr(string, "__builtin_") == string)
15946 {
15947 if(exp->destType)
15948 {
15949 functionType->__anon1.__anon2.returnType = exp->destType;
15950 exp->destType->refCount++;
15951 }
15952 }
15953 else
15954 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s undefined; assuming extern returning int\n", (((void *)0))), string);
15955 symbol = __extension__ ({
15956 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
15957
15958 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1->type = ProcessTypeString("int()", 1), __ecereInstance1;
15959 });
15960 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)symbol);
15961 if(strstr(symbol->string, "::"))
15962 globalContext->hasNameSpace = 1;
15963 yylloc = oldyylloc;
15964 }
15965 }
15966 else if(exp->__anon1.call.exp->type == 8)
15967 {
15968 }
15969 else
15970 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "callable object undefined; extern assuming returning int\n", (((void *)0))));
15971 if(!functionType->__anon1.__anon2.returnType)
15972 {
15973 functionType->__anon1.__anon2.returnType = __extension__ ({
15974 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
15975
15976 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 3, __ecereInstance1;
15977 });
15978 }
15979 }
15980 if(functionType && functionType->kind == 11)
15981 {
15982 exp->expType = functionType->__anon1.__anon2.returnType;
15983 if(functionType->__anon1.__anon2.returnType)
15984 functionType->__anon1.__anon2.returnType->refCount++;
15985 if(!functionType->refCount)
15986 FreeType(functionType);
15987 }
15988 if(exp->__anon1.call.arguments)
15989 {
15990 for(e = (*exp->__anon1.call.arguments).first; e; e = e->next)
15991 ProcessExpressionType(e);
15992 }
15993 break;
15994 }
15995 case 8:
15996 {
15997 struct Type * type;
15998 struct Location oldyylloc = yylloc;
15999 unsigned int thisPtr;
16000 struct Expression * checkExp = exp->__anon1.member.exp;
16001
16002 while(checkExp)
16003 {
16004 if(checkExp->type == 11)
16005 checkExp = checkExp->__anon1.cast.exp;
16006 else if(checkExp->type == 5)
16007 checkExp = checkExp->__anon1.list ? (*checkExp->__anon1.list).first : (((void *)0));
16008 else
16009 break;
16010 }
16011 thisPtr = (checkExp && checkExp->type == 0 && !strcmp(checkExp->__anon1.__anon1.identifier->string, "this"));
16012 exp->thisPtr = thisPtr;
16013 if(exp->__anon1.member.member && exp->__anon1.member.member->_class && exp->__anon1.member.member->_class->__anon1.__anon1.name)
16014 {
16015 exp->__anon1.member.member->classSym = exp->__anon1.member.member->_class->__anon1.__anon1.symbol;
16016 }
16017 ProcessExpressionType(exp->__anon1.member.exp);
16018 if(exp->__anon1.member.exp->expType && exp->__anon1.member.exp->expType->kind == 8 && exp->__anon1.member.exp->expType->__anon1._class && exp->__anon1.member.exp->expType->__anon1._class->__anon1.registered && exp->__anon1.member.exp->expType->__anon1._class->__anon1.registered->type == 0)
16019 {
16020 exp->isConstant = 0;
16021 }
16022 else
16023 exp->isConstant = exp->__anon1.member.exp->isConstant;
16024 type = exp->__anon1.member.exp->expType;
16025 yylloc = exp->loc;
16026 if(type && (type->kind == 20))
16027 {
16028 struct __ecereNameSpace__ecere__com__Class * _class = thisClass ? thisClass : currentClass;
16029 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param = (((void *)0));
16030
16031 if(_class)
16032 {
16033 for(param = _class->templateParams.first; param; param = param->next)
16034 {
16035 if(param->type == 1 && exp->__anon1.member.member && exp->__anon1.member.member->string && !strcmp(param->name, exp->__anon1.member.member->string))
16036 break;
16037 }
16038 }
16039 if(param && param->defaultArg.__anon1.__anon2.__anon1.member)
16040 {
16041 struct Expression * argExp = GetTemplateArgExpByName(param->name, thisClass, 1);
16042
16043 if(argExp)
16044 {
16045 struct Expression * expMember = exp->__anon1.member.exp;
16046 struct Declarator * decl;
16047 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
16048 char thisClassTypeString[1024];
16049
16050 FreeIdentifier(exp->__anon1.member.member);
16051 ProcessExpressionType(argExp);
16052 {
16053 char * colon = strstr(param->defaultArg.__anon1.__anon2.memberString, "::");
16054
16055 if(colon)
16056 {
16057 memcpy(thisClassTypeString, param->defaultArg.__anon1.__anon2.memberString, colon - param->defaultArg.__anon1.__anon2.memberString);
16058 thisClassTypeString[colon - param->defaultArg.__anon1.__anon2.memberString] = '\0';
16059 }
16060 else
16061 strcpy(thisClassTypeString, _class->fullName);
16062 }
16063 decl = SpecDeclFromString(param->defaultArg.__anon1.__anon2.__anon1.member->dataTypeString, specs, (((void *)0)));
16064 exp->expType = ProcessType(specs, decl);
16065 if(exp->expType->kind == 8 && exp->expType->__anon1._class && exp->expType->__anon1._class->__anon1.registered && exp->expType->__anon1._class->__anon1.registered->templateClass)
16066 {
16067 struct __ecereNameSpace__ecere__com__Class * expClass = exp->expType->__anon1._class->__anon1.registered;
16068 struct __ecereNameSpace__ecere__com__Class * cClass = (((void *)0));
16069 int paramCount = 0;
16070 int lastParam = -1;
16071 char templateString[1024];
16072 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
16073
16074 sprintf(templateString, "%s<", expClass->templateClass->fullName);
16075 for(cClass = expClass; cClass; cClass = cClass->base)
16076 {
16077 int p = 0;
16078
16079 for(param = cClass->templateParams.first; param; param = param->next)
16080 {
16081 int id = p;
16082 struct __ecereNameSpace__ecere__com__Class * sClass;
16083 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg;
16084
16085 for(sClass = cClass->base; sClass; sClass = sClass->base)
16086 id += sClass->templateParams.count;
16087 arg = expClass->templateArgs[id];
16088 for(sClass = _class; sClass; sClass = sClass->base)
16089 {
16090 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
16091 int p = 0;
16092 struct __ecereNameSpace__ecere__com__Class * nextClass;
16093
16094 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
16095 p += nextClass->templateParams.count;
16096 for(cParam = sClass->templateParams.first; cParam; cParam = cParam->next, p++)
16097 {
16098 if(cParam->type == 0 && arg.__anon1.__anon1.dataTypeString && !strcmp(cParam->name, arg.__anon1.__anon1.dataTypeString))
16099 {
16100 if(_class->templateArgs && arg.__anon1.__anon1.dataTypeString && (!param->defaultArg.__anon1.__anon1.dataTypeString || strcmp(arg.__anon1.__anon1.dataTypeString, param->defaultArg.__anon1.__anon1.dataTypeString)))
16101 {
16102 arg.__anon1.__anon1.dataTypeString = _class->templateArgs[p].__anon1.__anon1.dataTypeString;
16103 arg.__anon1.__anon1.dataTypeClass = _class->templateArgs[p].__anon1.__anon1.dataTypeClass;
16104 break;
16105 }
16106 }
16107 }
16108 }
16109 {
16110 char argument[256];
16111
16112 argument[0] = '\0';
16113 switch(param->type)
16114 {
16115 case 2:
16116 {
16117 char expString[1024];
16118 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
16119 struct Declarator * decl = SpecDeclFromString(param->__anon1.dataTypeString, specs, (((void *)0)));
16120 struct Expression * exp;
16121 char * string = PrintHexUInt64(arg.__anon1.expression.__anon1.ui64);
16122
16123 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
16124 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
16125 ProcessExpressionType(exp);
16126 ComputeExpression(exp);
16127 expString[0] = '\0';
16128 PrintExpression(exp, expString);
16129 strcat(argument, expString);
16130 FreeExpression(exp);
16131 break;
16132 }
16133 case 1:
16134 {
16135 strcat(argument, arg.__anon1.__anon2.__anon1.member->name);
16136 break;
16137 }
16138 case 0:
16139 {
16140 if(arg.__anon1.__anon1.dataTypeString && (!param->defaultArg.__anon1.__anon1.dataTypeString || strcmp(arg.__anon1.__anon1.dataTypeString, param->defaultArg.__anon1.__anon1.dataTypeString)))
16141 {
16142 if(!strcmp(arg.__anon1.__anon1.dataTypeString, "thisclass"))
16143 strcat(argument, thisClassTypeString);
16144 else
16145 strcat(argument, arg.__anon1.__anon1.dataTypeString);
16146 }
16147 break;
16148 }
16149 }
16150 if(argument[0])
16151 {
16152 if(paramCount)
16153 strcat(templateString, ", ");
16154 if(lastParam != p - 1)
16155 {
16156 strcat(templateString, param->name);
16157 strcat(templateString, " = ");
16158 }
16159 strcat(templateString, argument);
16160 paramCount++;
16161 lastParam = p;
16162 }
16163 p++;
16164 }
16165 }
16166 }
16167 {
16168 int len = strlen(templateString);
16169
16170 if(templateString[len - 1] == '>')
16171 templateString[len++] = ' ';
16172 templateString[len++] = '>';
16173 templateString[len++] = '\0';
16174 }
16175 {
16176 struct Context * context = SetupTemplatesContext(_class);
16177
16178 FreeType(exp->expType);
16179 exp->expType = ProcessTypeString(templateString, 0);
16180 FinishTemplatesContext(context);
16181 }
16182 }
16183 if(!__ecereProp_Type_Get_isPointerType(expMember->expType))
16184 expMember = MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uintptr")), (((void *)0))), expMember);
16185 exp->type = 5;
16186 exp->__anon1.list = MkListOne(MkExpOp((((void *)0)), '*', MkExpCast(MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl)), MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), expMember))), '+', MkExpOp(MkExpMember(MkExpMember(argExp, MkIdentifier("member")), MkIdentifier("offset")), '+', MkExpMember(MkExpMember(MkExpMember(CopyExpression(argExp), MkIdentifier("member")), MkIdentifier("_class")), MkIdentifier("offset")))))))));
16187 }
16188 }
16189 else if(type->__anon1.templateParameter && type->__anon1.templateParameter->type == 0 && (type->__anon1.templateParameter->__anon1.dataType || type->__anon1.templateParameter->dataTypeString))
16190 {
16191 type = ProcessTemplateParameterType(type->__anon1.templateParameter);
16192 }
16193 }
16194 if(type && (type->kind == 20))
16195 ;
16196 else if(type && (type->kind == 8 || type->kind == 19 || type->kind == 3 || type->kind == 15 || type->kind == 4 || type->kind == 2 || type->kind == 5 || type->kind == 1 || type->kind == 24 || type->kind == 22 || type->kind == 23 || type->kind == 6 || type->kind == 7 || (type->kind == 13 && type->__anon1.type->kind == 1)))
16197 {
16198 struct Identifier * id = exp->__anon1.member.member;
16199 int typeKind = type->kind;
16200 struct __ecereNameSpace__ecere__com__Class * _class = (id && (!id->_class || id->_class->__anon1.__anon1.name)) ? (id->classSym ? id->classSym->__anon1.registered : (type->__anon1._class ? type->__anon1._class->__anon1.registered : (((void *)0)))) : (((void *)0));
16201
16202 if(typeKind == 19 && exp->__anon1.member.exp->type == 24)
16203 {
16204 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "ecere::com::Class");
16205 typeKind = 8;
16206 }
16207 if(id)
16208 {
16209 if(typeKind == 3 || typeKind == 15)
16210 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "int");
16211 else if(!_class)
16212 {
16213 if(type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered)
16214 {
16215 _class = type->__anon1._class->__anon1.registered;
16216 }
16217 else if((type->kind == 12 || type->kind == 13) && type->__anon1.type && type->__anon1.type->kind == 1)
16218 {
16219 _class = FindClass("char *")->__anon1.registered;
16220 }
16221 else if(type->kind == 13)
16222 {
16223 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "uintptr");
16224 FreeType(exp->expType);
16225 exp->expType = ProcessTypeString("uintptr", 0);
16226 exp->byReference = 1;
16227 }
16228 else
16229 {
16230 char string[1024] = "";
16231 struct Symbol * classSym;
16232
16233 PrintTypeNoConst(type, string, 0, 1);
16234 classSym = FindClass(string);
16235 if(classSym)
16236 _class = classSym->__anon1.registered;
16237 }
16238 }
16239 }
16240 if(_class && id)
16241 {
16242 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
16243 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
16244 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
16245 struct __ecereNameSpace__ecere__com__Property * revConvert = (((void *)0));
16246 struct __ecereNameSpace__ecere__com__ClassProperty * classProp = (((void *)0));
16247
16248 if(id && id->_class && id->_class->__anon1.__anon1.name && !strcmp(id->_class->__anon1.__anon1.name, "property"))
16249 exp->__anon1.member.memberType = 1;
16250 if(id && id->_class && type->__anon1._class && !__ecereNameSpace__ecere__com__eClass_IsDerived(type->__anon1._class->__anon1.registered, _class))
16251 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "invalid class specifier %s for object of class %s\n", (((void *)0))), _class->fullName, type->__anon1._class->string);
16252 if(typeKind != 19)
16253 {
16254 if((exp->__anon1.member.memberType == 0 && thisPtr) || exp->__anon1.member.memberType == 3)
16255 {
16256 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, id->string, privateModule, (((void *)0)), (((void *)0)));
16257 if(member && member->_class != (_class->templateClass ? _class->templateClass : _class) && exp->__anon1.member.memberType != 3)
16258 {
16259 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, privateModule);
16260 if(prop)
16261 member = (((void *)0));
16262 }
16263 if(!member && !prop)
16264 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, privateModule);
16265 if((member && member->_class == (_class->templateClass ? _class->templateClass : _class)) || (prop && prop->_class == (_class->templateClass ? _class->templateClass : _class)))
16266 exp->__anon1.member.thisPtr = 1;
16267 }
16268 else
16269 {
16270 unsigned int useMemberForNonConst = 0;
16271
16272 if(!id->classSym)
16273 {
16274 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, (((void *)0)));
16275 useMemberForNonConst = prop && exp->destType && ((exp->destType->kind == 8 && !exp->destType->constant) || ((exp->destType->kind == 13 || exp->destType->kind == 12) && exp->destType->__anon1.type && !exp->destType->__anon1.type->constant)) && !strncmp(prop->dataTypeString, "const ", 6);
16276 if(useMemberForNonConst || !id->_class || !id->_class->__anon1.__anon1.name || strcmp(id->_class->__anon1.__anon1.name, "property"))
16277 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, id->string, (((void *)0)), (((void *)0)), (((void *)0)));
16278 }
16279 if((!prop || useMemberForNonConst) && !member)
16280 {
16281 method = useMemberForNonConst ? (((void *)0)) : __ecereNameSpace__ecere__com__eClass_FindMethod(_class, id->string, (((void *)0)));
16282 if(!method)
16283 {
16284 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, id->string, privateModule);
16285 useMemberForNonConst |= prop && exp->destType && ((exp->destType->kind == 8 && !exp->destType->constant) || ((exp->destType->kind == 13 || exp->destType->kind == 12) && exp->destType->__anon1.type && !exp->destType->__anon1.type->constant)) && !strncmp(prop->dataTypeString, "const ", 6);
16286 if(useMemberForNonConst || !id->_class || !id->_class->__anon1.__anon1.name || strcmp(id->_class->__anon1.__anon1.name, "property"))
16287 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, id->string, privateModule, (((void *)0)), (((void *)0)));
16288 }
16289 }
16290 if(member && prop)
16291 {
16292 if(useMemberForNonConst || (member->_class != prop->_class && !id->_class && __ecereNameSpace__ecere__com__eClass_IsDerived(member->_class, prop->_class)))
16293 prop = (((void *)0));
16294 else
16295 member = (((void *)0));
16296 }
16297 }
16298 }
16299 if(!prop && !member && !method)
16300 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, id->string, privateModule);
16301 if(!prop && !member && !method)
16302 {
16303 if(typeKind == 19)
16304 {
16305 classProp = __ecereNameSpace__ecere__com__eClass_FindClassProperty(type->__anon1._class->__anon1.registered, exp->__anon1.member.member->string);
16306 if(classProp)
16307 {
16308 exp->__anon1.member.memberType = 5;
16309 exp->expType = ProcessTypeString(classProp->dataTypeString, 0);
16310 }
16311 else
16312 {
16313 char structName[1024];
16314 struct Identifier * id = exp->__anon1.member.member;
16315 struct Expression * classExp = exp->__anon1.member.exp;
16316
16317 type->refCount++;
16318 FreeType(classExp->expType);
16319 classExp->expType = ProcessTypeString("ecere::com::Class", 0);
16320 strcpy(structName, "__ecereClassData_");
16321 FullClassNameCat(structName, type->__anon1._class->string, 0);
16322 exp->type = 9;
16323 exp->__anon1.member.member = id;
16324 exp->__anon1.member.exp = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0)))), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpBrackets(MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpMember(classExp, MkIdentifier("data"))), '+', MkExpMember(MkExpClass(MkListOne(MkSpecifierName(type->__anon1._class->string)), (((void *)0))), MkIdentifier("offsetClass"))))))));
16325 FreeType(type);
16326 ProcessExpressionType(exp);
16327 return ;
16328 }
16329 }
16330 else
16331 {
16332 struct Symbol * classSym = FindClass(id->string);
16333
16334 if(classSym)
16335 {
16336 struct __ecereNameSpace__ecere__com__Class * convertClass = classSym->__anon1.registered;
16337
16338 if(convertClass)
16339 revConvert = __ecereNameSpace__ecere__com__eClass_FindProperty(convertClass, _class->fullName, privateModule);
16340 }
16341 }
16342 }
16343 if(exp->__anon1.member.exp->destType)
16344 FreeType(exp->__anon1.member.exp->destType);
16345 {
16346 if(method && !method->_class->symbol)
16347 method->_class->symbol = FindClass(method->_class->fullName);
16348 if(prop && !prop->_class->symbol)
16349 prop->_class->symbol = FindClass(prop->_class->fullName);
16350 exp->__anon1.member.exp->destType = __extension__ ({
16351 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16352
16353 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 8, __ecereInstance1->__anon1._class = prop ? prop->_class->symbol : method ? method->_class->symbol : _class->symbol, __ecereInstance1;
16354 });
16355 }
16356 if(prop)
16357 {
16358 exp->__anon1.member.memberType = 1;
16359 if(!prop->dataType)
16360 ProcessPropertyType(prop);
16361 exp->expType = prop->dataType;
16362 if(!strcmp(_class->base->fullName, "eda::Row") && !exp->expType->constant && !exp->destType)
16363 {
16364 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16365
16366 CopyTypeInto(type, exp->expType);
16367 type->refCount = 1;
16368 type->constant = 1;
16369 exp->expType = type;
16370 }
16371 else if(prop->dataType)
16372 prop->dataType->refCount++;
16373 }
16374 else if(member)
16375 {
16376 if(exp->__anon1.member.exp->expType->classObjectType == 2 && !strcmp(exp->__anon1.member.member->string, "_class"))
16377 {
16378 FreeExpContents(exp);
16379 exp->type = 0;
16380 exp->__anon1.__anon1.identifier = MkIdentifier("class");
16381 ProcessExpressionType(exp);
16382 return ;
16383 }
16384 exp->__anon1.member.memberType = 3;
16385 DeclareStruct(_class->fullName, 0);
16386 if(!member->dataType)
16387 {
16388 struct Context * context = SetupTemplatesContext(_class);
16389
16390 member->dataType = ProcessTypeString(member->dataTypeString, 0);
16391 FinishTemplatesContext(context);
16392 }
16393 exp->expType = member->dataType;
16394 if(member->dataType)
16395 member->dataType->refCount++;
16396 }
16397 else if(revConvert)
16398 {
16399 exp->__anon1.member.memberType = 4;
16400 exp->expType = MkClassType(revConvert->_class->fullName);
16401 }
16402 else if(method)
16403 {
16404 {
16405 exp->__anon1.member.memberType = 2;
16406 }
16407 if(!method->dataType)
16408 ProcessMethodType(method);
16409 exp->expType = __extension__ ({
16410 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16411
16412 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 16, __ecereInstance1->__anon1.__anon3.method = method, __ecereInstance1;
16413 });
16414 exp->expType->__anon1.__anon3.methodClass = (id && id->_class) ? _class : (((void *)0));
16415 exp->expType->__anon1.__anon3.usedClass = _class;
16416 }
16417 else if(!classProp)
16418 {
16419 if(exp->__anon1.member.exp->expType->classObjectType == 2 && !strcmp(exp->__anon1.member.member->string, "_class"))
16420 {
16421 FreeExpContents(exp);
16422 exp->type = 0;
16423 exp->__anon1.__anon1.identifier = MkIdentifier("class");
16424 FreeType(exp->expType);
16425 exp->expType = MkClassType("ecere::com::Class");
16426 return ;
16427 }
16428 yylloc = exp->__anon1.member.member->loc;
16429 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find member %s in class %s\n", (((void *)0))), id->string, _class->fullName);
16430 if(inCompiler)
16431 __ecereNameSpace__ecere__com__eClass_AddDataMember(_class, id->string, "int", 0, 0, 1);
16432 }
16433 if(_class && exp->expType)
16434 {
16435 struct __ecereNameSpace__ecere__com__Class * tClass;
16436
16437 tClass = type->__anon1._class && type->__anon1._class->__anon1.registered ? type->__anon1._class->__anon1.registered : _class;
16438 while(tClass && !tClass->templateClass)
16439 tClass = tClass->base;
16440 if(tClass && exp->expType->kind == 20 && exp->expType->__anon1.templateParameter->type == 0)
16441 {
16442 int id = 0;
16443 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
16444 struct __ecereNameSpace__ecere__com__Class * sClass;
16445
16446 for(sClass = tClass; sClass; sClass = sClass->base)
16447 {
16448 id = 0;
16449 if(sClass->templateClass)
16450 sClass = sClass->templateClass;
16451 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
16452 {
16453 if(curParam->type == 0 && !strcmp(exp->expType->__anon1.templateParameter->identifier->string, curParam->name))
16454 {
16455 for(sClass = sClass->base; sClass; sClass = sClass->base)
16456 id += sClass->templateParams.count;
16457 break;
16458 }
16459 id++;
16460 }
16461 if(curParam)
16462 break;
16463 }
16464 if(curParam && tClass->templateArgs[id].__anon1.__anon1.dataTypeString)
16465 {
16466 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg = tClass->templateArgs[id];
16467 struct Context * context = SetupTemplatesContext(tClass);
16468 unsigned int constant = exp->expType->constant;
16469
16470 FreeType(exp->expType);
16471 exp->expType = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
16472 if(exp->expType->kind == 8 && constant)
16473 exp->expType->constant = 1;
16474 else if(exp->expType->kind == 13)
16475 {
16476 struct Type * t = exp->expType->__anon1.type;
16477
16478 while(t->kind == 13)
16479 t = t->__anon1.type;
16480 if(constant)
16481 t->constant = constant;
16482 }
16483 if(exp->expType)
16484 {
16485 if(exp->expType->kind == 21)
16486 {
16487 FreeType(exp->expType);
16488 exp->expType = ReplaceThisClassType(_class);
16489 }
16490 if(tClass->templateClass && (exp->expType->kind != 20 || (!exp->expType->__anon1.templateParameter || (!exp->expType->__anon1.templateParameter->dataTypeString && !exp->expType->__anon1.templateParameter->__anon1.dataType))))
16491 exp->expType->passAsTemplate = 1;
16492 if(!exp->destType)
16493 {
16494 exp->destType = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
16495 if(exp->destType->kind == 8 && constant)
16496 exp->destType->constant = 1;
16497 else if(exp->destType->kind == 13)
16498 {
16499 struct Type * t = exp->destType->__anon1.type;
16500
16501 while(t->kind == 13)
16502 t = t->__anon1.type;
16503 if(constant)
16504 t->constant = constant;
16505 }
16506 if(exp->destType->kind == 21)
16507 {
16508 FreeType(exp->destType);
16509 exp->destType = ReplaceThisClassType(_class);
16510 }
16511 }
16512 }
16513 FinishTemplatesContext(context);
16514 }
16515 }
16516 else if(tClass && exp->expType->kind == 13 && exp->expType->__anon1.type && exp->expType->__anon1.type->kind == 20 && exp->expType->__anon1.type->__anon1.templateParameter->type == 0)
16517 {
16518 int id = 0;
16519 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
16520 struct __ecereNameSpace__ecere__com__Class * sClass;
16521
16522 for(sClass = tClass; sClass; sClass = sClass->base)
16523 {
16524 id = 0;
16525 if(sClass->templateClass)
16526 sClass = sClass->templateClass;
16527 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
16528 {
16529 if(curParam->type == 0 && !strcmp(exp->expType->__anon1.type->__anon1.templateParameter->identifier->string, curParam->name))
16530 {
16531 for(sClass = sClass->base; sClass; sClass = sClass->base)
16532 id += sClass->templateParams.count;
16533 break;
16534 }
16535 id++;
16536 }
16537 if(curParam)
16538 break;
16539 }
16540 if(curParam)
16541 {
16542 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg = tClass->templateArgs[id];
16543 struct Context * context = SetupTemplatesContext(tClass);
16544 struct Type * basicType;
16545
16546 basicType = ProcessTypeString(arg.__anon1.__anon1.dataTypeString, 0);
16547 if(basicType)
16548 {
16549 if(basicType->kind == 21)
16550 {
16551 FreeType(basicType);
16552 basicType = ReplaceThisClassType(_class);
16553 }
16554 FreeType(exp->expType);
16555 exp->expType = __extension__ ({
16556 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16557
16558 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 13, __ecereInstance1->__anon1.type = basicType, __ecereInstance1;
16559 });
16560 if(!exp->destType)
16561 {
16562 exp->destType = exp->expType;
16563 exp->destType->refCount++;
16564 }
16565 {
16566 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
16567 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
16568 struct Declarator * decl;
16569
16570 decl = SpecDeclFromString(arg.__anon1.__anon1.dataTypeString, specs, (((void *)0)));
16571 *newExp = *exp;
16572 if(exp->destType)
16573 exp->destType->refCount++;
16574 if(exp->expType)
16575 exp->expType->refCount++;
16576 exp->type = 11;
16577 exp->__anon1.cast.typeName = MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl));
16578 exp->__anon1.cast.exp = newExp;
16579 }
16580 }
16581 FinishTemplatesContext(context);
16582 }
16583 }
16584 else if(tClass && exp->expType->kind == 8 && exp->expType->__anon1._class && strchr(exp->expType->__anon1._class->string, '<'))
16585 {
16586 struct __ecereNameSpace__ecere__com__Class * expClass = exp->expType->__anon1._class->__anon1.registered;
16587
16588 if(expClass)
16589 {
16590 struct __ecereNameSpace__ecere__com__Class * cClass = (((void *)0));
16591 int p = 0;
16592 int paramCount = 0;
16593 int lastParam = -1;
16594 char templateString[1024];
16595 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
16596
16597 sprintf(templateString, "%s<", expClass->templateClass->fullName);
16598 while(cClass != expClass)
16599 {
16600 struct __ecereNameSpace__ecere__com__Class * sClass;
16601
16602 for(sClass = expClass; sClass && sClass->base != cClass; sClass = sClass->base)
16603 ;
16604 cClass = sClass;
16605 for(param = cClass->templateParams.first; param; param = param->next)
16606 {
16607 struct __ecereNameSpace__ecere__com__Class * cClassCur = (((void *)0));
16608 int cp = 0;
16609 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * paramCur = (((void *)0));
16610 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg;
16611
16612 while(cClassCur != tClass && !paramCur)
16613 {
16614 struct __ecereNameSpace__ecere__com__Class * sClassCur;
16615
16616 for(sClassCur = tClass; sClassCur && sClassCur->base != cClassCur; sClassCur = sClassCur->base)
16617 ;
16618 cClassCur = sClassCur;
16619 for(paramCur = cClassCur->templateParams.first; paramCur; paramCur = paramCur->next)
16620 {
16621 if(!strcmp(paramCur->name, param->name))
16622 {
16623 break;
16624 }
16625 cp++;
16626 }
16627 }
16628 if(paramCur && paramCur->type == 0)
16629 arg = tClass->templateArgs[cp];
16630 else
16631 arg = expClass->templateArgs[p];
16632 {
16633 char argument[256];
16634
16635 argument[0] = '\0';
16636 switch(param->type)
16637 {
16638 case 2:
16639 {
16640 char expString[1024];
16641 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
16642 struct Declarator * decl = SpecDeclFromString(param->__anon1.dataTypeString, specs, (((void *)0)));
16643 struct Expression * exp;
16644 char * string = PrintHexUInt64(arg.__anon1.expression.__anon1.ui64);
16645
16646 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
16647 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
16648 ProcessExpressionType(exp);
16649 ComputeExpression(exp);
16650 expString[0] = '\0';
16651 PrintExpression(exp, expString);
16652 strcat(argument, expString);
16653 FreeExpression(exp);
16654 break;
16655 }
16656 case 1:
16657 {
16658 strcat(argument, arg.__anon1.__anon2.__anon1.member->name);
16659 break;
16660 }
16661 case 0:
16662 {
16663 if(arg.__anon1.__anon1.dataTypeString && (!param->defaultArg.__anon1.__anon1.dataTypeString || strcmp(arg.__anon1.__anon1.dataTypeString, param->defaultArg.__anon1.__anon1.dataTypeString)))
16664 strcat(argument, arg.__anon1.__anon1.dataTypeString);
16665 break;
16666 }
16667 }
16668 if(argument[0])
16669 {
16670 if(paramCount)
16671 strcat(templateString, ", ");
16672 if(lastParam != p - 1)
16673 {
16674 strcat(templateString, param->name);
16675 strcat(templateString, " = ");
16676 }
16677 strcat(templateString, argument);
16678 paramCount++;
16679 lastParam = p;
16680 }
16681 }
16682 p++;
16683 }
16684 }
16685 {
16686 int len = strlen(templateString);
16687
16688 if(templateString[len - 1] == '>')
16689 templateString[len++] = ' ';
16690 templateString[len++] = '>';
16691 templateString[len++] = '\0';
16692 }
16693 FreeType(exp->expType);
16694 {
16695 struct Context * context = SetupTemplatesContext(tClass);
16696
16697 exp->expType = ProcessTypeString(templateString, 0);
16698 FinishTemplatesContext(context);
16699 }
16700 }
16701 }
16702 }
16703 }
16704 else
16705 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "undefined class %s\n", (((void *)0))), (id && (!id->_class || id->_class->__anon1.__anon1.name)) ? (id->classSym ? id->classSym->string : (type->__anon1._class ? type->__anon1._class->string : (((void *)0)))) : "(null)");
16706 }
16707 else if(type && (type->kind == 9 || type->kind == 10))
16708 {
16709 struct Type * memberType = exp->__anon1.member.member ? FindMember(type, exp->__anon1.member.member->string) : (((void *)0));
16710
16711 if(memberType)
16712 {
16713 exp->expType = memberType;
16714 if(memberType)
16715 memberType->refCount++;
16716 }
16717 }
16718 else
16719 {
16720 char expString[10240];
16721
16722 expString[0] = '\0';
16723 if(inCompiler)
16724 {
16725 PrintExpression(exp, expString);
16726 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
16727 }
16728 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "member operator on non-structure type expression %s\n", (((void *)0))), expString);
16729 }
16730 if(exp->expType && exp->expType->kind == 21 && (!exp->destType || exp->destType->kind != 21))
16731 {
16732 if(type && (type->kind == 8 || type->kind == 19 || type->kind == 3 || type->kind == 15))
16733 {
16734 struct Identifier * id = exp->__anon1.member.member;
16735 struct __ecereNameSpace__ecere__com__Class * _class = (id && (!id->_class || id->_class->__anon1.__anon1.name)) ? (id->classSym ? id->classSym->__anon1.registered : (type->__anon1._class ? type->__anon1._class->__anon1.registered : (((void *)0)))) : (((void *)0));
16736
16737 if(_class)
16738 {
16739 FreeType(exp->expType);
16740 exp->expType = ReplaceThisClassType(_class);
16741 }
16742 }
16743 }
16744 yylloc = oldyylloc;
16745 break;
16746 }
16747 case 9:
16748 {
16749 struct Type * destType = exp->destType;
16750
16751 if(exp->__anon1.member.member && exp->__anon1.member.member->_class && exp->__anon1.member.member->_class->__anon1.__anon1.name)
16752 {
16753 exp->__anon1.member.member->classSym = exp->__anon1.member.member->_class->__anon1.__anon1.symbol;
16754 }
16755 exp->__anon1.member.exp = MkExpBrackets(MkListOne(MkExpOp((((void *)0)), '*', exp->__anon1.member.exp)));
16756 exp->type = 8;
16757 if(destType)
16758 destType->count++;
16759 ProcessExpressionType(exp);
16760 if(destType)
16761 destType->count--;
16762 break;
16763 }
16764 case 15:
16765 {
16766 struct Symbol * classSym = exp->__anon1._class->__anon1.__anon1.symbol;
16767
16768 if(classSym && classSym->__anon1.registered)
16769 {
16770 if(classSym->__anon1.registered->type == 5)
16771 {
16772 char name[1024];
16773
16774 name[0] = '\0';
16775 DeclareStruct(classSym->string, 0);
16776 FreeSpecifier(exp->__anon1._class);
16777 exp->type = 10;
16778 FullClassNameCat(name, classSym->string, 0);
16779 exp->__anon1.typeName = MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(name), (((void *)0)))), (((void *)0)));
16780 }
16781 else
16782 {
16783 if(classSym->__anon1.registered->fixed)
16784 {
16785 FreeSpecifier(exp->__anon1._class);
16786 exp->__anon1.__anon1.constant = PrintUInt(classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->structSize : classSym->__anon1.registered->structSize);
16787 exp->type = 2;
16788 }
16789 else
16790 {
16791 char className[1024];
16792
16793 strcpy(className, "__ecereClass_");
16794 FullClassNameCat(className, classSym->string, 1);
16795 DeclareClass(classSym, className);
16796 FreeExpContents(exp);
16797 exp->type = 9;
16798 exp->__anon1.member.exp = MkExpIdentifier(MkIdentifier(className));
16799 exp->__anon1.member.member = MkIdentifier("structSize");
16800 }
16801 }
16802 }
16803 exp->expType = __extension__ ({
16804 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16805
16806 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 23, __ecereInstance1;
16807 });
16808 break;
16809 }
16810 case 10:
16811 {
16812 struct Type * type = ProcessType(exp->__anon1.typeName->qualifiers, exp->__anon1.typeName->declarator);
16813
16814 exp->expType = __extension__ ({
16815 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
16816
16817 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 23, __ecereInstance1;
16818 });
16819 exp->isConstant = 1;
16820 DeclareType(type, 0, 0);
16821 FreeType(type);
16822 break;
16823 }
16824 case 11:
16825 {
16826 struct Type * type = ProcessType(exp->__anon1.cast.typeName->qualifiers, exp->__anon1.cast.typeName->declarator);
16827
16828 type->count = 1;
16829 FreeType(exp->__anon1.cast.exp->destType);
16830 exp->__anon1.cast.exp->destType = type;
16831 type->refCount++;
16832 type->casted = 1;
16833 ProcessExpressionType(exp->__anon1.cast.exp);
16834 type->casted = 0;
16835 type->count = 0;
16836 exp->expType = type;
16837 if(!exp->__anon1.cast.exp->needCast && !NeedCast(exp->__anon1.cast.exp->expType, type))
16838 {
16839 void * prev = exp->prev, * next = exp->next;
16840 struct Type * expType = exp->__anon1.cast.exp->destType;
16841 struct Expression * castExp = exp->__anon1.cast.exp;
16842 struct Type * destType = exp->destType;
16843
16844 if(expType)
16845 expType->refCount++;
16846 FreeType(exp->expType);
16847 FreeTypeName(exp->__anon1.cast.typeName);
16848 *exp = *castExp;
16849 FreeType(exp->expType);
16850 FreeType(exp->destType);
16851 exp->expType = expType;
16852 exp->destType = destType;
16853 ((castExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)castExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(castExp)) : 0), castExp = 0);
16854 exp->prev = prev;
16855 exp->next = next;
16856 }
16857 else
16858 {
16859 exp->isConstant = exp->__anon1.cast.exp->isConstant;
16860 }
16861 break;
16862 }
16863 case 33:
16864 {
16865 struct Type * type = ProcessType(exp->__anon1.initializer.typeName->qualifiers, exp->__anon1.initializer.typeName->declarator);
16866
16867 exp->expType = type;
16868 break;
16869 }
16870 case 34:
16871 {
16872 struct Type * type = ProcessType(exp->__anon1.vaArg.typeName->qualifiers, exp->__anon1.vaArg.typeName->declarator);
16873
16874 ProcessExpressionType(exp->__anon1.vaArg.exp);
16875 exp->expType = type;
16876 break;
16877 }
16878 case 12:
16879 {
16880 struct Expression * e;
16881
16882 exp->isConstant = 1;
16883 FreeType(exp->__anon1.cond.cond->destType);
16884 exp->__anon1.cond.cond->destType = MkClassType("bool");
16885 exp->__anon1.cond.cond->destType->truth = 1;
16886 ProcessExpressionType(exp->__anon1.cond.cond);
16887 if(!exp->__anon1.cond.cond->isConstant)
16888 exp->isConstant = 0;
16889 for(e = (*exp->__anon1.cond.exp).first; e; e = e->next)
16890 {
16891 if(!e->next)
16892 {
16893 FreeType(e->destType);
16894 e->destType = exp->destType;
16895 if(e->destType)
16896 e->destType->refCount++;
16897 }
16898 ProcessExpressionType(e);
16899 if(!e->next)
16900 {
16901 exp->expType = e->expType;
16902 if(e->expType)
16903 e->expType->refCount++;
16904 }
16905 if(!e->isConstant)
16906 exp->isConstant = 0;
16907 }
16908 FreeType(exp->__anon1.cond.elseExp->destType);
16909 exp->__anon1.cond.elseExp->destType = exp->destType ? exp->destType : exp->expType;
16910 if(exp->__anon1.cond.elseExp->destType)
16911 exp->__anon1.cond.elseExp->destType->refCount++;
16912 ProcessExpressionType(exp->__anon1.cond.elseExp);
16913 if(!exp->__anon1.cond.elseExp->isConstant)
16914 exp->isConstant = 0;
16915 break;
16916 }
16917 case 23:
16918 {
16919 if(exp->__anon1.compound && exp->__anon1.compound->__anon1.compound.statements && (*exp->__anon1.compound->__anon1.compound.statements).last)
16920 {
16921 struct Statement * last = (*exp->__anon1.compound->__anon1.compound.statements).last;
16922
16923 if(last->type == 3 && last->__anon1.expressions && (*last->__anon1.expressions).last)
16924 {
16925 ((struct Expression *)(*last->__anon1.expressions).last)->destType = exp->destType;
16926 if(exp->destType)
16927 exp->destType->refCount++;
16928 }
16929 ProcessStatement(exp->__anon1.compound);
16930 exp->expType = (last->__anon1.expressions && (*last->__anon1.expressions).last) ? ((struct Expression *)(*last->__anon1.expressions).last)->expType : (((void *)0));
16931 if(exp->expType)
16932 exp->expType->refCount++;
16933 }
16934 break;
16935 }
16936 case 24:
16937 {
16938 struct Specifier * spec = (*exp->__anon1._classExp.specifiers).first;
16939
16940 if(spec && spec->type == 1)
16941 {
16942 exp->expType = MkClassType(spec->__anon1.__anon1.name);
16943 exp->expType->kind = 19;
16944 exp->byReference = 1;
16945 }
16946 else
16947 {
16948 exp->expType = MkClassType("ecere::com::Class");
16949 exp->byReference = 1;
16950 }
16951 break;
16952 }
16953 case 25:
16954 {
16955 struct __ecereNameSpace__ecere__com__Class * _class = thisClass ? thisClass : currentClass;
16956
16957 if(_class)
16958 {
16959 struct Identifier * id = exp->__anon1.classData.id;
16960 char structName[1024];
16961 struct Expression * classExp;
16962
16963 strcpy(structName, "__ecereClassData_");
16964 FullClassNameCat(structName, _class->fullName, 0);
16965 exp->type = 9;
16966 exp->__anon1.member.member = id;
16967 if(curCompound && FindSymbol("this", curContext, curCompound->__anon1.compound.context, 0, 0))
16968 classExp = MkExpMember(MkExpIdentifier(MkIdentifier("this")), MkIdentifier("_class"));
16969 else
16970 classExp = MkExpIdentifier(MkIdentifier("class"));
16971 exp->__anon1.member.exp = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0)))), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpBrackets(MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpMember(classExp, MkIdentifier("data"))), '+', MkExpMember(MkExpClass(MkListOne(MkSpecifierName(_class->fullName)), (((void *)0))), MkIdentifier("offsetClass"))))))));
16972 ProcessExpressionType(exp);
16973 return ;
16974 }
16975 break;
16976 }
16977 case 35:
16978 {
16979 struct Type * type = (((void *)0));
16980 const char * typeString = (((void *)0));
16981 char typeStringBuf[1024];
16982
16983 if(exp->destType && exp->destType->kind == 8 && exp->destType->__anon1._class && exp->destType->__anon1._class->__anon1.registered && exp->destType->__anon1._class->__anon1.registered != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(exp->destType->__anon1._class->__anon1.registered, containerClass))
16984 {
16985 struct __ecereNameSpace__ecere__com__Class * templateClass = exp->destType->__anon1._class->__anon1.registered;
16986
16987 typeString = templateClass->templateArgs[2].__anon1.__anon1.dataTypeString;
16988 }
16989 else if(exp->__anon1.list)
16990 {
16991 struct Expression * e;
16992
16993 for(e = (*exp->__anon1.list).first; e; e = e->next)
16994 {
16995 ProcessExpressionType(e);
16996 if(e->expType)
16997 {
16998 if(!type)
16999 {
17000 type = e->expType;
17001 type->refCount++;
17002 }
17003 else
17004 {
17005 if(!MatchTypeExpression(e, type, (((void *)0)), 0, 1))
17006 {
17007 FreeType(type);
17008 type = e->expType;
17009 e->expType = (((void *)0));
17010 e = (*exp->__anon1.list).first;
17011 ProcessExpressionType(e);
17012 if(e->expType)
17013 {
17014 if(!MatchTypeExpression(e, type, (((void *)0)), 0, 1))
17015 {
17016 FreeType(e->expType);
17017 e->expType = (((void *)0));
17018 FreeType(type);
17019 type = (((void *)0));
17020 break;
17021 }
17022 }
17023 }
17024 }
17025 if(e->expType)
17026 {
17027 FreeType(e->expType);
17028 e->expType = (((void *)0));
17029 }
17030 }
17031 }
17032 if(type)
17033 {
17034 typeStringBuf[0] = '\0';
17035 PrintTypeNoConst(type, typeStringBuf, 0, 1);
17036 typeString = typeStringBuf;
17037 FreeType(type);
17038 type = (((void *)0));
17039 }
17040 }
17041 if(typeString)
17042 {
17043 char templateString[1024];
17044 struct __ecereNameSpace__ecere__sys__OldList * initializers = MkList();
17045 struct __ecereNameSpace__ecere__sys__OldList * structInitializers = MkList();
17046 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
17047 struct Expression * expExt;
17048 struct Declarator * decl = SpecDeclFromString(typeString, specs, (((void *)0)));
17049
17050 sprintf(templateString, "Container<%s>", typeString);
17051 if(exp->__anon1.list)
17052 {
17053 struct Expression * e;
17054
17055 type = ProcessTypeString(typeString, 0);
17056 while((e = (*exp->__anon1.list).first))
17057 {
17058 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*exp->__anon1.list), e);
17059 e->destType = type;
17060 type->refCount++;
17061 ProcessExpressionType(e);
17062 ListAdd(initializers, MkInitializerAssignment(e));
17063 }
17064 FreeType(type);
17065 (__ecereNameSpace__ecere__com__eSystem_Delete(exp->__anon1.list), exp->__anon1.list = 0);
17066 }
17067 DeclareStruct("ecere::com::BuiltInContainer", 0);
17068 ListAdd(structInitializers, MkInitializerAssignment(MkExpMember(MkExpClass(MkListOne(MkSpecifierName("BuiltInContainer")), (((void *)0))), MkIdentifier("_vTbl"))));
17069 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17070 ListAdd(structInitializers, MkInitializerAssignment(MkExpClass(MkListOne(MkSpecifierName("BuiltInContainer")), (((void *)0)))));
17071 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17072 ListAdd(structInitializers, MkInitializerAssignment(MkExpConstant("0")));
17073 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17074 ListAdd(structInitializers, MkInitializerAssignment(MkExpExtensionInitializer(MkTypeName(specs, MkDeclaratorArray(decl, (((void *)0)))), MkInitializerList(initializers))));
17075 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17076 ListAdd(structInitializers, MkInitializerAssignment(__extension__ ({
17077 struct Expression * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
17078
17079 __ecereInstance1->type = 2, __ecereInstance1->__anon1.__anon1.constant = __ecereNameSpace__ecere__com__PrintString(__ecereClass_int, (void *)&(*initializers).count, (void *)0), __ecereInstance1;
17080 })));
17081 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17082 ListAdd(structInitializers, MkInitializerAssignment(MkExpClass(CopyList(specs, (void *)(CopySpecifier)), CopyDeclarator(decl))));
17083 ProcessExpressionType(((struct Initializer *)(*structInitializers).last)->__anon1.exp);
17084 exp->expType = ProcessTypeString(templateString, 0);
17085 exp->type = 5;
17086 exp->__anon1.list = MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName(templateString)), (((void *)0))), MkExpOp((((void *)0)), '&', expExt = MkExpExtensionInitializer(MkTypeName(MkListOne(MkSpecifierName("BuiltInContainer")), (((void *)0))), MkInitializerList(structInitializers)))));
17087 ProcessExpressionType(expExt);
17088 }
17089 else
17090 {
17091 exp->expType = ProcessTypeString("Container", 0);
17092 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Couldn't determine type of array elements\n", (((void *)0))));
17093 }
17094 break;
17095 }
17096 }
17097 if(exp->expType && exp->expType->kind == 21 && thisClass && (!exp->destType || exp->destType->kind != 21))
17098 {
17099 FreeType(exp->expType);
17100 exp->expType = ReplaceThisClassType(thisClass);
17101 }
17102 if(exp->expType && (exp->expType->kind == 9 || exp->expType->kind == 10 || exp->expType->kind == 15) && !exp->expType->__anon1.__anon1.members.first && exp->expType->__anon1.__anon1.enumName)
17103 {
17104 struct Symbol * symbol = FindSymbol(exp->expType->__anon1.__anon1.enumName, curContext, globalContext, 1, 0);
17105
17106 if(symbol)
17107 {
17108 if(exp->expType->kind != 15)
17109 {
17110 struct Type * member;
17111 char * enumName = __ecereNameSpace__ecere__sys__CopyString(exp->expType->__anon1.__anon1.enumName);
17112
17113 FreeType(exp->expType);
17114 exp->expType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
17115 exp->expType->kind = symbol->type->kind;
17116 exp->expType->refCount++;
17117 exp->expType->__anon1.__anon1.enumName = enumName;
17118 exp->expType->__anon1.__anon1.members = symbol->type->__anon1.__anon1.members;
17119 for(member = symbol->type->__anon1.__anon1.members.first; member; member = member->next)
17120 member->refCount++;
17121 }
17122 else
17123 {
17124 struct __ecereNameSpace__ecere__sys__NamedLink64 * member;
17125
17126 for(member = symbol->type->__anon1.__anon1.members.first; member; member = member->next)
17127 {
17128 struct __ecereNameSpace__ecere__sys__NamedLink64 * value = (value = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink64), value->name = __ecereNameSpace__ecere__sys__CopyString(member->name), value);
17129
17130 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&exp->expType->__anon1.__anon1.members, value);
17131 }
17132 }
17133 }
17134 }
17135 yylloc = exp->loc;
17136 if(exp->destType && (exp->destType->kind == 18))
17137 ;
17138 else if(exp->destType && !exp->destType->keepCast)
17139 {
17140 if(!exp->needTemplateCast && exp->expType && (exp->expType->kind == 20 || exp->expType->passAsTemplate))
17141 exp->needTemplateCast = 1;
17142 if(exp->destType->kind == 0)
17143 ;
17144 else if(!CheckExpressionType(exp, exp->destType, 0, !exp->destType->casted))
17145 {
17146 if(!exp->destType->count || unresolved)
17147 {
17148 if(!exp->expType)
17149 {
17150 yylloc = exp->loc;
17151 if(exp->destType->kind != 14)
17152 {
17153 char type2[1024];
17154
17155 type2[0] = '\0';
17156 if(inCompiler)
17157 {
17158 char expString[10240];
17159
17160 expString[0] = '\0';
17161 PrintType(exp->destType, type2, 0, 1);
17162 if(inCompiler)
17163 {
17164 PrintExpression(exp, expString);
17165 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
17166 }
17167 if(unresolved)
17168 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s; expected %s\n", (((void *)0))), expString, type2);
17169 else if(exp->type != 16)
17170 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s; expected %s\n", (((void *)0))), expString, type2);
17171 }
17172 }
17173 else
17174 {
17175 char expString[10240];
17176
17177 expString[0] = '\0';
17178 if(inCompiler)
17179 {
17180 PrintExpression(exp, expString);
17181 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
17182 }
17183 if(unresolved)
17184 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s\n", (((void *)0))), expString);
17185 else if(exp->type != 16)
17186 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
17187 }
17188 }
17189 else
17190 {
17191 char type1[1024];
17192 char type2[1024];
17193
17194 type1[0] = '\0';
17195 type2[0] = '\0';
17196 if(inCompiler)
17197 {
17198 PrintType(exp->expType, type1, 0, 1);
17199 PrintType(exp->destType, type2, 0, 1);
17200 }
17201 if(exp->destType->truth && exp->destType->__anon1._class && exp->destType->__anon1._class->__anon1.registered && !strcmp(exp->destType->__anon1._class->__anon1.registered->name, "bool") && exp->expType->kind != 0 && exp->expType->kind != 9 && exp->expType->kind != 10 && (exp->expType->kind != 8 || exp->expType->classObjectType || (exp->expType->__anon1._class && exp->expType->__anon1._class->__anon1.registered && exp->expType->__anon1._class->__anon1.registered->type != 1)))
17202 ;
17203 else
17204 {
17205 char expString[10240];
17206
17207 expString[0] = '\0';
17208 if(inCompiler)
17209 {
17210 PrintExpression(exp, expString);
17211 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
17212 }
17213 if(!sourceFile || (!strstr(sourceFile, "src\\lexer.ec") && !strstr(sourceFile, "src/lexer.ec") && !strstr(sourceFile, "src\\grammar.ec") && !strstr(sourceFile, "src/grammar.ec") && !strstr(sourceFile, "src\\type.ec") && !strstr(sourceFile, "src/type.ec") && !strstr(sourceFile, "src\\expression.ec") && !strstr(sourceFile, "src/expression.ec")))
17214 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1, type2);
17215 FreeType(exp->expType);
17216 exp->destType->refCount++;
17217 exp->expType = exp->destType;
17218 }
17219 }
17220 }
17221 }
17222 else if(exp->destType && exp->destType->kind == 13 && exp->destType->__anon1.type && exp->destType->__anon1.type->kind == 11 && exp->expType && (exp->expType->kind == 11 || exp->expType->kind == 16))
17223 {
17224 struct Expression * nbExp = GetNonBracketsExp(exp);
17225
17226 if(nbExp->type != 11 || !IsVoidPtrCast(nbExp->__anon1.cast.typeName))
17227 {
17228 struct Expression * e = MoveExpContents(exp);
17229
17230 exp->__anon1.cast.exp = MkExpBrackets(MkListOne(e));
17231 exp->type = 11;
17232 exp->__anon1.cast.exp->destType = exp->destType;
17233 if(exp->destType)
17234 exp->destType->refCount++;
17235 exp->__anon1.cast.typeName = MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0))));
17236 }
17237 }
17238 }
17239 else if(unresolved)
17240 {
17241 if(exp->__anon1.__anon1.identifier->_class && exp->__anon1.__anon1.identifier->_class->__anon1.__anon1.name)
17242 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s::%s\n", (((void *)0))), exp->__anon1.__anon1.identifier->_class->__anon1.__anon1.name, exp->__anon1.__anon1.identifier->string);
17243 else if(exp->__anon1.__anon1.identifier->string && exp->__anon1.__anon1.identifier->string[0])
17244 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s\n", (((void *)0))), exp->__anon1.__anon1.identifier->string);
17245 }
17246 else if(!exp->expType && exp->type != 16)
17247 {
17248 char expString[10240];
17249
17250 expString[0] = '\0';
17251 if(inCompiler)
17252 {
17253 PrintExpression(exp, expString);
17254 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
17255 }
17256 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
17257 }
17258 if(inCompiler)
17259 ApplyAnyObjectLogic(exp);
17260 if(!notByReference && exp->expType && exp->expType->kind == 8 && exp->expType->__anon1._class && exp->expType->__anon1._class->__anon1.registered && exp->expType->__anon1._class->__anon1.registered->type == 5 && (!exp->destType || (exp->destType->kind != 3 && exp->destType->kind != 4 && exp->destType->kind != 22 && exp->destType->kind != 23 && exp->destType->kind != 5 && exp->destType->kind != 2 && exp->destType->kind != 1 && exp->destType->kind != 24)))
17261 {
17262 exp->byReference = 1;
17263 }
17264 yylloc = oldyylloc;
17265 }
17266
17267 static void FindNextDataMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class ** curClass, struct __ecereNameSpace__ecere__com__DataMember ** curMember, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
17268 {
17269 if(*curMember)
17270 {
17271 *curMember = (*curMember)->next;
17272 if(subMemberStackPos && *subMemberStackPos > 0 && subMemberStack[*subMemberStackPos - 1]->type == 1)
17273 {
17274 *curMember = subMemberStack[--(*subMemberStackPos)];
17275 *curMember = (*curMember)->next;
17276 }
17277 while((*curMember) && (*curMember)->isProperty)
17278 *curMember = (*curMember)->next;
17279 if(subMemberStackPos)
17280 {
17281 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
17282 {
17283 subMemberStack[(*subMemberStackPos)++] = *curMember;
17284 *curMember = (*curMember)->members.first;
17285 while(*curMember && (*curMember)->isProperty)
17286 *curMember = (*curMember)->next;
17287 }
17288 }
17289 }
17290 while(!*curMember)
17291 {
17292 if(!*curMember)
17293 {
17294 if(subMemberStackPos && *subMemberStackPos)
17295 {
17296 *curMember = subMemberStack[--(*subMemberStackPos)];
17297 *curMember = (*curMember)->next;
17298 }
17299 else
17300 {
17301 struct __ecereNameSpace__ecere__com__Class * lastCurClass = *curClass;
17302
17303 if(*curClass == _class)
17304 break;
17305 for(*curClass = _class; (*curClass)->base != lastCurClass && (*curClass)->base->type != 1000; *curClass = (*curClass)->base)
17306 ;
17307 *curMember = (*curClass)->membersAndProperties.first;
17308 }
17309 while((*curMember) && (*curMember)->isProperty)
17310 *curMember = (*curMember)->next;
17311 if(subMemberStackPos)
17312 {
17313 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
17314 {
17315 subMemberStack[(*subMemberStackPos)++] = *curMember;
17316 *curMember = (*curMember)->members.first;
17317 while(*curMember && (*curMember)->isProperty)
17318 *curMember = (*curMember)->next;
17319 }
17320 }
17321 }
17322 }
17323 }
17324
17325 static void ProcessInitializer(struct Initializer * init, struct Type * type)
17326 {
17327 switch(init->type)
17328 {
17329 case 0:
17330 if(!init->__anon1.exp || init->__anon1.exp->type != 1 || !init->__anon1.exp->__anon1.instance || init->__anon1.exp->__anon1.instance->_class || !type || type->kind == 8)
17331 {
17332 if(init->__anon1.exp && !init->__anon1.exp->destType)
17333 {
17334 FreeType(init->__anon1.exp->destType);
17335 init->__anon1.exp->destType = type;
17336 if(type)
17337 type->refCount++;
17338 }
17339 if(init->__anon1.exp)
17340 {
17341 ProcessExpressionType(init->__anon1.exp);
17342 init->isConstant = init->__anon1.exp->isConstant;
17343 }
17344 break;
17345 }
17346 else
17347 {
17348 struct Expression * exp = init->__anon1.exp;
17349 struct Instantiation * inst = exp->__anon1.instance;
17350 struct MembersInit * members;
17351
17352 init->type = 1;
17353 init->__anon1.list = MkList();
17354 if(inst->members)
17355 {
17356 for(members = (*inst->members).first; members; members = members->next)
17357 {
17358 if(members->type == 0)
17359 {
17360 struct MemberInit * member;
17361
17362 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
17363 {
17364 ListAdd(init->__anon1.list, member->initializer);
17365 member->initializer = (((void *)0));
17366 }
17367 }
17368 }
17369 }
17370 FreeExpression(exp);
17371 }
17372 case 1:
17373 {
17374 struct Initializer * i;
17375 struct Type * initializerType = (((void *)0));
17376 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
17377 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
17378 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
17379 int subMemberStackPos = 0;
17380
17381 if(type && type->kind == 12)
17382 initializerType = Dereference(type);
17383 else if(type && (type->kind == 9 || type->kind == 10))
17384 initializerType = type->__anon1.__anon1.members.first;
17385 for(i = (*init->__anon1.list).first; i; i = i->next)
17386 {
17387 if(type && type->kind == 8 && type->__anon1._class && type->__anon1._class->__anon1.registered)
17388 {
17389 FindNextDataMember(type->__anon1._class->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
17390 if(curMember)
17391 {
17392 if(!curMember->dataType)
17393 curMember->dataType = ProcessTypeString(curMember->dataTypeString, 0);
17394 initializerType = curMember->dataType;
17395 }
17396 }
17397 ProcessInitializer(i, initializerType);
17398 if(initializerType && type && (type->kind == 9 || type->kind == 10))
17399 initializerType = initializerType->next;
17400 if(!i->isConstant)
17401 init->isConstant = 0;
17402 }
17403 if(type && type->kind == 12)
17404 FreeType(initializerType);
17405 if(type && type->kind != 12 && type->kind != 9 && type->kind != 10 && (type->kind != 8 || !type->__anon1._class->__anon1.registered || type->__anon1._class->__anon1.registered->type != 1))
17406 {
17407 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Assigning list initializer to non list\n", (((void *)0))));
17408 }
17409 break;
17410 }
17411 }
17412 }
17413
17414 extern struct Symbol * FindType(struct Context * ctx, const char *  name);
17415
17416 static void ProcessClass(struct __ecereNameSpace__ecere__sys__OldList * definitions, struct Symbol * symbol);
17417
17418 static void ProcessSpecifier(struct Specifier * spec, unsigned int declareStruct)
17419 {
17420 switch(spec->type)
17421 {
17422 case 0:
17423 {
17424 if(spec->__anon1.specifier == THISCLASS)
17425 {
17426 if(thisClass)
17427 {
17428 spec->type = 1;
17429 spec->__anon1.__anon1.name = ReplaceThisClass(thisClass);
17430 spec->__anon1.__anon1.symbol = FindClass(spec->__anon1.__anon1.name);
17431 ProcessSpecifier(spec, declareStruct);
17432 }
17433 }
17434 break;
17435 }
17436 case 1:
17437 {
17438 struct Symbol * symbol = FindType(curContext, spec->__anon1.__anon1.name);
17439
17440 if(symbol)
17441 DeclareType(symbol->type, 1, 1);
17442 else if((symbol = spec->__anon1.__anon1.symbol) && symbol->__anon1.registered && symbol->__anon1.registered->type == 1 && declareStruct)
17443 DeclareStruct(spec->__anon1.__anon1.name, 0);
17444 break;
17445 }
17446 case 2:
17447 {
17448 struct Enumerator * e;
17449
17450 if(spec->__anon1.__anon2.list)
17451 {
17452 for(e = (*spec->__anon1.__anon2.list).first; e; e = e->next)
17453 {
17454 if(e->exp)
17455 ProcessExpressionType(e->exp);
17456 }
17457 }
17458 break;
17459 }
17460 case 3:
17461 case 4:
17462 {
17463 if(spec->__anon1.__anon2.definitions)
17464 {
17465 struct Symbol * symbol = spec->__anon1.__anon2.id ? FindClass(spec->__anon1.__anon2.id->string) : (((void *)0));
17466
17467 ProcessClass(spec->__anon1.__anon2.definitions, symbol);
17468 }
17469 break;
17470 }
17471 }
17472 }
17473
17474 static void ProcessDeclarator(struct Declarator * decl)
17475 {
17476 switch(decl->type)
17477 {
17478 case 1:
17479 if(decl->__anon1.identifier->classSym)
17480 {
17481 FreeSpecifier(decl->__anon1.identifier->_class);
17482 decl->__anon1.identifier->_class = (((void *)0));
17483 }
17484 break;
17485 case 3:
17486 if(decl->__anon1.array.exp)
17487 ProcessExpressionType(decl->__anon1.array.exp);
17488 case 0:
17489 case 2:
17490 case 4:
17491 case 5:
17492 case 6:
17493 case 7:
17494 if(decl->declarator)
17495 ProcessDeclarator(decl->declarator);
17496 if(decl->type == 4)
17497 {
17498 struct Identifier * id = GetDeclId(decl);
17499
17500 if(id && id->_class)
17501 {
17502 struct TypeName * param = (param = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TypeName), param->qualifiers = MkListOne(id->_class), param->declarator = (((void *)0)), param);
17503
17504 if(!decl->__anon1.function.parameters)
17505 decl->__anon1.function.parameters = MkList();
17506 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->__anon1.function.parameters), (((void *)0)), param);
17507 id->_class = (((void *)0));
17508 }
17509 if(decl->__anon1.function.parameters)
17510 {
17511 struct TypeName * param;
17512
17513 for(param = (*decl->__anon1.function.parameters).first; param; param = param->next)
17514 {
17515 if(param->qualifiers && (*param->qualifiers).first)
17516 {
17517 struct Specifier * spec = (*param->qualifiers).first;
17518
17519 if(spec && spec->__anon1.specifier == TYPED_OBJECT)
17520 {
17521 struct Declarator * d = param->declarator;
17522 struct TypeName * newParam = (newParam = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TypeName), newParam->qualifiers = MkListOne(MkSpecifier(VOID)), newParam->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d), newParam);
17523
17524 if(d->type != 5)
17525 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*newParam->qualifiers), (((void *)0)), MkSpecifier(CONST));
17526 FreeList(param->qualifiers, (void *)(FreeSpecifier));
17527 param->qualifiers = MkListOne(MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0))));
17528 param->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier("class")));
17529 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->__anon1.function.parameters), param, newParam);
17530 param = newParam;
17531 }
17532 else if(spec && spec->__anon1.specifier == ANY_OBJECT)
17533 {
17534 struct Declarator * d = param->declarator;
17535
17536 FreeList(param->qualifiers, (void *)(FreeSpecifier));
17537 param->qualifiers = MkListOne(MkSpecifier(VOID));
17538 if(d->type != 5)
17539 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*param->qualifiers), (((void *)0)), MkSpecifier(CONST));
17540 param->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), d);
17541 }
17542 else if(spec->__anon1.specifier == THISCLASS)
17543 {
17544 if(thisClass)
17545 {
17546 spec->type = 1;
17547 spec->__anon1.__anon1.name = ReplaceThisClass(thisClass);
17548 spec->__anon1.__anon1.symbol = FindClass(spec->__anon1.__anon1.name);
17549 ProcessSpecifier(spec, 0);
17550 }
17551 }
17552 }
17553 if(param->declarator)
17554 ProcessDeclarator(param->declarator);
17555 }
17556 }
17557 }
17558 break;
17559 }
17560 }
17561
17562 extern struct Identifier * CopyIdentifier(struct Identifier * id);
17563
17564 extern void FreeInitDeclarator(struct InitDeclarator * decl);
17565
17566 static void ProcessDeclaration(struct Declaration * decl)
17567 {
17568 yylloc = decl->loc;
17569 switch(decl->type)
17570 {
17571 case 1:
17572 {
17573 unsigned int declareStruct = 0;
17574
17575 if(decl->__anon1.__anon1.declarators)
17576 {
17577 struct InitDeclarator * d;
17578
17579 for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
17580 {
17581 struct Type * type, * subType;
17582
17583 ProcessDeclarator(d->declarator);
17584 type = ProcessType(decl->__anon1.__anon1.specifiers, d->declarator);
17585 if(d->initializer)
17586 {
17587 ProcessInitializer(d->initializer, type);
17588 if((*decl->__anon1.__anon1.declarators).count == 1 && d->initializer->type == 0 && d->initializer->__anon1.exp->type == 1)
17589 {
17590 if(type->kind == 8 && type->__anon1._class == d->initializer->__anon1.exp->expType->__anon1._class)
17591 {
17592 struct Instantiation * inst = d->initializer->__anon1.exp->__anon1.instance;
17593
17594 inst->exp = MkExpIdentifier(CopyIdentifier(GetDeclId(d->declarator)));
17595 d->initializer->__anon1.exp->__anon1.instance = (((void *)0));
17596 if(decl->__anon1.__anon1.specifiers)
17597 FreeList(decl->__anon1.__anon1.specifiers, (void *)(FreeSpecifier));
17598 FreeList(decl->__anon1.__anon1.declarators, (void *)(FreeInitDeclarator));
17599 d = (((void *)0));
17600 decl->type = 2;
17601 decl->__anon1.inst = inst;
17602 }
17603 }
17604 }
17605 for(subType = type; subType; )
17606 {
17607 if(subType->kind == 8)
17608 {
17609 declareStruct = 1;
17610 break;
17611 }
17612 else if(subType->kind == 13)
17613 break;
17614 else if(subType->kind == 12)
17615 subType = subType->__anon1.__anon4.arrayType;
17616 else
17617 break;
17618 }
17619 FreeType(type);
17620 if(!d)
17621 break;
17622 }
17623 }
17624 if(decl->__anon1.__anon1.specifiers)
17625 {
17626 struct Specifier * s;
17627
17628 for(s = (*decl->__anon1.__anon1.specifiers).first; s; s = s->next)
17629 {
17630 ProcessSpecifier(s, declareStruct);
17631 }
17632 }
17633 break;
17634 }
17635 case 2:
17636 {
17637 ProcessInstantiationType(decl->__anon1.inst);
17638 break;
17639 }
17640 case 0:
17641 {
17642 struct Specifier * spec;
17643 struct Declarator * d;
17644 unsigned int declareStruct = 0;
17645
17646 if(decl->__anon1.__anon1.declarators)
17647 {
17648 for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
17649 {
17650 struct Type * type = ProcessType(decl->__anon1.__anon1.specifiers, d->declarator);
17651 struct Type * subType;
17652
17653 ProcessDeclarator(d);
17654 for(subType = type; subType; )
17655 {
17656 if(subType->kind == 8)
17657 {
17658 declareStruct = 1;
17659 break;
17660 }
17661 else if(subType->kind == 13)
17662 break;
17663 else if(subType->kind == 12)
17664 subType = subType->__anon1.__anon4.arrayType;
17665 else
17666 break;
17667 }
17668 FreeType(type);
17669 }
17670 }
17671 if(decl->__anon1.__anon1.specifiers)
17672 {
17673 for(spec = (*decl->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
17674 ProcessSpecifier(spec, declareStruct);
17675 }
17676 break;
17677 }
17678 }
17679 }
17680
17681 static struct FunctionDefinition * curFunction;
17682
17683 static void CreateFireWatcher(struct __ecereNameSpace__ecere__com__Property * prop, struct Expression * object, struct Statement * stmt)
17684 {
17685 char propName[1024], propNameM[1024];
17686 char getName[1024], setName[1024];
17687 struct __ecereNameSpace__ecere__sys__OldList * args;
17688
17689 DeclareProperty(prop, setName, getName);
17690 strcpy(propName, "__ecereProp_");
17691 FullClassNameCat(propName, prop->_class->fullName, 0);
17692 strcat(propName, "_");
17693 FullClassNameCat(propName, prop->name, 1);
17694 strcpy(propNameM, "__ecerePropM_");
17695 FullClassNameCat(propNameM, prop->_class->fullName, 0);
17696 strcat(propNameM, "_");
17697 FullClassNameCat(propNameM, prop->name, 1);
17698 if(prop->isWatchable)
17699 {
17700 args = MkList();
17701 ListAdd(args, object ? CopyExpression(object) : MkExpIdentifier(MkIdentifier("this")));
17702 ListAdd(args, MkExpIdentifier(MkIdentifier(propName)));
17703 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_FireWatchers")), args));
17704 args = MkList();
17705 ListAdd(args, object ? CopyExpression(object) : MkExpIdentifier(MkIdentifier("this")));
17706 ListAdd(args, MkExpIdentifier(MkIdentifier(propNameM)));
17707 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_FireWatchers")), args));
17708 }
17709 {
17710 args = MkList();
17711 ListAdd(args, object ? CopyExpression(object) : MkExpIdentifier(MkIdentifier("this")));
17712 ListAdd(args, MkExpIdentifier(MkIdentifier(propName)));
17713 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_FireSelfWatchers")), args));
17714 args = MkList();
17715 ListAdd(args, object ? CopyExpression(object) : MkExpIdentifier(MkIdentifier("this")));
17716 ListAdd(args, MkExpIdentifier(MkIdentifier(propNameM)));
17717 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_FireSelfWatchers")), args));
17718 }
17719 if(curFunction->propSet && !strcmp(curFunction->propSet->string, prop->name) && (!object || (object->type == 0 && !strcmp(object->__anon1.__anon1.identifier->string, "this"))))
17720 curFunction->propSet->fireWatchersDone = 1;
17721 }
17722
17723 extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
17724
17725 extern struct Instantiation * MkInstantiationNamed(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
17726
17727 extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
17728
17729 extern struct Statement * MkForStmt(struct Statement * init, struct Statement * check, struct __ecereNameSpace__ecere__sys__OldList * inc, struct Statement * statement);
17730
17731 extern struct Statement * MkWhileStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement);
17732
17733 extern struct ClassFunction * MkClassFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Specifier * _class, struct Declarator * decl, struct __ecereNameSpace__ecere__sys__OldList * declList);
17734
17735 extern void ProcessClassFunctionBody(struct ClassFunction * func, struct Statement * body);
17736
17737 extern void FreePropertyWatch(struct PropertyWatch * watcher);
17738
17739 static void ProcessStatement(struct Statement * stmt)
17740 {
17741 yylloc = stmt->loc;
17742 switch(stmt->type)
17743 {
17744 case 0:
17745 ProcessStatement(stmt->__anon1.labeled.stmt);
17746 break;
17747 case 1:
17748 if(stmt->__anon1.caseStmt.exp)
17749 {
17750 FreeType(stmt->__anon1.caseStmt.exp->destType);
17751 stmt->__anon1.caseStmt.exp->destType = curSwitchType;
17752 if(curSwitchType)
17753 curSwitchType->refCount++;
17754 ProcessExpressionType(stmt->__anon1.caseStmt.exp);
17755 ComputeExpression(stmt->__anon1.caseStmt.exp);
17756 }
17757 if(stmt->__anon1.caseStmt.stmt)
17758 ProcessStatement(stmt->__anon1.caseStmt.stmt);
17759 break;
17760 case 2:
17761 {
17762 if(stmt->__anon1.compound.context)
17763 {
17764 struct Declaration * decl;
17765 struct Statement * s;
17766 struct Statement * prevCompound = curCompound;
17767 struct Context * prevContext = curContext;
17768
17769 if(!stmt->__anon1.compound.isSwitch)
17770 curCompound = stmt;
17771 curContext = stmt->__anon1.compound.context;
17772 if(stmt->__anon1.compound.declarations)
17773 {
17774 for(decl = (*stmt->__anon1.compound.declarations).first; decl; decl = decl->next)
17775 ProcessDeclaration(decl);
17776 }
17777 if(stmt->__anon1.compound.statements)
17778 {
17779 for(s = (*stmt->__anon1.compound.statements).first; s; s = s->next)
17780 ProcessStatement(s);
17781 }
17782 curContext = prevContext;
17783 curCompound = prevCompound;
17784 }
17785 break;
17786 }
17787 case 3:
17788 {
17789 struct Expression * exp;
17790
17791 if(stmt->__anon1.expressions)
17792 {
17793 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
17794 ProcessExpressionType(exp);
17795 }
17796 break;
17797 }
17798 case 4:
17799 {
17800 struct Expression * exp;
17801
17802 FreeType(((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->destType);
17803 ((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->destType = MkClassType("bool");
17804 ((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->destType->truth = 1;
17805 for(exp = (*stmt->__anon1.ifStmt.exp).first; exp; exp = exp->next)
17806 {
17807 ProcessExpressionType(exp);
17808 }
17809 if(stmt->__anon1.ifStmt.stmt)
17810 ProcessStatement(stmt->__anon1.ifStmt.stmt);
17811 if(stmt->__anon1.ifStmt.elseStmt)
17812 ProcessStatement(stmt->__anon1.ifStmt.elseStmt);
17813 break;
17814 }
17815 case 5:
17816 {
17817 struct Type * oldSwitchType = curSwitchType;
17818
17819 if(stmt->__anon1.switchStmt.exp)
17820 {
17821 struct Expression * exp;
17822
17823 for(exp = (*stmt->__anon1.switchStmt.exp).first; exp; exp = exp->next)
17824 {
17825 if(!exp->next)
17826 {
17827 ProcessExpressionType(exp);
17828 }
17829 if(!exp->next)
17830 curSwitchType = exp->expType;
17831 }
17832 }
17833 ProcessStatement(stmt->__anon1.switchStmt.stmt);
17834 curSwitchType = oldSwitchType;
17835 break;
17836 }
17837 case 6:
17838 {
17839 if(stmt->__anon1.whileStmt.exp)
17840 {
17841 struct Expression * exp;
17842
17843 FreeType(((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->destType);
17844 ((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->destType = MkClassType("bool");
17845 ((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->destType->truth = 1;
17846 for(exp = (*stmt->__anon1.whileStmt.exp).first; exp; exp = exp->next)
17847 {
17848 ProcessExpressionType(exp);
17849 }
17850 }
17851 if(stmt->__anon1.whileStmt.stmt)
17852 ProcessStatement(stmt->__anon1.whileStmt.stmt);
17853 break;
17854 }
17855 case 7:
17856 {
17857 if(stmt->__anon1.doWhile.exp)
17858 {
17859 struct Expression * exp;
17860
17861 if((*stmt->__anon1.doWhile.exp).last)
17862 {
17863 FreeType(((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->destType);
17864 ((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->destType = MkClassType("bool");
17865 ((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->destType->truth = 1;
17866 }
17867 for(exp = (*stmt->__anon1.doWhile.exp).first; exp; exp = exp->next)
17868 {
17869 ProcessExpressionType(exp);
17870 }
17871 }
17872 if(stmt->__anon1.doWhile.stmt)
17873 ProcessStatement(stmt->__anon1.doWhile.stmt);
17874 break;
17875 }
17876 case 8:
17877 {
17878 struct Expression * exp;
17879
17880 if(stmt->__anon1.forStmt.init)
17881 ProcessStatement(stmt->__anon1.forStmt.init);
17882 if(stmt->__anon1.forStmt.check && stmt->__anon1.forStmt.check->__anon1.expressions)
17883 {
17884 FreeType(((struct Expression *)(*stmt->__anon1.forStmt.check->__anon1.expressions).last)->destType);
17885 ((struct Expression *)(*stmt->__anon1.forStmt.check->__anon1.expressions).last)->destType = MkClassType("bool");
17886 ((struct Expression *)(*stmt->__anon1.forStmt.check->__anon1.expressions).last)->destType->truth = 1;
17887 }
17888 if(stmt->__anon1.forStmt.check)
17889 ProcessStatement(stmt->__anon1.forStmt.check);
17890 if(stmt->__anon1.forStmt.increment)
17891 {
17892 for(exp = (*stmt->__anon1.forStmt.increment).first; exp; exp = exp->next)
17893 ProcessExpressionType(exp);
17894 }
17895 if(stmt->__anon1.forStmt.stmt)
17896 ProcessStatement(stmt->__anon1.forStmt.stmt);
17897 break;
17898 }
17899 case 18:
17900 {
17901 struct Identifier * id = stmt->__anon1.forEachStmt.id;
17902 struct __ecereNameSpace__ecere__sys__OldList * exp = stmt->__anon1.forEachStmt.exp;
17903 struct __ecereNameSpace__ecere__sys__OldList * filter = stmt->__anon1.forEachStmt.filter;
17904 struct Statement * block = stmt->__anon1.forEachStmt.stmt;
17905 char iteratorType[1024];
17906 struct Type * source;
17907 struct Expression * e;
17908 unsigned int isBuiltin = exp && (*exp).last && (((struct Expression *)(*exp).last)->type == 35 || (((struct Expression *)(*exp).last)->type == 11 && ((struct Expression *)(*exp).last)->__anon1.cast.exp->type == 35));
17909 struct Expression * arrayExp;
17910 const char * typeString = (((void *)0));
17911 int builtinCount = 0;
17912
17913 for(e = exp ? (*exp).first : (((void *)0)); e; e = e->next)
17914 {
17915 if(!e->next)
17916 {
17917 FreeType(e->destType);
17918 e->destType = ProcessTypeString("Container", 0);
17919 }
17920 if(!isBuiltin || e->next)
17921 ProcessExpressionType(e);
17922 }
17923 source = (exp && (*exp).last) ? ((struct Expression *)(*exp).last)->expType : (((void *)0));
17924 if(isBuiltin || (source && source->kind == 8 && source->__anon1._class && source->__anon1._class->__anon1.registered && source->__anon1._class->__anon1.registered != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, containerClass)))
17925 {
17926 struct __ecereNameSpace__ecere__com__Class * _class = source ? source->__anon1._class->__anon1.registered : (((void *)0));
17927 struct Symbol * symbol;
17928 struct Expression * expIt = (((void *)0));
17929 unsigned int isMap = 0, isArray = 0, isLinkList = 0, isList = 0, isCustomAVLTree = 0;
17930 struct __ecereNameSpace__ecere__com__Class * arrayClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "Array");
17931 struct __ecereNameSpace__ecere__com__Class * linkListClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "LinkList");
17932 struct __ecereNameSpace__ecere__com__Class * customAVLTreeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "CustomAVLTree");
17933
17934 stmt->type = 2;
17935 stmt->__anon1.compound.context = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
17936 stmt->__anon1.compound.context->parent = curContext;
17937 curContext = stmt->__anon1.compound.context;
17938 if(source && __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, customAVLTreeClass))
17939 {
17940 struct __ecereNameSpace__ecere__com__Class * mapClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "Map");
17941
17942 isCustomAVLTree = 1;
17943 if(__ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, mapClass))
17944 isMap = 1;
17945 }
17946 else if(source && __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, arrayClass))
17947 isArray = 1;
17948 else if(source && __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, linkListClass))
17949 {
17950 struct __ecereNameSpace__ecere__com__Class * listClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "List");
17951
17952 isLinkList = 1;
17953 isList = __ecereNameSpace__ecere__com__eClass_IsDerived(source->__anon1._class->__anon1.registered, listClass);
17954 }
17955 if(isArray)
17956 {
17957 struct Declarator * decl;
17958 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
17959
17960 decl = SpecDeclFromString(_class->templateArgs[2].__anon1.__anon1.dataTypeString, specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(id)));
17961 stmt->__anon1.compound.declarations = MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(decl, (((void *)0))))));
17962 ListAdd(stmt->__anon1.compound.declarations, MkDeclaration(MkListOne(MkSpecifierName(source->__anon1._class->__anon1.registered->fullName)), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internalArray")), MkInitializerAssignment(MkExpBrackets(exp))))));
17963 }
17964 else if(isBuiltin)
17965 {
17966 struct Type * type = (((void *)0));
17967 char typeStringBuf[1024];
17968
17969 arrayExp = (((struct Expression *)(*exp).last)->type == 35) ? (struct Expression *)(*exp).last : ((struct Expression *)(*exp).last)->__anon1.cast.exp;
17970 if(((struct Expression *)(*exp).last)->type == 11)
17971 {
17972 struct TypeName * typeName = ((struct Expression *)(*exp).last)->__anon1.cast.typeName;
17973
17974 if(typeName)
17975 arrayExp->destType = ProcessType(typeName->qualifiers, typeName->declarator);
17976 }
17977 if(arrayExp->destType && arrayExp->destType->kind == 8 && arrayExp->destType->__anon1._class && arrayExp->destType->__anon1._class->__anon1.registered && arrayExp->destType->__anon1._class->__anon1.registered != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(arrayExp->destType->__anon1._class->__anon1.registered, containerClass) && arrayExp->destType->__anon1._class->__anon1.registered->templateArgs)
17978 {
17979 struct __ecereNameSpace__ecere__com__Class * templateClass = arrayExp->destType->__anon1._class->__anon1.registered;
17980
17981 typeString = templateClass->templateArgs[2].__anon1.__anon1.dataTypeString;
17982 }
17983 else if(arrayExp->__anon1.list)
17984 {
17985 struct Expression * e;
17986
17987 for(e = (*arrayExp->__anon1.list).first; e; e = e->next)
17988 {
17989 ProcessExpressionType(e);
17990 if(e->expType)
17991 {
17992 if(!type)
17993 {
17994 type = e->expType;
17995 type->refCount++;
17996 }
17997 else
17998 {
17999 if(!MatchTypeExpression(e, type, (((void *)0)), 0, 1))
18000 {
18001 FreeType(type);
18002 type = e->expType;
18003 e->expType = (((void *)0));
18004 e = (*arrayExp->__anon1.list).first;
18005 ProcessExpressionType(e);
18006 if(e->expType)
18007 {
18008 if(!MatchTypeExpression(e, type, (((void *)0)), 0, 1))
18009 {
18010 FreeType(e->expType);
18011 e->expType = (((void *)0));
18012 FreeType(type);
18013 type = (((void *)0));
18014 break;
18015 }
18016 }
18017 }
18018 }
18019 if(e->expType)
18020 {
18021 FreeType(e->expType);
18022 e->expType = (((void *)0));
18023 }
18024 }
18025 }
18026 if(type)
18027 {
18028 typeStringBuf[0] = '\0';
18029 PrintType(type, typeStringBuf, 0, 1);
18030 typeString = typeStringBuf;
18031 FreeType(type);
18032 }
18033 }
18034 if(typeString)
18035 {
18036 struct __ecereNameSpace__ecere__sys__OldList * initializers = MkList();
18037 struct Declarator * decl;
18038 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
18039
18040 if(arrayExp->__anon1.list)
18041 {
18042 struct Expression * e;
18043
18044 builtinCount = (*arrayExp->__anon1.list).count;
18045 type = ProcessTypeString(typeString, 0);
18046 while((e = (*arrayExp->__anon1.list).first))
18047 {
18048 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*arrayExp->__anon1.list), e);
18049 e->destType = type;
18050 type->refCount++;
18051 ProcessExpressionType(e);
18052 ListAdd(initializers, MkInitializerAssignment(e));
18053 }
18054 FreeType(type);
18055 (__ecereNameSpace__ecere__com__eSystem_Delete(arrayExp->__anon1.list), arrayExp->__anon1.list = 0);
18056 }
18057 decl = SpecDeclFromString(typeString, specs, MkDeclaratorIdentifier(id));
18058 stmt->__anon1.compound.declarations = MkListOne(MkDeclaration(CopyList(specs, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl), (((void *)0))))));
18059 ListAdd(stmt->__anon1.compound.declarations, MkDeclaration(specs, MkListOne(MkInitDeclarator(PlugDeclarator(decl, MkDeclaratorArray(MkDeclaratorIdentifier(MkIdentifier("__internalArray")), (((void *)0)))), MkInitializerList(initializers)))));
18060 FreeList(exp, (void *)(FreeExpression));
18061 }
18062 else
18063 {
18064 arrayExp->expType = ProcessTypeString("Container", 0);
18065 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Couldn't determine type of array elements\n", (((void *)0))));
18066 }
18067 }
18068 else if(isLinkList && !isList)
18069 {
18070 struct Declarator * decl;
18071 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
18072
18073 decl = SpecDeclFromString(_class->templateArgs[3].__anon1.__anon1.dataTypeString, specs, MkDeclaratorIdentifier(id));
18074 stmt->__anon1.compound.declarations = MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(decl, (((void *)0))))));
18075 ListAdd(stmt->__anon1.compound.declarations, MkDeclaration(MkListOne(MkSpecifierName(source->__anon1._class->__anon1.registered->fullName)), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internalLinkList")), MkInitializerAssignment(MkExpBrackets(exp))))));
18076 }
18077 else if(_class->templateArgs)
18078 {
18079 if(isMap)
18080 sprintf(iteratorType, "MapIterator<%s, %s >", _class->templateArgs[5].__anon1.__anon1.dataTypeString, _class->templateArgs[6].__anon1.__anon1.dataTypeString);
18081 else
18082 sprintf(iteratorType, "Iterator<%s, %s >", _class->templateArgs[2].__anon1.__anon1.dataTypeString, _class->templateArgs[1].__anon1.__anon1.dataTypeString);
18083 stmt->__anon1.compound.declarations = MkListOne(MkDeclarationInst(MkInstantiationNamed(MkListOne(MkSpecifierName(iteratorType)), MkExpIdentifier(id), MkListOne(MkMembersInitList(MkListOne(MkMemberInit(isMap ? MkListOne(MkIdentifier("map")) : (((void *)0)), MkInitializerAssignment(MkExpBrackets(exp)))))))));
18084 }
18085 symbol = FindSymbol(id->string, curContext, curContext, 0, 0);
18086 if(block)
18087 {
18088 switch(block->type)
18089 {
18090 case 2:
18091 if(block->__anon1.compound.context)
18092 block->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18093 break;
18094 case 4:
18095 if(block->__anon1.ifStmt.stmt && block->__anon1.ifStmt.stmt->type == 2 && block->__anon1.ifStmt.stmt->__anon1.compound.context)
18096 block->__anon1.ifStmt.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18097 if(block->__anon1.ifStmt.elseStmt && block->__anon1.ifStmt.elseStmt->type == 2 && block->__anon1.ifStmt.elseStmt->__anon1.compound.context)
18098 block->__anon1.ifStmt.elseStmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18099 break;
18100 case 5:
18101 if(block->__anon1.switchStmt.stmt && block->__anon1.switchStmt.stmt->type == 2 && block->__anon1.switchStmt.stmt->__anon1.compound.context)
18102 block->__anon1.switchStmt.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18103 break;
18104 case 6:
18105 if(block->__anon1.whileStmt.stmt && block->__anon1.whileStmt.stmt->type == 2 && block->__anon1.whileStmt.stmt->__anon1.compound.context)
18106 block->__anon1.whileStmt.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18107 break;
18108 case 7:
18109 if(block->__anon1.doWhile.stmt && block->__anon1.doWhile.stmt->type == 2 && block->__anon1.doWhile.stmt->__anon1.compound.context)
18110 block->__anon1.doWhile.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18111 break;
18112 case 8:
18113 if(block->__anon1.forStmt.stmt && block->__anon1.forStmt.stmt->type == 2 && block->__anon1.forStmt.stmt->__anon1.compound.context)
18114 block->__anon1.forStmt.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18115 break;
18116 case 18:
18117 if(block->__anon1.forEachStmt.stmt && block->__anon1.forEachStmt.stmt->type == 2 && block->__anon1.forEachStmt.stmt->__anon1.compound.context)
18118 block->__anon1.forEachStmt.stmt->__anon1.compound.context->parent = stmt->__anon1.compound.context;
18119 break;
18120 }
18121 }
18122 if(filter)
18123 {
18124 block = MkIfStmt(filter, block, (((void *)0)));
18125 }
18126 if(isArray)
18127 {
18128 stmt->__anon1.compound.statements = MkListOne(MkForStmt(MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpMember(MkExpIdentifier(MkIdentifier("__internalArray")), MkIdentifier("array"))))), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '<', MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("__internalArray")), MkIdentifier("array")), '+', MkExpMember(MkExpIdentifier(MkIdentifier("__internalArray")), MkIdentifier("count")))))), MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), INC_OP, (((void *)0)))), block));
18129 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.init);
18130 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.check);
18131 ProcessExpressionType((*((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.increment).first);
18132 }
18133 else if(isBuiltin)
18134 {
18135 char count[128];
18136
18137 sprintf(count, "%d", builtinCount);
18138 stmt->__anon1.compound.statements = MkListOne(MkForStmt(MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpIdentifier(MkIdentifier("__internalArray"))))), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '<', MkExpOp(MkExpIdentifier(MkIdentifier("__internalArray")), '+', MkExpConstant(count))))), MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), INC_OP, (((void *)0)))), block));
18139 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.init);
18140 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.check);
18141 ProcessExpressionType((*((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.increment).first);
18142 }
18143 else if(isLinkList && !isList)
18144 {
18145 struct __ecereNameSpace__ecere__com__Class * typeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->templateArgs[3].__anon1.__anon1.dataTypeString);
18146 struct __ecereNameSpace__ecere__com__Class * listItemClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, "ListItem");
18147
18148 if(typeClass && __ecereNameSpace__ecere__com__eClass_IsDerived(typeClass, listItemClass) && _class->templateArgs[5].__anon1.__anon1.dataTypeString && !strcmp(_class->templateArgs[5].__anon1.__anon1.dataTypeString, "LT::link"))
18149 {
18150 stmt->__anon1.compound.statements = MkListOne(MkForStmt(MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpMember(MkExpIdentifier(MkIdentifier("__internalLinkList")), MkIdentifier("first"))))), MkExpressionStmt(MkListOne(MkExpIdentifier(CopyIdentifier(id)))), MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpMember(MkExpIdentifier(CopyIdentifier(id)), MkIdentifier("next")))), block));
18151 }
18152 else
18153 {
18154 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
18155 struct Declarator * decl = SpecDeclFromString(_class->templateArgs[3].__anon1.__anon1.dataTypeString, specs, (((void *)0)));
18156
18157 stmt->__anon1.compound.statements = MkListOne(MkForStmt(MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpMember(MkExpIdentifier(MkIdentifier("__internalLinkList")), MkIdentifier("first"))))), MkExpressionStmt(MkListOne(MkExpIdentifier(CopyIdentifier(id)))), MkListOne(MkExpOp(MkExpIdentifier(CopyIdentifier(id)), '=', MkExpCast(MkTypeName(specs, decl), MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalLinkList")), MkIdentifier("GetNext")), MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("IteratorPointer")), (((void *)0))), MkExpIdentifier(CopyIdentifier(id)))))))), block));
18158 }
18159 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.init);
18160 ProcessStatement(((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.check);
18161 ProcessExpressionType((*((struct Statement *)(*stmt->__anon1.compound.statements).first)->__anon1.forStmt.increment).first);
18162 }
18163 else
18164 {
18165 stmt->__anon1.compound.statements = MkListOne(MkWhileStmt(MkListOne(MkExpCall(MkExpMember(expIt = MkExpIdentifier(CopyIdentifier(id)), MkIdentifier("Next")), (((void *)0)))), block));
18166 }
18167 ProcessExpressionType(expIt);
18168 if((*stmt->__anon1.compound.declarations).first)
18169 ProcessDeclaration((*stmt->__anon1.compound.declarations).first);
18170 if(symbol)
18171 symbol->isIterator = isMap ? 2 : ((isArray || isBuiltin) ? 3 : (isLinkList ? (isList ? 5 : 4) : (isCustomAVLTree ? 6 : 1)));
18172 ProcessStatement(stmt);
18173 curContext = stmt->__anon1.compound.context->parent;
18174 break;
18175 }
18176 else
18177 {
18178 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Expression is not a container\n", (((void *)0))));
18179 }
18180 break;
18181 }
18182 case 9:
18183 break;
18184 case 10:
18185 break;
18186 case 11:
18187 break;
18188 case 12:
18189 {
18190 struct Expression * exp;
18191
18192 if(stmt->__anon1.expressions)
18193 {
18194 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
18195 {
18196 if(!exp->next)
18197 {
18198 if(curFunction && !curFunction->type)
18199 curFunction->type = ProcessType(curFunction->specifiers, curFunction->declarator);
18200 FreeType(exp->destType);
18201 exp->destType = (curFunction && curFunction->type && curFunction->type->kind == 11) ? curFunction->type->__anon1.__anon2.returnType : (((void *)0));
18202 if(exp->destType)
18203 exp->destType->refCount++;
18204 }
18205 ProcessExpressionType(exp);
18206 }
18207 }
18208 break;
18209 }
18210 case 14:
18211 {
18212 ProcessDeclaration(stmt->__anon1.decl);
18213 break;
18214 }
18215 case 13:
18216 {
18217 struct AsmField * field;
18218
18219 if(stmt->__anon1.asmStmt.inputFields)
18220 {
18221 for(field = (*stmt->__anon1.asmStmt.inputFields).first; field; field = field->next)
18222 if(field->expression)
18223 ProcessExpressionType(field->expression);
18224 }
18225 if(stmt->__anon1.asmStmt.outputFields)
18226 {
18227 for(field = (*stmt->__anon1.asmStmt.outputFields).first; field; field = field->next)
18228 if(field->expression)
18229 ProcessExpressionType(field->expression);
18230 }
18231 if(stmt->__anon1.asmStmt.clobberedFields)
18232 {
18233 for(field = (*stmt->__anon1.asmStmt.clobberedFields).first; field; field = field->next)
18234 {
18235 if(field->expression)
18236 ProcessExpressionType(field->expression);
18237 }
18238 }
18239 break;
18240 }
18241 case 17:
18242 {
18243 struct PropertyWatch * propWatch;
18244 struct __ecereNameSpace__ecere__sys__OldList * watches = stmt->__anon1._watch.watches;
18245 struct Expression * object = stmt->__anon1._watch.object;
18246 struct Expression * watcher = stmt->__anon1._watch.watcher;
18247
18248 if(watcher)
18249 ProcessExpressionType(watcher);
18250 if(object)
18251 ProcessExpressionType(object);
18252 if(inCompiler)
18253 {
18254 if(watcher || thisClass)
18255 {
18256 struct External * external = curExternal;
18257 struct Context * context = curContext;
18258
18259 stmt->type = 3;
18260 stmt->__anon1.expressions = MkList();
18261 curExternal = external->prev;
18262 for(propWatch = (*watches).first; propWatch; propWatch = propWatch->next)
18263 {
18264 struct ClassFunction * func;
18265 char watcherName[1024];
18266 struct __ecereNameSpace__ecere__com__Class * watcherClass = watcher ? ((watcher->expType && watcher->expType->kind == 8 && watcher->expType->__anon1._class) ? watcher->expType->__anon1._class->__anon1.registered : (((void *)0))) : thisClass;
18267 struct External * createdExternal;
18268 struct External * externalDecl = MkExternalDeclaration((((void *)0)));
18269
18270 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, externalDecl);
18271 sprintf(watcherName, "__ecerePropertyWatcher_%d", propWatcherID++);
18272 if(propWatch->deleteWatch)
18273 strcat(watcherName, "_delete");
18274 else
18275 {
18276 struct Identifier * propID;
18277
18278 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
18279 {
18280 strcat(watcherName, "_");
18281 strcat(watcherName, propID->string);
18282 }
18283 }
18284 if(object && object->expType && object->expType->kind == 8 && object->expType->__anon1._class && object->expType->__anon1._class->__anon1.registered)
18285 {
18286 func = MkClassFunction(MkListOne(MkSpecifier(VOID)), (((void *)0)), MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(watcherName)), MkListOne(MkTypeName(MkListOne(MkSpecifierName(object->expType->__anon1._class->string)), MkDeclaratorIdentifier(MkIdentifier("value"))))), (((void *)0)));
18287 ProcessClassFunctionBody(func, propWatch->compound);
18288 propWatch->compound = (((void *)0));
18289 createdExternal = ProcessClassFunction(watcherClass, func, ast, curExternal, 1);
18290 createdExternal->symbol->idCode = external->symbol->idCode;
18291 curExternal = createdExternal;
18292 ProcessFunction(createdExternal->__anon1.function);
18293 {
18294 struct Declaration * decl = MkDeclaration(CopyList(createdExternal->__anon1.function->specifiers, (void *)(CopySpecifier)), MkListOne(MkInitDeclarator(CopyDeclarator(createdExternal->__anon1.function->declarator), (((void *)0)))));
18295
18296 externalDecl->__anon1.declaration = decl;
18297 if(decl->symbol && !decl->symbol->__anon2.__anon1.pointerExternal)
18298 decl->symbol->__anon2.__anon1.pointerExternal = externalDecl;
18299 }
18300 if(propWatch->deleteWatch)
18301 {
18302 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
18303
18304 ListAdd(args, CopyExpression(object));
18305 ListAdd(args, watcher ? CopyExpression(watcher) : MkExpIdentifier(MkIdentifier("this")));
18306 ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
18307 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_WatchDestruction")), args));
18308 }
18309 else
18310 {
18311 struct __ecereNameSpace__ecere__com__Class * _class = object->expType->__anon1._class->__anon1.registered;
18312 struct Identifier * propID;
18313
18314 for(propID = (*propWatch->properties).first; propID; propID = propID->next)
18315 {
18316 char propName[1024];
18317 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, propID->string, privateModule);
18318
18319 if(prop)
18320 {
18321 char getName[1024], setName[1024];
18322 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
18323
18324 DeclareProperty(prop, setName, getName);
18325 strcpy(propName, "__ecereProp_");
18326 FullClassNameCat(propName, prop->_class->fullName, 0);
18327 strcat(propName, "_");
18328 FullClassNameCat(propName, prop->name, 1);
18329 ListAdd(args, CopyExpression(object));
18330 ListAdd(args, MkExpIdentifier(MkIdentifier(propName)));
18331 ListAdd(args, watcher ? CopyExpression(watcher) : MkExpIdentifier(MkIdentifier("this")));
18332 ListAdd(args, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpIdentifier(MkIdentifier(watcherName))));
18333 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_Watch")), args));
18334 }
18335 else
18336 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
18337 }
18338 }
18339 }
18340 else
18341 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid watched object\n", (((void *)0))));
18342 }
18343 curExternal = external;
18344 curContext = context;
18345 if(watcher)
18346 FreeExpression(watcher);
18347 if(object)
18348 FreeExpression(object);
18349 FreeList(watches, (void *)(FreePropertyWatch));
18350 }
18351 else
18352 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No observer specified and not inside a _class\n", (((void *)0))));
18353 }
18354 else
18355 {
18356 for(propWatch = (*watches).first; propWatch; propWatch = propWatch->next)
18357 {
18358 ProcessStatement(propWatch->compound);
18359 }
18360 }
18361 break;
18362 }
18363 case 15:
18364 {
18365 struct __ecereNameSpace__ecere__sys__OldList * watches = stmt->__anon1._watch.watches;
18366 struct Expression * object = stmt->__anon1._watch.object;
18367 struct __ecereNameSpace__ecere__com__Class * _class;
18368
18369 if(object)
18370 ProcessExpressionType(object);
18371 if(inCompiler)
18372 {
18373 _class = object ? ((object->expType && object->expType->kind == 8 && object->expType->__anon1._class) ? object->expType->__anon1._class->__anon1.registered : (((void *)0))) : thisClass;
18374 if(_class)
18375 {
18376 struct Identifier * propID;
18377
18378 stmt->type = 3;
18379 stmt->__anon1.expressions = MkList();
18380 if(!watches && curFunction->propSet && (!object || (object->type == 0 && !strcmp(object->__anon1.__anon1.identifier->string, "this"))))
18381 {
18382 watches = MkListOne(MkIdentifier(curFunction->propSet->string));
18383 }
18384 else if(!watches)
18385 {
18386 }
18387 if(watches)
18388 {
18389 for(propID = (*watches).first; propID; propID = propID->next)
18390 {
18391 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, propID->string, privateModule);
18392
18393 if(prop)
18394 {
18395 CreateFireWatcher(prop, object, stmt);
18396 }
18397 else
18398 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
18399 }
18400 }
18401 else
18402 {
18403 struct __ecereNameSpace__ecere__com__Property * prop;
18404 struct __ecereNameSpace__ecere__com__Class * base;
18405
18406 for(base = _class; base; base = base->base)
18407 {
18408 for(prop = base->membersAndProperties.first; prop; prop = prop->next)
18409 {
18410 if(prop->isProperty && prop->isWatchable)
18411 {
18412 CreateFireWatcher(prop, object, stmt);
18413 }
18414 }
18415 }
18416 }
18417 if(object)
18418 FreeExpression(object);
18419 FreeList(watches, (void *)(FreeIdentifier));
18420 }
18421 else
18422 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid object specified and not inside a class\n", (((void *)0))));
18423 }
18424 break;
18425 }
18426 case 16:
18427 {
18428 struct __ecereNameSpace__ecere__sys__OldList * watches = stmt->__anon1._watch.watches;
18429 struct Expression * object = stmt->__anon1._watch.object;
18430 struct Expression * watcher = stmt->__anon1._watch.watcher;
18431 struct __ecereNameSpace__ecere__com__Class * _class;
18432
18433 if(object)
18434 ProcessExpressionType(object);
18435 if(watcher)
18436 ProcessExpressionType(watcher);
18437 if(inCompiler)
18438 {
18439 _class = (object && object->expType && object->expType->kind == 8 && object->expType->__anon1._class) ? object->expType->__anon1._class->__anon1.registered : (((void *)0));
18440 if(watcher || thisClass)
18441 {
18442 if(_class)
18443 {
18444 struct Identifier * propID;
18445
18446 stmt->type = 3;
18447 stmt->__anon1.expressions = MkList();
18448 if(!watches)
18449 {
18450 struct __ecereNameSpace__ecere__sys__OldList * args;
18451
18452 args = MkList();
18453 ListAdd(args, CopyExpression(object));
18454 ListAdd(args, MkExpConstant("0"));
18455 ListAdd(args, watcher ? CopyExpression(watcher) : MkExpIdentifier(MkIdentifier("this")));
18456 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_StopWatching")), args));
18457 }
18458 else
18459 {
18460 for(propID = (*watches).first; propID; propID = propID->next)
18461 {
18462 char propName[1024];
18463 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, propID->string, privateModule);
18464
18465 if(prop)
18466 {
18467 char getName[1024], setName[1024];
18468 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
18469
18470 DeclareProperty(prop, setName, getName);
18471 strcpy(propName, "__ecereProp_");
18472 FullClassNameCat(propName, prop->_class->fullName, 0);
18473 strcat(propName, "_");
18474 FullClassNameCat(propName, prop->name, 1);
18475 ListAdd(args, CopyExpression(object));
18476 ListAdd(args, MkExpIdentifier(MkIdentifier(propName)));
18477 ListAdd(args, watcher ? CopyExpression(watcher) : MkExpIdentifier(MkIdentifier("this")));
18478 ListAdd(stmt->__anon1.expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_StopWatching")), args));
18479 }
18480 else
18481 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
18482 }
18483 }
18484 if(object)
18485 FreeExpression(object);
18486 if(watcher)
18487 FreeExpression(watcher);
18488 FreeList(watches, (void *)(FreeIdentifier));
18489 }
18490 else
18491 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid object specified and not inside a class\n", (((void *)0))));
18492 }
18493 else
18494 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No observer specified and not inside a class\n", (((void *)0))));
18495 }
18496 break;
18497 }
18498 }
18499 }
18500
18501 extern struct Expression * QBrackets(struct Expression * exp);
18502
18503 extern struct TypeName * QMkType(const char *  spec, struct Declarator * decl);
18504
18505 extern struct Declarator * QMkPtrDecl(const char *  id);
18506
18507 extern struct Expression * MkExpPointer(struct Expression * expression, struct Identifier * member);
18508
18509 extern struct Expression * QMkExpCond(struct Expression * cond, struct Expression * exp, struct Expression * elseExp);
18510
18511 extern struct Statement * MkFireWatchersStmt(struct Expression * object, struct __ecereNameSpace__ecere__sys__OldList * watches);
18512
18513 static void ProcessFunction(struct FunctionDefinition * function)
18514 {
18515 struct Identifier * id = GetDeclId(function->declarator);
18516 struct Symbol * symbol = function->declarator ? function->declarator->symbol : (((void *)0));
18517 struct Type * type = symbol ? symbol->type : (((void *)0));
18518 struct __ecereNameSpace__ecere__com__Class * oldThisClass = thisClass;
18519 struct Context * oldTopContext = topContext;
18520
18521 yylloc = function->loc;
18522 if(type && type->__anon1.__anon2.thisClass)
18523 {
18524 struct Symbol * classSym = type->__anon1.__anon2.thisClass;
18525 struct __ecereNameSpace__ecere__com__Class * _class = type->__anon1.__anon2.thisClass->__anon1.registered;
18526 char className[1024];
18527 char structName[1024];
18528 struct Declarator * funcDecl;
18529 struct Symbol * thisSymbol;
18530 unsigned int typedObject = 0;
18531
18532 if(_class && !_class->base)
18533 {
18534 _class = currentClass;
18535 if(_class && !_class->symbol)
18536 _class->symbol = FindClass(_class->fullName);
18537 classSym = _class ? _class->symbol : (((void *)0));
18538 typedObject = 1;
18539 }
18540 thisClass = _class;
18541 if(inCompiler && _class)
18542 {
18543 if(type->kind == 11)
18544 {
18545 if(symbol->type->__anon1.__anon2.params.count == 1 && ((struct Type *)symbol->type->__anon1.__anon2.params.first)->kind == 0)
18546 {
18547 struct Type * param = symbol->type->__anon1.__anon2.params.first;
18548
18549 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&symbol->type->__anon1.__anon2.params, param);
18550 FreeType(param);
18551 }
18552 if(type->classObjectType != 1)
18553 {
18554 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(&symbol->type->__anon1.__anon2.params, (((void *)0)), MkClassType(_class->fullName));
18555 symbol->type->__anon1.__anon2.staticMethod = 1;
18556 symbol->type->__anon1.__anon2.thisClass = (((void *)0));
18557 symbol->type->extraParam = 0;
18558 }
18559 }
18560 strcpy(className, "__ecereClass_");
18561 FullClassNameCat(className, _class->fullName, 1);
18562 structName[0] = (char)0;
18563 FullClassNameCat(structName, _class->fullName, 0);
18564 funcDecl = GetFuncDecl(function->declarator);
18565 if(funcDecl)
18566 {
18567 if(funcDecl->__anon1.function.parameters && (*funcDecl->__anon1.function.parameters).count == 1)
18568 {
18569 struct TypeName * param = (*funcDecl->__anon1.function.parameters).first;
18570
18571 if(param->qualifiers && (*param->qualifiers).count == 1 && ((struct Specifier *)(*param->qualifiers).first)->__anon1.specifier == VOID && !param->declarator)
18572 {
18573 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*funcDecl->__anon1.function.parameters), param);
18574 FreeTypeName(param);
18575 }
18576 }
18577 if(!function->propertyNoThis)
18578 {
18579 struct TypeName * thisParam = (((void *)0));
18580
18581 if(type->classObjectType != 1)
18582 {
18583 thisParam = QMkClass(_class->fullName, MkDeclaratorIdentifier(MkIdentifier("this")));
18584 if(!funcDecl->__anon1.function.parameters)
18585 funcDecl->__anon1.function.parameters = MkList();
18586 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->__anon1.function.parameters), (((void *)0)), thisParam);
18587 }
18588 if(typedObject)
18589 {
18590 if(type->classObjectType != 1)
18591 {
18592 if(type->byReference || _class->type == 3 || _class->type == 1000 || _class->type == 4 || _class->type == 2)
18593 thisParam->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), thisParam->declarator);
18594 }
18595 thisParam = __extension__ ({
18596 struct TypeName * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_TypeName);
18597
18598 __ecereInstance1->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier("class"))), __ecereInstance1->qualifiers = MkListOne(MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0)))), __ecereInstance1;
18599 });
18600 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->__anon1.function.parameters), (((void *)0)), thisParam);
18601 }
18602 }
18603 }
18604 if(symbol && symbol->__anon2.__anon1.pointerExternal && symbol->__anon2.__anon1.pointerExternal->type == 1)
18605 {
18606 struct InitDeclarator * initDecl = (*symbol->__anon2.__anon1.pointerExternal->__anon1.declaration->__anon1.__anon1.declarators).first;
18607
18608 funcDecl = GetFuncDecl(initDecl->declarator);
18609 if(funcDecl)
18610 {
18611 if(funcDecl->__anon1.function.parameters && (*funcDecl->__anon1.function.parameters).count == 1)
18612 {
18613 struct TypeName * param = (*funcDecl->__anon1.function.parameters).first;
18614
18615 if(param->qualifiers && (*param->qualifiers).count == 1 && ((struct Specifier *)(*param->qualifiers).first)->__anon1.specifier == VOID && !param->declarator)
18616 {
18617 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*funcDecl->__anon1.function.parameters), param);
18618 FreeTypeName(param);
18619 }
18620 }
18621 if(type->classObjectType != 1)
18622 {
18623 if((_class->type != 2 && _class->type != 3 && _class->type != 4) || function != (struct FunctionDefinition *)symbol->__anon2.__anon2.externalSet)
18624 {
18625 struct TypeName * thisParam = QMkClass(_class->fullName, MkDeclaratorIdentifier(MkIdentifier("this")));
18626
18627 if(!funcDecl->__anon1.function.parameters)
18628 funcDecl->__anon1.function.parameters = MkList();
18629 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->__anon1.function.parameters), (((void *)0)), thisParam);
18630 }
18631 }
18632 }
18633 }
18634 }
18635 if(function->body)
18636 {
18637 if(type->classObjectType != 1)
18638 {
18639 thisSymbol = __extension__ ({
18640 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
18641
18642 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("this"), __ecereInstance1->type = classSym ? MkClassType(classSym->string) : (((void *)0)), __ecereInstance1;
18643 });
18644 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&function->body->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18645 if(typedObject && thisSymbol->type)
18646 {
18647 thisSymbol->type->classObjectType = 2;
18648 thisSymbol->type->byReference = type->byReference;
18649 thisSymbol->type->typedByReference = type->byReference;
18650 }
18651 }
18652 }
18653 if(inCompiler && _class && (_class->type == 0) && type->classObjectType != 1)
18654 {
18655 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
18656
18657 {
18658 struct __ecereNameSpace__ecere__com__Class * base;
18659
18660 for(base = _class; base && base->type != 1000; base = base->next)
18661 {
18662 for(member = base->membersAndProperties.first; member; member = member->next)
18663 if(!member->isProperty)
18664 break;
18665 if(member)
18666 break;
18667 }
18668 }
18669 for(member = _class->membersAndProperties.first; member; member = member->next)
18670 if(!member->isProperty)
18671 break;
18672 if(member)
18673 {
18674 char pointerName[1024];
18675 struct Declaration * decl;
18676 struct Initializer * initializer;
18677 struct Expression * exp, * bytePtr;
18678
18679 strcpy(pointerName, "__ecerePointer_");
18680 FullClassNameCat(pointerName, _class->fullName, 0);
18681 {
18682 char className[1024];
18683
18684 strcpy(className, "__ecereClass_");
18685 FullClassNameCat(className, classSym->string, 1);
18686 DeclareClass(classSym, className);
18687 }
18688 bytePtr = QBrackets(MkExpCast(QMkType("char", QMkPtrDecl((((void *)0)))), QMkExpId("this")));
18689 if(_class->fixed)
18690 {
18691 char string[256];
18692
18693 sprintf(string, "%d", _class->offset);
18694 exp = QBrackets(MkExpOp(bytePtr, '+', MkExpConstant(string)));
18695 }
18696 else
18697 {
18698 exp = QBrackets(MkExpOp(bytePtr, '+', MkExpPointer(QMkExpId(className), MkIdentifier("offset"))));
18699 }
18700 exp = QBrackets(QMkExpCond(QMkExpId("this"), exp, MkExpConstant("0")));
18701 exp->expType = __extension__ ({
18702 struct Type * __ecereInstance2 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
18703
18704 __ecereInstance2->refCount = 1, __ecereInstance2->kind = 13, __ecereInstance2->__anon1.type = __extension__ ({
18705 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
18706
18707 __ecereInstance1->refCount = 1, __ecereInstance1->kind = 0, __ecereInstance1;
18708 }), __ecereInstance2;
18709 });
18710 if(function->body)
18711 {
18712 yylloc = function->body->loc;
18713 initializer = MkInitializerAssignment(MkExpCast(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0)))), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), exp));
18714 {
18715 struct Context * prevContext = curContext;
18716 struct __ecereNameSpace__ecere__sys__OldList * list;
18717
18718 curContext = function->body->__anon1.compound.context;
18719 decl = MkDeclaration((list = MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0))))), MkListOne(MkInitDeclarator(QMkPtrDecl(pointerName), initializer)));
18720 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*list), (((void *)0)), MkSpecifierExtended(MkExtDeclAttrib(MkAttrib(ATTRIB, MkListOne(MkAttribute(__ecereNameSpace__ecere__sys__CopyString("unused"), (((void *)0))))))));
18721 curContext = prevContext;
18722 }
18723 decl->symbol = (((void *)0));
18724 if(!function->body->__anon1.compound.declarations)
18725 function->body->__anon1.compound.declarations = MkList();
18726 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*function->body->__anon1.compound.declarations), (((void *)0)), decl);
18727 }
18728 }
18729 }
18730 }
18731 else
18732 thisClass = (((void *)0));
18733 if(id)
18734 {
18735 FreeSpecifier(id->_class);
18736 id->_class = (((void *)0));
18737 if(symbol && symbol->__anon2.__anon1.pointerExternal && symbol->__anon2.__anon1.pointerExternal->type == 1)
18738 {
18739 struct InitDeclarator * initDecl = (*symbol->__anon2.__anon1.pointerExternal->__anon1.declaration->__anon1.__anon1.declarators).first;
18740
18741 id = GetDeclId(initDecl->declarator);
18742 FreeSpecifier(id->_class);
18743 id->_class = (((void *)0));
18744 }
18745 }
18746 if(function->body)
18747 topContext = function->body->__anon1.compound.context;
18748 {
18749 struct FunctionDefinition * oldFunction = curFunction;
18750
18751 curFunction = function;
18752 if(function->body)
18753 ProcessStatement(function->body);
18754 if(inCompiler && function->propSet && !function->propSet->fireWatchersDone)
18755 {
18756 struct Statement * prevCompound = curCompound;
18757 struct Context * prevContext = curContext;
18758 struct Statement * fireWatchers = MkFireWatchersStmt((((void *)0)), (((void *)0)));
18759
18760 if(!function->body->__anon1.compound.statements)
18761 function->body->__anon1.compound.statements = MkList();
18762 ListAdd(function->body->__anon1.compound.statements, fireWatchers);
18763 curCompound = function->body;
18764 curContext = function->body->__anon1.compound.context;
18765 ProcessStatement(fireWatchers);
18766 curContext = prevContext;
18767 curCompound = prevCompound;
18768 }
18769 curFunction = oldFunction;
18770 }
18771 if(function->declarator)
18772 {
18773 ProcessDeclarator(function->declarator);
18774 }
18775 topContext = oldTopContext;
18776 thisClass = oldThisClass;
18777 }
18778
18779 extern void FreeSymbol(struct Symbol * symbol);
18780
18781 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
18782
18783 static void ProcessClass(struct __ecereNameSpace__ecere__sys__OldList * definitions, struct Symbol * symbol)
18784 {
18785 struct ClassDef * def;
18786 struct External * external = curExternal;
18787 struct __ecereNameSpace__ecere__com__Class * regClass = symbol ? symbol->__anon1.registered : (((void *)0));
18788
18789 for(def = definitions->first; def; def = def->next)
18790 {
18791 if(def->type == 0)
18792 {
18793 if(def->__anon1.function->declarator)
18794 curExternal = def->__anon1.function->declarator->symbol->__anon2.__anon1.pointerExternal;
18795 else
18796 curExternal = external;
18797 ProcessFunction((struct FunctionDefinition *)def->__anon1.function);
18798 }
18799 else if(def->type == 2)
18800 {
18801 if(def->__anon1.decl->type == 2)
18802 {
18803 thisClass = regClass;
18804 ProcessInstantiationType(def->__anon1.decl->__anon1.inst);
18805 thisClass = (((void *)0));
18806 }
18807 else
18808 {
18809 struct __ecereNameSpace__ecere__com__Class * backThisClass = thisClass;
18810
18811 if(regClass)
18812 thisClass = regClass;
18813 ProcessDeclaration(def->__anon1.decl);
18814 thisClass = backThisClass;
18815 }
18816 }
18817 else if(def->type == 1 && def->__anon1.defProperties)
18818 {
18819 struct MemberInit * defProperty;
18820 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = regClass ? MkClassType(regClass->fullName) : (((void *)0)), thisSymbol);
18821
18822 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18823 for(defProperty = (*def->__anon1.defProperties).first; defProperty; defProperty = defProperty->next)
18824 {
18825 thisClass = regClass;
18826 ProcessMemberInitData(defProperty, regClass, (((void *)0)), (((void *)0)), (((void *)0)), (((void *)0)));
18827 thisClass = (((void *)0));
18828 }
18829 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18830 FreeSymbol(thisSymbol);
18831 }
18832 else if(def->type == 3 && def->__anon1.propertyDef)
18833 {
18834 struct PropertyDef * prop = def->__anon1.propertyDef;
18835
18836 thisClass = regClass;
18837 if(prop->setStmt)
18838 {
18839 if(regClass)
18840 {
18841 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
18842
18843 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&prop->setStmt->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18844 }
18845 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalSet : (((void *)0));
18846 ProcessStatement(prop->setStmt);
18847 }
18848 if(prop->getStmt)
18849 {
18850 if(regClass)
18851 {
18852 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
18853
18854 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&prop->getStmt->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18855 }
18856 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalGet : (((void *)0));
18857 ProcessStatement(prop->getStmt);
18858 }
18859 if(prop->issetStmt)
18860 {
18861 if(regClass)
18862 {
18863 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
18864
18865 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&prop->issetStmt->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18866 }
18867 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalIsSet : (((void *)0));
18868 ProcessStatement(prop->issetStmt);
18869 }
18870 thisClass = (((void *)0));
18871 }
18872 else if(def->type == 4 && def->__anon1.propertyWatch)
18873 {
18874 struct PropertyWatch * propertyWatch = def->__anon1.propertyWatch;
18875
18876 thisClass = regClass;
18877 if(propertyWatch->compound)
18878 {
18879 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = regClass ? MkClassType(regClass->fullName) : (((void *)0)), thisSymbol);
18880
18881 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&propertyWatch->compound->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
18882 curExternal = (((void *)0));
18883 ProcessStatement(propertyWatch->compound);
18884 }
18885 thisClass = (((void *)0));
18886 }
18887 }
18888 }
18889
18890 void DeclareFunctionUtil(const char * s)
18891 {
18892 struct __ecereNameSpace__ecere__com__GlobalFunction * function = __ecereNameSpace__ecere__com__eSystem_FindFunction(privateModule, s);
18893
18894 if(function)
18895 {
18896 char name[1024];
18897
18898 name[0] = (char)0;
18899 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)function->module + structSize_Instance)))->importType != 1 && (!function->dataType || !function->dataType->dllExport))
18900 strcpy(name, "__ecereFunction_");
18901 FullClassNameCat(name, s, 0);
18902 DeclareFunction(function, name);
18903 }
18904 }
18905
18906 extern struct __ecereNameSpace__ecere__com__Instance * GetPrivateModule(void);
18907
18908 extern unsigned int memoryGuard;
18909
18910 void ComputeDataTypes()
18911 {
18912 struct External * external;
18913 struct External * temp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_External);
18914 struct External * after = (((void *)0));
18915
18916 currentClass = (((void *)0));
18917 containerClass = __ecereNameSpace__ecere__com__eSystem_FindClass(GetPrivateModule(), "Container");
18918 for(external = (*ast).first; external; external = external->next)
18919 {
18920 if(external->type == 1)
18921 {
18922 struct Declaration * decl = external->__anon1.declaration;
18923
18924 if(decl)
18925 {
18926 struct __ecereNameSpace__ecere__sys__OldList * decls = decl->__anon1.__anon1.declarators;
18927
18928 if(decls)
18929 {
18930 struct InitDeclarator * initDecl = (*decls).first;
18931
18932 if(initDecl)
18933 {
18934 struct Declarator * declarator = initDecl->declarator;
18935
18936 if(declarator && declarator->type == 1)
18937 {
18938 struct Identifier * id = declarator->__anon1.identifier;
18939
18940 if(id && id->string)
18941 {
18942 if(!strcmp(id->string, "uintptr_t") || !strcmp(id->string, "intptr_t") || !strcmp(id->string, "size_t") || !strcmp(id->string, "ssize_t"))
18943 {
18944 external->symbol->id = -1001, external->symbol->idCode = -1001;
18945 after = external;
18946 }
18947 }
18948 }
18949 }
18950 }
18951 }
18952 }
18953 }
18954 {
18955 struct External * e = MkExternalDeclaration(MkDeclaration(MkListOne(MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Instance"), (((void *)0)))), (((void *)0))));
18956
18957 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), after, e);
18958 after = e;
18959 }
18960 temp->symbol = __extension__ ({
18961 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
18962
18963 __ecereInstance1->id = -1000, __ecereInstance1->idCode = -1000, __ecereInstance1;
18964 });
18965 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), after, temp);
18966 curExternal = temp;
18967 DeclareFunctionUtil("eSystem_New");
18968 DeclareFunctionUtil("eSystem_New0");
18969 DeclareFunctionUtil("eSystem_Renew");
18970 DeclareFunctionUtil("eSystem_Renew0");
18971 DeclareFunctionUtil("eSystem_Delete");
18972 DeclareFunctionUtil("eClass_GetProperty");
18973 DeclareFunctionUtil("eClass_SetProperty");
18974 DeclareFunctionUtil("eInstance_FireSelfWatchers");
18975 DeclareFunctionUtil("eInstance_SetMethod");
18976 DeclareFunctionUtil("eInstance_IncRef");
18977 DeclareFunctionUtil("eInstance_StopWatching");
18978 DeclareFunctionUtil("eInstance_Watch");
18979 DeclareFunctionUtil("eInstance_FireWatchers");
18980 if(memoryGuard)
18981 {
18982 DeclareFunctionUtil("MemoryGuard_PushLoc");
18983 DeclareFunctionUtil("MemoryGuard_PopLoc");
18984 }
18985 DeclareStruct("ecere::com::Class", 0);
18986 DeclareStruct("ecere::com::Instance", 0);
18987 DeclareStruct("ecere::com::Property", 0);
18988 DeclareStruct("ecere::com::DataMember", 0);
18989 DeclareStruct("ecere::com::Method", 0);
18990 DeclareStruct("ecere::com::SerialBuffer", 0);
18991 DeclareStruct("ecere::com::ClassTemplateArgument", 0);
18992 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), temp);
18993 for(external = (*ast).first; external; external = external->next)
18994 {
18995 afterExternal = curExternal = external;
18996 if(external->type == 0)
18997 {
18998 currentClass = external->__anon1.function->_class;
18999 ProcessFunction(external->__anon1.function);
19000 }
19001 else if(external->type == 1)
19002 {
19003 currentClass = (((void *)0));
19004 if(external->__anon1.declaration)
19005 ProcessDeclaration(external->__anon1.declaration);
19006 }
19007 else if(external->type == 2)
19008 {
19009 struct ClassDefinition * _class = external->__anon1._class;
19010
19011 currentClass = external->symbol->__anon1.registered;
19012 if(_class->definitions)
19013 {
19014 ProcessClass(_class->definitions, _class->symbol);
19015 }
19016 if(inCompiler)
19017 {
19018 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*ast), external);
19019 ((external ? (__ecereClass_External->Destructor ? __ecereClass_External->Destructor((void *)external) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(external)) : 0), external = 0);
19020 }
19021 }
19022 else if(external->type == 4)
19023 {
19024 thisNameSpace = external->__anon1.id->string;
19025 }
19026 }
19027 currentClass = (((void *)0));
19028 thisNameSpace = (((void *)0));
19029 curExternal = (((void *)0));
19030 ((temp->symbol ? (__ecereClass_Symbol->Destructor ? __ecereClass_Symbol->Destructor((void *)temp->symbol) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(temp->symbol)) : 0), temp->symbol = 0);
19031 ((temp ? (__ecereClass_External->Destructor ? __ecereClass_External->Destructor((void *)temp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(temp)) : 0), temp = 0);
19032 }
19033
19034 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);
19035
19036 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, const char *  name, const char *  baseName, int size, int sizeClass, unsigned int (*  Constructor)(void * ), void (*  Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
19037
19038 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
19039
19040 void __ecereRegisterModule_pass15(struct __ecereNameSpace__ecere__com__Instance * module)
19041 {
19042 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
19043
19044 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetYydebug", "void SetYydebug(bool b)", SetYydebug, module, 1);
19045 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetThisClass", "void SetThisClass(ecere::com::Class c)", SetThisClass, module, 1);
19046 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetThisClass", "ecere::com::Class GetThisClass(void)", GetThisClass, module, 1);
19047 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintExpression", "void PrintExpression(Expression exp, char * string)", PrintExpression, module, 1);
19048 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessTemplateParameterType", "Type ProcessTemplateParameterType(TemplateParameter param)", ProcessTemplateParameterType, module, 2);
19049 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("NeedCast", "bool NeedCast(Type type1, Type type2)", NeedCast, module, 2);
19050 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintInt", "char * PrintInt(int64 result)", PrintInt, module, 1);
19051 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintUInt", "char * PrintUInt(uint64 result)", PrintUInt, module, 1);
19052 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintInt64", "char * PrintInt64(int64 result)", PrintInt64, module, 1);
19053 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintUInt64", "char * PrintUInt64(uint64 result)", PrintUInt64, module, 1);
19054 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintHexUInt", "char * PrintHexUInt(uint64 result)", PrintHexUInt, module, 1);
19055 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintHexUInt64", "char * PrintHexUInt64(uint64 result)", PrintHexUInt64, module, 1);
19056 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintShort", "char * PrintShort(short result)", PrintShort, module, 1);
19057 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintUShort", "char * PrintUShort(uint16 result)", PrintUShort, module, 1);
19058 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintChar", "char * PrintChar(char result)", PrintChar, module, 1);
19059 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintUChar", "char * PrintUChar(byte result)", PrintUChar, module, 1);
19060 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintFloat", "char * PrintFloat(float result)", PrintFloat, module, 1);
19061 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintDouble", "char * PrintDouble(double result)", PrintDouble, module, 1);
19062 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpInt", "bool GetOpInt(Operand op2, int * value2)", GetOpInt, module, 1);
19063 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetInt", "bool GetInt(Expression exp, int * value2)", GetInt, module, 1);
19064 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUInt", "bool GetOpUInt(Operand op2, uint * value2)", GetOpUInt, module, 1);
19065 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUInt", "bool GetUInt(Expression exp, uint * value2)", GetUInt, module, 1);
19066 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpInt64", "bool GetOpInt64(Operand op2, int64 * value2)", GetOpInt64, module, 1);
19067 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetInt64", "bool GetInt64(Expression exp, int64 * value2)", GetInt64, module, 1);
19068 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUInt64", "bool GetOpUInt64(Operand op2, uint64 * value2)", GetOpUInt64, module, 1);
19069 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUInt64", "bool GetUInt64(Expression exp, uint64 * value2)", GetUInt64, module, 1);
19070 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpIntPtr", "bool GetOpIntPtr(Operand op2, intptr * value2)", GetOpIntPtr, module, 1);
19071 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIntPtr", "bool GetIntPtr(Expression exp, intptr * value2)", GetIntPtr, module, 1);
19072 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUIntPtr", "bool GetOpUIntPtr(Operand op2, uintptr * value2)", GetOpUIntPtr, module, 1);
19073 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUIntPtr", "bool GetUIntPtr(Expression exp, uintptr * value2)", GetUIntPtr, module, 1);
19074 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpIntSize", "bool GetOpIntSize(Operand op2, intsize * value2)", GetOpIntSize, module, 1);
19075 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIntSize", "bool GetIntSize(Expression exp, intsize * value2)", GetIntSize, module, 1);
19076 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUIntSize", "bool GetOpUIntSize(Operand op2, uintsize * value2)", GetOpUIntSize, module, 1);
19077 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUIntSize", "bool GetUIntSize(Expression exp, uintsize * value2)", GetUIntSize, module, 1);
19078 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpShort", "bool GetOpShort(Operand op2, short * value2)", GetOpShort, module, 1);
19079 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetShort", "bool GetShort(Expression exp, short * value2)", GetShort, module, 1);
19080 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUShort", "bool GetOpUShort(Operand op2, uint16 * value2)", GetOpUShort, module, 1);
19081 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUShort", "bool GetUShort(Expression exp, uint16 * value2)", GetUShort, module, 1);
19082 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpChar", "bool GetOpChar(Operand op2, char * value2)", GetOpChar, module, 1);
19083 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetChar", "bool GetChar(Expression exp, char * value2)", GetChar, module, 1);
19084 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUChar", "bool GetOpUChar(Operand op2, byte * value2)", GetOpUChar, module, 1);
19085 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUChar", "bool GetUChar(Expression exp, byte * value2)", GetUChar, module, 1);
19086 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpFloat", "bool GetOpFloat(Operand op2, float * value2)", GetOpFloat, module, 1);
19087 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetFloat", "bool GetFloat(Expression exp, float * value2)", GetFloat, module, 1);
19088 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpDouble", "bool GetOpDouble(Operand op2, double * value2)", GetOpDouble, module, 1);
19089 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetDouble", "bool GetDouble(Expression exp, double * value2)", GetDouble, module, 1);
19090 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeClassMembers", "void ComputeClassMembers(ecere::com::Class _class, bool isMember)", ComputeClassMembers, module, 2);
19091 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeModuleClasses", "void ComputeModuleClasses(ecere::com::Module module)", ComputeModuleClasses, module, 1);
19092 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeTypeSize", "int ComputeTypeSize(Type type)", ComputeTypeSize, module, 1);
19093 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("AddMembers", "int AddMembers(ecere::sys::OldList * declarations, ecere::com::Class _class, bool isMember, uint * retSize, ecere::com::Class topClass, bool * addedPadding)", AddMembers, module, 2);
19094 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareStruct", "void DeclareStruct(const char * name, bool skipNoHead)", DeclareStruct, module, 2);
19095 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareProperty", "void DeclareProperty(ecere::com::Property prop, char * setName, char * getName)", DeclareProperty, module, 2);
19096 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("Dereference", "Type Dereference(Type source)", Dereference, module, 1);
19097 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessMemberInitData", "void ProcessMemberInitData(MemberInit member, ecere::com::Class _class, ecere::com::Class * curClass, ecere::com::DataMember * curMember, ecere::com::DataMember * subMemberStack, int * subMemberStackPos)", ProcessMemberInitData, module, 2);
19098 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessInstantiationType", "void ProcessInstantiationType(Instantiation inst)", ProcessInstantiationType, module, 2);
19099 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindTemplateArg", "ecere::com::ClassTemplateArgument * FindTemplateArg(ecere::com::Class _class, TemplateParameter param)", FindTemplateArg, module, 2);
19100 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetupTemplatesContext", "Context SetupTemplatesContext(ecere::com::Class _class)", SetupTemplatesContext, module, 1);
19101 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FinishTemplatesContext", "void FinishTemplatesContext(Context context)", FinishTemplatesContext, module, 1);
19102 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessMethodType", "void ProcessMethodType(ecere::com::Method method)", ProcessMethodType, module, 1);
19103 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessPropertyType", "void ProcessPropertyType(ecere::com::Property prop)", ProcessPropertyType, module, 1);
19104 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareMethod", "void DeclareMethod(ecere::com::Method method, const char * name)", DeclareMethod, module, 1);
19105 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReplaceThisClass", "char * ReplaceThisClass(ecere::com::Class _class)", ReplaceThisClass, module, 2);
19106 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReplaceThisClassType", "Type ReplaceThisClassType(ecere::com::Class _class)", ReplaceThisClassType, module, 2);
19107 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReplaceThisClassSpecifiers", "void ReplaceThisClassSpecifiers(ecere::sys::OldList specs, ecere::com::Class _class)", ReplaceThisClassSpecifiers, module, 2);
19108 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareFunction", "bool DeclareFunction(ecere::com::GlobalFunction function, char * name)", DeclareFunction, module, 2);
19109 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareGlobalData", "void DeclareGlobalData(GlobalData data)", DeclareGlobalData, module, 2);
19110 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "Conversion", 0, sizeof(struct Conversion), 0, (void *)0, (void *)0, module, 2, 1);
19111 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
19112 __ecereClass_Conversion = class;
19113 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchTypes", "bool MatchTypes(Type source, Type dest, ecere::sys::OldList conversions, ecere::com::Class owningClassSource, ecere::com::Class owningClassDest, bool doConversion, bool enumBaseType, bool acceptReversedParams, bool isConversionExploration, bool warnConst)", MatchTypes, module, 1);
19114 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchWithEnums_NameSpace", "bool MatchWithEnums_NameSpace(ecere::com::NameSpace nameSpace, Expression sourceExp, Type dest, char * string, ecere::sys::OldList conversions)", MatchWithEnums_NameSpace, module, 2);
19115 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ModuleVisibility", "bool ModuleVisibility(ecere::com::Module searchIn, ecere::com::Module searchFor)", ModuleVisibility, module, 1);
19116 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchWithEnums_Module", "bool MatchWithEnums_Module(ecere::com::Module mainModule, Expression sourceExp, Type dest, char * string, ecere::sys::OldList conversions)", MatchWithEnums_Module, module, 2);
19117 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchTypeExpression", "bool MatchTypeExpression(Expression sourceExp, Type dest, ecere::sys::OldList conversions, bool skipUnitBla, bool warnConst)", MatchTypeExpression, module, 2);
19118 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReadString", "void ReadString(char * output, char * string)", ReadString, module, 1);
19119 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("UnescapeString", "int UnescapeString(char * d, char * s, int len)", UnescapeString, module, 1);
19120 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("OffsetEscapedString", "char * OffsetEscapedString(char * s, int len, int offset)", OffsetEscapedString, module, 1);
19121 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOperand", "Operand GetOperand(Expression exp)", GetOperand, module, 1);
19122 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PopulateInstance", "void PopulateInstance(Instantiation inst)", PopulateInstance, module, 1);
19123 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeInstantiation", "void ComputeInstantiation(Expression exp)", ComputeInstantiation, module, 1);
19124 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CallOperator", "void CallOperator(Expression exp, Expression exp1, Expression exp2, Operand op1, Operand op2)", CallOperator, module, 1);
19125 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeExpression", "void ComputeExpression(Expression exp)", ComputeExpression, module, 1);
19126 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CheckTemplateTypes", "void CheckTemplateTypes(Expression exp)", CheckTemplateTypes, module, 1);
19127 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindSymbol", "Symbol FindSymbol(const char * name, Context startContext, Context endContext, bool isStruct, bool globalNameSpace)", FindSymbol, module, 1);
19128 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintType", "void PrintType(Type type, char * string, bool printName, bool fullName)", PrintType, module, 1);
19129 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintTypeNoConst", "void PrintTypeNoConst(Type type, char * string, bool printName, bool fullName)", PrintTypeNoConst, module, 1);
19130 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindMemberAndOffset", "Type FindMemberAndOffset(Type type, char * string, uint * offset)", FindMemberAndOffset, module, 1);
19131 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetParseError", "bool GetParseError(void)", GetParseError, module, 1);
19132 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ParseExpressionString", "Expression ParseExpressionString(char * expression)", ParseExpressionString, module, 1);
19133 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReplaceExpContents", "void ReplaceExpContents(Expression checkedExp, Expression newExp)", ReplaceExpContents, module, 1);
19134 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ApplyAnyObjectLogic", "void ApplyAnyObjectLogic(Expression e)", ApplyAnyObjectLogic, module, 1);
19135 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ApplyLocation", "void ApplyLocation(Expression exp, Location loc)", ApplyLocation, module, 1);
19136 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessExpressionType", "void ProcessExpressionType(Expression exp)", ProcessExpressionType, module, 1);
19137 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareFunctionUtil", "void DeclareFunctionUtil(const String s)", DeclareFunctionUtil, module, 1);
19138 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeDataTypes", "void ComputeDataTypes(void)", ComputeDataTypes, module, 1);
19139 }
19140
19141 void __ecereUnregisterModule_pass15(struct __ecereNameSpace__ecere__com__Instance * module)
19142 {
19143
19144 }
19145