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

   1 /* Code generated from eC source file: dbpass.ec */
   2 #if defined(__GNUC__)
   3 typedef long long int64;
   4 typedef unsigned long long uint64;
   5 #ifndef _WIN32
   6 #define __declspec(x)
   7 #endif
   8 #elif defined(__TINYC__)
   9 #include <stdarg.h>
  10 #define __builtin_va_list va_list
  11 #define __builtin_va_start va_start
  12 #define __builtin_va_end va_end
  13 #ifdef _WIN32
  14 #define strcasecmp stricmp
  15 #define strncasecmp strnicmp
  16 #define __declspec(x) __attribute__((x))
  17 #else
  18 #define __declspec(x)
  19 #endif
  20 typedef long long int64;
  21 typedef unsigned long long uint64;
  22 #else
  23 typedef __int64 int64;
  24 typedef unsigned __int64 uint64;
  25 #endif
  26 #ifdef __BIG_ENDIAN__
  27 #define __ENDIAN_PAD(x) (8 - (x))
  28 #else
  29 #define __ENDIAN_PAD(x) 0
  30 #endif
  31 #include <stdint.h>
  32 #include <sys/types.h>
  33 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  34
  35 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  36
  37 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  38
  39 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  40
  41 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
  42
  43 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  44
  45 struct __ecereNameSpace__ecere__sys__BTNode;
  46
  47 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  48
  49 struct __ecereNameSpace__ecere__sys__BinaryTree
  50 {
  51 struct __ecereNameSpace__ecere__sys__BTNode * root;
  52 int count;
  53 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  54 void (*  FreeKey)(void *  key);
  55 } __attribute__ ((gcc_struct));
  56
  57 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  58
  59 struct __ecereNameSpace__ecere__sys__OldList
  60 {
  61 void *  first;
  62 void *  last;
  63 int count;
  64 unsigned int offset;
  65 unsigned int circ;
  66 } __attribute__ ((gcc_struct));
  67
  68 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  69
  70 struct __ecereNameSpace__ecere__com__Method
  71 {
  72 const char *  name;
  73 struct __ecereNameSpace__ecere__com__Method * parent;
  74 struct __ecereNameSpace__ecere__com__Method * left;
  75 struct __ecereNameSpace__ecere__com__Method * right;
  76 int depth;
  77 int (*  function)();
  78 int vid;
  79 int type;
  80 struct __ecereNameSpace__ecere__com__Class * _class;
  81 void *  symbol;
  82 const char *  dataTypeString;
  83 struct Type * dataType;
  84 int memberAccess;
  85 } __attribute__ ((gcc_struct));
  86
  87 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
  88
  89 struct __ecereNameSpace__ecere__com__Property
  90 {
  91 struct __ecereNameSpace__ecere__com__Property * prev;
  92 struct __ecereNameSpace__ecere__com__Property * next;
  93 const char *  name;
  94 unsigned int isProperty;
  95 int memberAccess;
  96 int id;
  97 struct __ecereNameSpace__ecere__com__Class * _class;
  98 const char *  dataTypeString;
  99 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 100 struct Type * dataType;
 101 void (*  Set)(void * , int);
 102 int (*  Get)(void * );
 103 unsigned int (*  IsSet)(void * );
 104 void *  data;
 105 void *  symbol;
 106 int vid;
 107 unsigned int conversion;
 108 unsigned int watcherOffset;
 109 const char *  category;
 110 unsigned int compiled;
 111 unsigned int selfWatchable;
 112 unsigned int isWatchable;
 113 } __attribute__ ((gcc_struct));
 114
 115 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
 116
 117 struct CodePosition
 118 {
 119 int line;
 120 int charPos;
 121 int pos;
 122 int included;
 123 } __attribute__ ((gcc_struct));
 124
 125 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 126
 127 struct Location
 128 {
 129 struct CodePosition start;
 130 struct CodePosition end;
 131 } __attribute__ ((gcc_struct));
 132
 133 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attrib;
 134
 135 struct Attrib;
 136
 137 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ExtDecl;
 138
 139 struct ExtDecl;
 140
 141 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 142
 143 struct ClassDefinition
 144 {
 145 struct ClassDefinition * prev;
 146 struct ClassDefinition * next;
 147 struct Location loc;
 148 struct Specifier * _class;
 149 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 150 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 151 struct Symbol * symbol;
 152 struct Location blockStart;
 153 struct Location nameLoc;
 154 int endid;
 155 int declMode;
 156 unsigned int deleteWatchable;
 157 } __attribute__ ((gcc_struct));
 158
 159 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 160
 161 struct Context
 162 {
 163 struct Context * parent;
 164 struct __ecereNameSpace__ecere__sys__BinaryTree types;
 165 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 166 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
 167 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
 168 int nextID;
 169 int simpleID;
 170 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
 171 struct ClassDefinition * classDef;
 172 unsigned int templateTypesOnly;
 173 unsigned int hasNameSpace;
 174 } __attribute__ ((gcc_struct));
 175
 176 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 177
 178 struct Instantiation
 179 {
 180 struct Instantiation * prev;
 181 struct Instantiation * next;
 182 struct Location loc;
 183 struct Specifier * _class;
 184 struct Expression * exp;
 185 struct __ecereNameSpace__ecere__sys__OldList *  members;
 186 struct Symbol * symbol;
 187 unsigned int fullSet;
 188 unsigned int isConstant;
 189 unsigned char *  data;
 190 struct Location nameLoc;
 191 struct Location insideLoc;
 192 unsigned int built;
 193 } __attribute__ ((gcc_struct));
 194
 195 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 196
 197 struct Declaration
 198 {
 199 struct Declaration * prev;
 200 struct Declaration * next;
 201 struct Location loc;
 202 int type;
 203 union
 204 {
 205 struct
 206 {
 207 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 208 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 209 } __attribute__ ((gcc_struct));
 210 struct Instantiation * inst;
 211 struct
 212 {
 213 struct Identifier * id;
 214 struct Expression * exp;
 215 } __attribute__ ((gcc_struct));
 216 } __attribute__ ((gcc_struct));
 217 struct Specifier * extStorage;
 218 struct Symbol * symbol;
 219 int declMode;
 220 } __attribute__ ((gcc_struct));
 221
 222 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 223
 224 struct Statement
 225 {
 226 struct Statement * prev;
 227 struct Statement * next;
 228 struct Location loc;
 229 int type;
 230 union
 231 {
 232 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 233 struct
 234 {
 235 struct Identifier * id;
 236 struct Statement * stmt;
 237 } __attribute__ ((gcc_struct)) labeled;
 238 struct
 239 {
 240 struct Expression * exp;
 241 struct Statement * stmt;
 242 } __attribute__ ((gcc_struct)) caseStmt;
 243 struct
 244 {
 245 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 246 struct __ecereNameSpace__ecere__sys__OldList * statements;
 247 struct Context * context;
 248 unsigned int isSwitch;
 249 } __attribute__ ((gcc_struct)) compound;
 250 struct
 251 {
 252 struct __ecereNameSpace__ecere__sys__OldList * exp;
 253 struct Statement * stmt;
 254 struct Statement * elseStmt;
 255 } __attribute__ ((gcc_struct)) ifStmt;
 256 struct
 257 {
 258 struct __ecereNameSpace__ecere__sys__OldList * exp;
 259 struct Statement * stmt;
 260 } __attribute__ ((gcc_struct)) switchStmt;
 261 struct
 262 {
 263 struct __ecereNameSpace__ecere__sys__OldList * exp;
 264 struct Statement * stmt;
 265 } __attribute__ ((gcc_struct)) whileStmt;
 266 struct
 267 {
 268 struct __ecereNameSpace__ecere__sys__OldList * exp;
 269 struct Statement * stmt;
 270 } __attribute__ ((gcc_struct)) doWhile;
 271 struct
 272 {
 273 struct Statement * init;
 274 struct Statement * check;
 275 struct __ecereNameSpace__ecere__sys__OldList * increment;
 276 struct Statement * stmt;
 277 } __attribute__ ((gcc_struct)) forStmt;
 278 struct
 279 {
 280 struct Identifier * id;
 281 } __attribute__ ((gcc_struct)) gotoStmt;
 282 struct
 283 {
 284 struct Specifier * spec;
 285 char * statements;
 286 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 287 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 288 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 289 } __attribute__ ((gcc_struct)) asmStmt;
 290 struct
 291 {
 292 struct Expression * watcher;
 293 struct Expression * object;
 294 struct __ecereNameSpace__ecere__sys__OldList * watches;
 295 } __attribute__ ((gcc_struct)) _watch;
 296 struct
 297 {
 298 struct Identifier * id;
 299 struct __ecereNameSpace__ecere__sys__OldList * exp;
 300 struct __ecereNameSpace__ecere__sys__OldList * filter;
 301 struct Statement * stmt;
 302 } __attribute__ ((gcc_struct)) forEachStmt;
 303 struct Declaration * decl;
 304 } __attribute__ ((gcc_struct));
 305 } __attribute__ ((gcc_struct));
 306
 307 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 308
 309 struct TypeName
 310 {
 311 struct TypeName * prev;
 312 struct TypeName * next;
 313 struct Location loc;
 314 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 315 struct Declarator * declarator;
 316 int classObjectType;
 317 struct Expression * bitCount;
 318 } __attribute__ ((gcc_struct));
 319
 320 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 321
 322 struct Initializer
 323 {
 324 struct Initializer * prev;
 325 struct Initializer * next;
 326 struct Location loc;
 327 int type;
 328 union
 329 {
 330 struct Expression * exp;
 331 struct __ecereNameSpace__ecere__sys__OldList *  list;
 332 } __attribute__ ((gcc_struct));
 333 unsigned int isConstant;
 334 struct Identifier * id;
 335 } __attribute__ ((gcc_struct));
 336
 337 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 338
 339 struct __ecereNameSpace__ecere__com__DataValue
 340 {
 341 union
 342 {
 343 char c;
 344 unsigned char uc;
 345 short s;
 346 unsigned short us;
 347 int i;
 348 unsigned int ui;
 349 void *  p;
 350 float f;
 351 double d;
 352 long long i64;
 353 uint64 ui64;
 354 } __attribute__ ((gcc_struct));
 355 } __attribute__ ((gcc_struct));
 356
 357 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 358
 359 struct Expression
 360 {
 361 struct Expression * prev;
 362 struct Expression * next;
 363 struct Location loc;
 364 int type;
 365 union
 366 {
 367 struct
 368 {
 369 char *  constant;
 370 struct Identifier * identifier;
 371 } __attribute__ ((gcc_struct));
 372 struct Statement * compound;
 373 struct Instantiation * instance;
 374 struct
 375 {
 376 char *  string;
 377 unsigned int intlString;
 378 } __attribute__ ((gcc_struct));
 379 struct __ecereNameSpace__ecere__sys__OldList *  list;
 380 struct
 381 {
 382 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 383 struct Declarator * decl;
 384 } __attribute__ ((gcc_struct)) _classExp;
 385 struct
 386 {
 387 struct Identifier * id;
 388 } __attribute__ ((gcc_struct)) classData;
 389 struct
 390 {
 391 struct Expression * exp;
 392 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 393 struct Location argLoc;
 394 } __attribute__ ((gcc_struct)) call;
 395 struct
 396 {
 397 struct Expression * exp;
 398 struct __ecereNameSpace__ecere__sys__OldList * index;
 399 } __attribute__ ((gcc_struct)) index;
 400 struct
 401 {
 402 struct Expression * exp;
 403 struct Identifier * member;
 404 int memberType;
 405 unsigned int thisPtr;
 406 } __attribute__ ((gcc_struct)) member;
 407 struct
 408 {
 409 int op;
 410 struct Expression * exp1;
 411 struct Expression * exp2;
 412 } __attribute__ ((gcc_struct)) op;
 413 struct TypeName * typeName;
 414 struct Specifier * _class;
 415 struct
 416 {
 417 struct TypeName * typeName;
 418 struct Expression * exp;
 419 } __attribute__ ((gcc_struct)) cast;
 420 struct
 421 {
 422 struct Expression * cond;
 423 struct __ecereNameSpace__ecere__sys__OldList * exp;
 424 struct Expression * elseExp;
 425 } __attribute__ ((gcc_struct)) cond;
 426 struct
 427 {
 428 struct TypeName * typeName;
 429 struct Expression * size;
 430 } __attribute__ ((gcc_struct)) _new;
 431 struct
 432 {
 433 struct TypeName * typeName;
 434 struct Expression * size;
 435 struct Expression * exp;
 436 } __attribute__ ((gcc_struct)) _renew;
 437 struct
 438 {
 439 char * table;
 440 struct Identifier * id;
 441 } __attribute__ ((gcc_struct)) db;
 442 struct
 443 {
 444 struct Expression * ds;
 445 struct Expression * name;
 446 } __attribute__ ((gcc_struct)) dbopen;
 447 struct
 448 {
 449 struct TypeName * typeName;
 450 struct Initializer * initializer;
 451 } __attribute__ ((gcc_struct)) initializer;
 452 struct
 453 {
 454 struct Expression * exp;
 455 struct TypeName * typeName;
 456 } __attribute__ ((gcc_struct)) vaArg;
 457 } __attribute__ ((gcc_struct));
 458 unsigned int debugValue;
 459 struct __ecereNameSpace__ecere__com__DataValue val;
 460 uint64 address;
 461 unsigned int hasAddress;
 462 struct Type * expType;
 463 struct Type * destType;
 464 unsigned int usage;
 465 int tempCount;
 466 unsigned int byReference;
 467 unsigned int isConstant;
 468 unsigned int addedThis;
 469 unsigned int needCast;
 470 unsigned int thisPtr;
 471 unsigned int opDestType;
 472 } __attribute__ ((gcc_struct));
 473
 474 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 475
 476 struct TemplateDatatype;
 477
 478 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 479
 480 struct TemplateArgument;
 481
 482 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 483
 484 struct TemplateParameter;
 485
 486 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 487
 488 struct Specifier
 489 {
 490 struct Specifier * prev;
 491 struct Specifier * next;
 492 struct Location loc;
 493 int type;
 494 union
 495 {
 496 int specifier;
 497 struct
 498 {
 499 struct ExtDecl * extDecl;
 500 char *  name;
 501 struct Symbol * symbol;
 502 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 503 } __attribute__ ((gcc_struct));
 504 struct
 505 {
 506 struct Identifier * id;
 507 struct __ecereNameSpace__ecere__sys__OldList *  list;
 508 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 509 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 510 unsigned int addNameSpace;
 511 struct Context * ctx;
 512 struct ExtDecl * extDeclStruct;
 513 } __attribute__ ((gcc_struct));
 514 struct Expression * expression;
 515 struct Specifier * _class;
 516 struct TemplateParameter * templateParameter;
 517 } __attribute__ ((gcc_struct));
 518 } __attribute__ ((gcc_struct));
 519
 520 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 521
 522 struct Identifier
 523 {
 524 struct Identifier * prev;
 525 struct Identifier * next;
 526 struct Location loc;
 527 struct Symbol * classSym;
 528 struct Specifier * _class;
 529 char *  string;
 530 struct Identifier * badID;
 531 } __attribute__ ((gcc_struct));
 532
 533 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 534
 535 struct Pointer;
 536
 537 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 538
 539 struct Declarator;
 540
 541 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 542
 543 struct FunctionDefinition
 544 {
 545 struct FunctionDefinition * prev;
 546 struct FunctionDefinition * next;
 547 struct Location loc;
 548 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 549 struct Declarator * declarator;
 550 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 551 struct Statement * body;
 552 struct __ecereNameSpace__ecere__com__Class * _class;
 553 struct __ecereNameSpace__ecere__sys__OldList attached;
 554 int declMode;
 555 struct Type * type;
 556 struct Symbol * propSet;
 557 int tempCount;
 558 unsigned int propertyNoThis;
 559 } __attribute__ ((gcc_struct));
 560
 561 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 562
 563 struct DBTableDef
 564 {
 565 char *  name;
 566 struct Symbol * symbol;
 567 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 568 int declMode;
 569 } __attribute__ ((gcc_struct));
 570
 571 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 572
 573 struct External
 574 {
 575 struct External * prev;
 576 struct External * next;
 577 struct Location loc;
 578 int type;
 579 struct Symbol * symbol;
 580 union
 581 {
 582 struct FunctionDefinition * function;
 583 struct ClassDefinition * _class;
 584 struct Declaration * declaration;
 585 char *  importString;
 586 struct Identifier * id;
 587 struct DBTableDef * table;
 588 } __attribute__ ((gcc_struct));
 589 int importType;
 590 } __attribute__ ((gcc_struct));
 591
 592 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 593
 594 struct ModuleImport;
 595
 596 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 597
 598 struct ClassImport;
 599
 600 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 601
 602 struct Symbol
 603 {
 604 char *  string;
 605 struct Symbol * parent;
 606 struct Symbol * left;
 607 struct Symbol * right;
 608 int depth;
 609 struct Type * type;
 610 union
 611 {
 612 struct __ecereNameSpace__ecere__com__Method * method;
 613 struct __ecereNameSpace__ecere__com__Property * _property;
 614 struct __ecereNameSpace__ecere__com__Class * registered;
 615 } __attribute__ ((gcc_struct));
 616 int id;
 617 int idCode;
 618 union
 619 {
 620 struct
 621 {
 622 struct External * pointerExternal;
 623 struct External * structExternal;
 624 } __attribute__ ((gcc_struct));
 625 struct
 626 {
 627 struct External * externalGet;
 628 struct External * externalSet;
 629 struct External * externalPtr;
 630 struct External * externalIsSet;
 631 } __attribute__ ((gcc_struct));
 632 struct
 633 {
 634 struct External * methodExternal;
 635 struct External * methodCodeExternal;
 636 } __attribute__ ((gcc_struct));
 637 } __attribute__ ((gcc_struct));
 638 unsigned int imported;
 639 unsigned int declaredStructSym;
 640 struct __ecereNameSpace__ecere__com__Class * _class;
 641 unsigned int declaredStruct;
 642 unsigned int needConstructor;
 643 unsigned int needDestructor;
 644 char *  constructorName;
 645 char *  structName;
 646 char *  className;
 647 char *  destructorName;
 648 struct ModuleImport * module;
 649 struct ClassImport * _import;
 650 struct Location nameLoc;
 651 unsigned int isParam;
 652 unsigned int isRemote;
 653 unsigned int isStruct;
 654 unsigned int fireWatchersDone;
 655 int declaring;
 656 unsigned int classData;
 657 unsigned int isStatic;
 658 char *  shortName;
 659 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 660 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 661 struct Context * ctx;
 662 int isIterator;
 663 struct Expression * propCategory;
 664 } __attribute__ ((gcc_struct));
 665
 666 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 667
 668 struct Type
 669 {
 670 struct Type * prev;
 671 struct Type * next;
 672 int refCount;
 673 union
 674 {
 675 struct Symbol * _class;
 676 struct
 677 {
 678 struct __ecereNameSpace__ecere__sys__OldList members;
 679 char *  enumName;
 680 } __attribute__ ((gcc_struct));
 681 struct
 682 {
 683 struct Type * returnType;
 684 struct __ecereNameSpace__ecere__sys__OldList params;
 685 struct Symbol * thisClass;
 686 unsigned int staticMethod;
 687 struct TemplateParameter * thisClassTemplate;
 688 } __attribute__ ((gcc_struct));
 689 struct
 690 {
 691 struct __ecereNameSpace__ecere__com__Method * method;
 692 struct __ecereNameSpace__ecere__com__Class * methodClass;
 693 struct __ecereNameSpace__ecere__com__Class * usedClass;
 694 } __attribute__ ((gcc_struct));
 695 struct
 696 {
 697 struct Type * arrayType;
 698 int arraySize;
 699 struct Expression * arraySizeExp;
 700 unsigned int freeExp;
 701 struct Symbol * enumClass;
 702 } __attribute__ ((gcc_struct));
 703 struct Type * type;
 704 struct TemplateParameter * templateParameter;
 705 } __attribute__ ((gcc_struct));
 706 int kind;
 707 unsigned int size;
 708 char *  name;
 709 char *  typeName;
 710 int classObjectType;
 711 int alignment;
 712 unsigned int offset;
 713 int bitFieldCount;
 714 int count;
 715 unsigned int isSigned : 1;
 716 unsigned int constant : 1;
 717 unsigned int truth : 1;
 718 unsigned int byReference : 1;
 719 unsigned int extraParam : 1;
 720 unsigned int directClassAccess : 1;
 721 unsigned int computing : 1;
 722 unsigned int keepCast : 1;
 723 unsigned int passAsTemplate : 1;
 724 unsigned int dllExport : 1;
 725 unsigned int attrStdcall : 1;
 726 unsigned int declaredWithStruct : 1;
 727 unsigned int typedByReference : 1;
 728 unsigned int casted : 1;
 729 } __attribute__ ((gcc_struct));
 730
 731 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 732
 733 struct __ecereNameSpace__ecere__com__Class
 734 {
 735 struct __ecereNameSpace__ecere__com__Class * prev;
 736 struct __ecereNameSpace__ecere__com__Class * next;
 737 const char *  name;
 738 int offset;
 739 int structSize;
 740 int (* *  _vTbl)();
 741 int vTblSize;
 742 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 743 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 744 int offsetClass;
 745 int sizeClass;
 746 struct __ecereNameSpace__ecere__com__Class * base;
 747 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 748 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 749 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 750 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 751 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 752 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 753 int memberID;
 754 int startMemberID;
 755 int type;
 756 struct __ecereNameSpace__ecere__com__Instance * module;
 757 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 758 const char *  dataTypeString;
 759 struct Type * dataType;
 760 int typeSize;
 761 int defaultAlignment;
 762 void (*  Initialize)();
 763 int memberOffset;
 764 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 765 const char *  designerClass;
 766 unsigned int noExpansion;
 767 const char *  defaultProperty;
 768 unsigned int comRedefinition;
 769 int count;
 770 int isRemote;
 771 unsigned int internalDecl;
 772 void *  data;
 773 unsigned int computeSize;
 774 int structAlignment;
 775 int destructionWatchOffset;
 776 unsigned int fixed;
 777 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 778 int inheritanceAccess;
 779 const char *  fullName;
 780 void *  symbol;
 781 struct __ecereNameSpace__ecere__sys__OldList conversions;
 782 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 783 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 784 struct __ecereNameSpace__ecere__com__Class * templateClass;
 785 struct __ecereNameSpace__ecere__sys__OldList templatized;
 786 int numParams;
 787 unsigned int isInstanceClass;
 788 unsigned int byValueSystemClass;
 789 } __attribute__ ((gcc_struct));
 790
 791 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 792
 793 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 794
 795 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 796
 797 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 798
 799 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 800
 801 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);
 802
 803 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 804
 805 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 806
 807 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 808
 809 struct __ecereNameSpace__ecere__com__Instance
 810 {
 811 int (* *  _vTbl)();
 812 struct __ecereNameSpace__ecere__com__Class * _class;
 813 int _refCount;
 814 } __attribute__ ((gcc_struct));
 815
 816 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 817
 818 struct __ecereNameSpace__ecere__com__DataMember
 819 {
 820 struct __ecereNameSpace__ecere__com__DataMember * prev;
 821 struct __ecereNameSpace__ecere__com__DataMember * next;
 822 const char *  name;
 823 unsigned int isProperty;
 824 int memberAccess;
 825 int id;
 826 struct __ecereNameSpace__ecere__com__Class * _class;
 827 const char *  dataTypeString;
 828 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 829 struct Type * dataType;
 830 int type;
 831 int offset;
 832 int memberID;
 833 struct __ecereNameSpace__ecere__sys__OldList members;
 834 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 835 int memberOffset;
 836 int structAlignment;
 837 } __attribute__ ((gcc_struct));
 838
 839 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 840
 841 struct __ecereNameSpace__ecere__com__SerialBuffer
 842 {
 843 unsigned char *  _buffer;
 844 unsigned int count;
 845 unsigned int _size;
 846 unsigned int pos;
 847 } __attribute__ ((gcc_struct));
 848
 849 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 850
 851 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 852 {
 853 union
 854 {
 855 struct
 856 {
 857 const char *  dataTypeString;
 858 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 859 } __attribute__ ((gcc_struct));
 860 struct __ecereNameSpace__ecere__com__DataValue expression;
 861 struct
 862 {
 863 const char *  memberString;
 864 union
 865 {
 866 struct __ecereNameSpace__ecere__com__DataMember * member;
 867 struct __ecereNameSpace__ecere__com__Property * prop;
 868 struct __ecereNameSpace__ecere__com__Method * method;
 869 } __attribute__ ((gcc_struct));
 870 } __attribute__ ((gcc_struct));
 871 } __attribute__ ((gcc_struct));
 872 } __attribute__ ((gcc_struct));
 873
 874 enum yytokentype
 875 {
 876 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
 877 };
 878
 879 typedef union YYSTYPE
 880 {
 881 int specifierType;
 882 int i;
 883 int declMode;
 884 struct Identifier * id;
 885 struct Expression * exp;
 886 struct Specifier * specifier;
 887 struct __ecereNameSpace__ecere__sys__OldList * list;
 888 struct Enumerator * enumerator;
 889 struct Declarator * declarator;
 890 struct Pointer * pointer;
 891 struct Initializer * initializer;
 892 struct InitDeclarator * initDeclarator;
 893 struct TypeName * typeName;
 894 struct Declaration * declaration;
 895 struct Statement * stmt;
 896 struct FunctionDefinition * function;
 897 struct External * external;
 898 struct Context * context;
 899 struct AsmField * asmField;
 900 struct Attrib * attrib;
 901 struct ExtDecl * extDecl;
 902 struct Attribute * attribute;
 903 struct Instantiation * instance;
 904 struct MembersInit * membersInit;
 905 struct MemberInit * memberInit;
 906 struct ClassFunction * classFunction;
 907 struct ClassDefinition * _class;
 908 struct ClassDef * classDef;
 909 struct PropertyDef * prop;
 910 char * string;
 911 struct Symbol * symbol;
 912 struct PropertyWatch * propertyWatch;
 913 struct TemplateParameter * templateParameter;
 914 struct TemplateArgument * templateArgument;
 915 struct TemplateDatatype * templateDatatype;
 916 struct DBTableEntry * dbtableEntry;
 917 struct DBIndexItem * dbindexItem;
 918 struct DBTableDef * dbtableDef;
 919 } __attribute__ ((gcc_struct)) YYSTYPE;
 920
 921 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 922
 923 struct Enumerator;
 924
 925 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 926
 927 struct InitDeclarator
 928 {
 929 struct InitDeclarator * prev;
 930 struct InitDeclarator * next;
 931 struct Location loc;
 932 struct Declarator * declarator;
 933 struct Initializer * initializer;
 934 } __attribute__ ((gcc_struct));
 935
 936 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 937
 938 struct AsmField;
 939
 940 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 941
 942 struct Attribute;
 943
 944 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 945
 946 struct ClassFunction
 947 {
 948 struct ClassFunction * prev;
 949 struct ClassFunction * next;
 950 struct Location loc;
 951 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 952 struct Declarator * declarator;
 953 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 954 struct Statement * body;
 955 struct __ecereNameSpace__ecere__com__Class * _class;
 956 struct __ecereNameSpace__ecere__sys__OldList attached;
 957 int declMode;
 958 struct Type * type;
 959 struct Symbol * propSet;
 960 unsigned int isVirtual;
 961 unsigned int isConstructor;
 962 unsigned int isDestructor;
 963 unsigned int dontMangle;
 964 int id;
 965 int idCode;
 966 } __attribute__ ((gcc_struct));
 967
 968 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 969
 970 struct MembersInit
 971 {
 972 struct MembersInit * prev;
 973 struct MembersInit * next;
 974 struct Location loc;
 975 int type;
 976 union
 977 {
 978 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
 979 struct ClassFunction * function;
 980 } __attribute__ ((gcc_struct));
 981 } __attribute__ ((gcc_struct));
 982
 983 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 984
 985 struct MemberInit
 986 {
 987 struct MemberInit * prev;
 988 struct MemberInit * next;
 989 struct Location loc;
 990 struct Location realLoc;
 991 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
 992 struct Initializer * initializer;
 993 unsigned int used;
 994 unsigned int variable;
 995 unsigned int takeOutExp;
 996 } __attribute__ ((gcc_struct));
 997
 998 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 999
1000 struct PropertyDef
1001 {
1002 struct PropertyDef * prev;
1003 struct PropertyDef * next;
1004 struct Location loc;
1005 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1006 struct Declarator * declarator;
1007 struct Identifier * id;
1008 struct Statement * getStmt;
1009 struct Statement * setStmt;
1010 struct Statement * issetStmt;
1011 struct Symbol * symbol;
1012 struct Expression * category;
1013 struct
1014 {
1015 unsigned int conversion : 1;
1016 unsigned int isWatchable : 1;
1017 unsigned int isDBProp : 1;
1018 } __attribute__ ((gcc_struct));
1019 } __attribute__ ((gcc_struct));
1020
1021 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1022
1023 struct PropertyWatch
1024 {
1025 struct PropertyWatch * prev;
1026 struct PropertyWatch * next;
1027 struct Location loc;
1028 struct Statement * compound;
1029 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1030 unsigned int deleteWatch;
1031 } __attribute__ ((gcc_struct));
1032
1033 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1034
1035 struct ClassDef
1036 {
1037 struct ClassDef * prev;
1038 struct ClassDef * next;
1039 struct Location loc;
1040 int type;
1041 union
1042 {
1043 struct Declaration * decl;
1044 struct ClassFunction * function;
1045 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1046 struct PropertyDef * propertyDef;
1047 struct PropertyWatch * propertyWatch;
1048 char *  designer;
1049 struct Identifier * defaultProperty;
1050 struct
1051 {
1052 struct Identifier * id;
1053 struct Initializer * initializer;
1054 } __attribute__ ((gcc_struct));
1055 } __attribute__ ((gcc_struct));
1056 int memberAccess;
1057 void *  object;
1058 } __attribute__ ((gcc_struct));
1059
1060 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1061
1062 struct DBTableEntry
1063 {
1064 struct DBTableEntry * prev;
1065 struct DBTableEntry * next;
1066 int type;
1067 struct Identifier * id;
1068 union
1069 {
1070 struct
1071 {
1072 struct TypeName * dataType;
1073 char *  name;
1074 } __attribute__ ((gcc_struct));
1075 struct __ecereNameSpace__ecere__sys__OldList *  items;
1076 } __attribute__ ((gcc_struct));
1077 } __attribute__ ((gcc_struct));
1078
1079 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1080
1081 struct DBIndexItem
1082 {
1083 struct DBIndexItem * prev;
1084 struct DBIndexItem * next;
1085 struct Identifier * id;
1086 int order;
1087 } __attribute__ ((gcc_struct));
1088
1089 extern YYSTYPE yylval;
1090
1091 extern struct Location yylloc;
1092
1093 static struct __ecereNameSpace__ecere__sys__OldList * tableStatements, * indexStatements, * addFieldStatements;
1094
1095 static int numIndexes;
1096
1097 static struct External * addAfter;
1098
1099 static void ProcessDeclaration(struct Declaration * decl);
1100
1101 static void ProcessMemberInit(struct MemberInit * init);
1102
1103 static void ProcessClassFunction(struct ClassFunction * func);
1104
1105 static void ProcessProperty(struct PropertyDef * def);
1106
1107 static void ProcessStatement(struct Statement * stmt);
1108
1109 static void ProcessInitializer(struct Initializer * initializer);
1110
1111 static void ProcessSpecifier(struct Specifier * spec)
1112 {
1113 switch(spec->type)
1114 {
1115 case 2:
1116 case 3:
1117 case 4:
1118 {
1119 if(spec->definitions)
1120 {
1121 struct ClassDef * def;
1122
1123 for(def = (*spec->definitions).first; def; def = def->next)
1124 {
1125 switch(def->type)
1126 {
1127 case 2:
1128 ProcessDeclaration(def->decl);
1129 break;
1130 case 1:
1131 {
1132 struct MemberInit * init;
1133
1134 for(init = (*def->defProperties).first; init; init = init->next)
1135 {
1136 ProcessMemberInit(init);
1137 }
1138 break;
1139 }
1140 case 0:
1141 ProcessClassFunction(def->function);
1142 break;
1143 case 3:
1144 if(def->propertyDef)
1145 {
1146 ProcessProperty(def->propertyDef);
1147 }
1148 break;
1149 case 4:
1150 if(def->propertyWatch && def->propertyWatch->compound)
1151 {
1152 ProcessStatement(def->propertyWatch->compound);
1153 }
1154 break;
1155 case 11:
1156 if(def->initializer)
1157 ProcessInitializer(def->initializer);
1158 break;
1159 }
1160 }
1161 }
1162 break;
1163 }
1164 }
1165 }
1166
1167 static void ProcessIdentifier(struct Identifier * id)
1168 {
1169 }
1170
1171 static void ProcessInstance(struct Instantiation * inst);
1172
1173 extern size_t strlen(const char * );
1174
1175 extern void *  memcpy(void * , const void * , size_t size);
1176
1177 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
1178
1179 extern int sprintf(char * , const char * , ...);
1180
1181 extern void FreeExpContents(struct Expression * exp);
1182
1183 extern struct Identifier * MkIdentifier(const char *  string);
1184
1185 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1186
1187 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1188
1189 extern struct Context * curContext;
1190
1191 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1192
1193 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1194
1195 extern struct Specifier * MkSpecifierName(const char *  name);
1196
1197 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1198
1199 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1200
1201 extern struct Specifier * MkSpecifier(int specifier);
1202
1203 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
1204
1205 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1206
1207 extern struct Statement * MkIfStmt(struct __ecereNameSpace__ecere__sys__OldList * exp, struct Statement * statement, struct Statement * elseStmt);
1208
1209 extern struct Statement * MkReturnStmt(struct __ecereNameSpace__ecere__sys__OldList * exp);
1210
1211 extern struct Expression * MkExpConstant(const char *  string);
1212
1213 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1214
1215 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1216
1217 extern struct Expression * CopyExpression(struct Expression * exp);
1218
1219 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1220
1221 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1222
1223 extern struct Declarator * MkDeclaratorArray(struct Declarator * declarator, struct Expression * exp);
1224
1225 extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
1226
1227 extern void Compiler_Error(const char *  format, ...);
1228
1229 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
1230
1231 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1232
1233 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1234
1235 static void ProcessExpression(struct Expression * exp)
1236 {
1237 switch(exp->type)
1238 {
1239 case 13:
1240 ProcessExpression(exp->_new.size);
1241 break;
1242 case 14:
1243 ProcessExpression(exp->_renew.exp);
1244 ProcessExpression(exp->_renew.size);
1245 break;
1246 case 2:
1247 break;
1248 case 0:
1249 ProcessIdentifier(exp->identifier);
1250 break;
1251 case 1:
1252 ProcessInstance(exp->instance);
1253 break;
1254 case 3:
1255 break;
1256 case 4:
1257 if(exp->op.exp1)
1258 {
1259 ProcessExpression(exp->op.exp1);
1260 }
1261 if(exp->op.exp2)
1262 {
1263 ProcessExpression(exp->op.exp2);
1264 }
1265 break;
1266 case 5:
1267 {
1268 struct Expression * expression;
1269
1270 for(expression = (*exp->list).first; expression; expression = expression->next)
1271 {
1272 ProcessExpression(expression);
1273 }
1274 break;
1275 }
1276 case 6:
1277 {
1278 struct Expression * expression;
1279
1280 ProcessExpression(exp->index.exp);
1281 for(expression = (*exp->index.index).first; expression; expression = expression->next)
1282 {
1283 ProcessExpression(expression);
1284 }
1285 break;
1286 }
1287 case 7:
1288 {
1289 ProcessExpression(exp->call.exp);
1290 if(exp->call.arguments)
1291 {
1292 struct Expression * expression;
1293
1294 for(expression = (*exp->call.arguments).first; expression; expression = expression->next)
1295 {
1296 ProcessExpression(expression);
1297 }
1298 }
1299 break;
1300 }
1301 case 8:
1302 ProcessExpression(exp->member.exp);
1303 break;
1304 case 9:
1305 ProcessExpression(exp->member.exp);
1306 break;
1307 case 10:
1308 break;
1309 case 11:
1310 ProcessExpression(exp->cast.exp);
1311 break;
1312 case 12:
1313 ProcessExpression(exp->cond.cond);
1314 {
1315 struct Expression * expression;
1316
1317 for(expression = (*exp->cond.exp).first; expression; expression = expression->next)
1318 {
1319 ProcessExpression(expression);
1320 }
1321 }
1322 ProcessExpression(exp->cond.elseExp);
1323 break;
1324 case 16:
1325 break;
1326 case 29:
1327 {
1328 char tableName[1024];
1329 char name[1024];
1330 int len = strlen(exp->db.table);
1331
1332 memcpy(tableName, exp->db.table + 1, len - 2);
1333 tableName[len - 2] = (char)0;
1334 __ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
1335 sprintf(name, "__ecereDBField_%s_%s", tableName, exp->db.id->string);
1336 FreeExpContents(exp);
1337 exp->type = 0;
1338 exp->identifier = MkIdentifier(name);
1339 break;
1340 }
1341 case 30:
1342 {
1343 char tableName[1024];
1344 char name[1024];
1345 int len = strlen(exp->db.table);
1346
1347 memcpy(tableName, exp->db.table + 1, len - 2);
1348 tableName[len - 2] = (char)0;
1349 __ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
1350 sprintf(name, "__ecereDBTable_%s", tableName);
1351 FreeExpContents(exp);
1352 exp->type = 0;
1353 exp->identifier = MkIdentifier(name);
1354 break;
1355 }
1356 case 31:
1357 {
1358 char tableName[1024];
1359 char name[1024];
1360 int len = strlen(exp->db.table);
1361
1362 memcpy(tableName, exp->db.table + 1, len - 2);
1363 tableName[len - 2] = (char)0;
1364 __ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
1365 sprintf(name, "__ecereDBIndex_%s_%s", tableName, exp->db.id->string);
1366 FreeExpContents(exp);
1367 exp->type = 0;
1368 exp->identifier = MkIdentifier(name);
1369 break;
1370 }
1371 case 28:
1372 {
1373 if(tableStatements)
1374 {
1375 struct Statement * databaseOpenStmt = MkCompoundStmt(MkList(), MkList());
1376 struct Statement * compound;
1377 struct Statement * ifDBStmt;
1378 struct __ecereNameSpace__ecere__sys__OldList * args;
1379 char numIndexesString[16];
1380
1381 databaseOpenStmt->compound.context = __extension__ ({
1382 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1383
1384 __ecereInstance1->parent = curContext, __ecereInstance1;
1385 });
1386 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.declarations), MkDeclaration(MkListOne(MkSpecifierName("Database")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("db")), (((void *)0))))));
1387 args = MkList();
1388 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkSpecifier(STATIC));
1389 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkSpecifierName("bool"));
1390 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.declarations), MkDeclaration(args, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("initialized")), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("false")))))));
1391 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("initialized"))), MkReturnStmt(MkListOne(MkExpConstant("0"))), (((void *)0))));
1392 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("initialized")), '=', MkExpIdentifier(MkIdentifier("true"))))));
1393 args = MkList();
1394 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), CopyExpression(exp->dbopen.name));
1395 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("no")));
1396 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("db")), '=', MkExpCall(MkExpMember(CopyExpression(exp->dbopen.ds), MkIdentifier("OpenDatabase")), args)))));
1397 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkIfStmt(MkListOne(MkExpOp((((void *)0)), '!', MkExpIdentifier(MkIdentifier("db")))), compound = MkCompoundStmt((((void *)0)), MkList()), (((void *)0))));
1398 compound->compound.context = __extension__ ({
1399 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1400
1401 __ecereInstance1->parent = databaseOpenStmt->compound.context, __ecereInstance1;
1402 });
1403 args = MkList();
1404 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), exp->dbopen.name);
1405 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("create")));
1406 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*compound->compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("db")), '=', MkExpCall(MkExpMember(exp->dbopen.ds, MkIdentifier("OpenDatabase")), args)))));
1407 exp->dbopen.name = (((void *)0));
1408 exp->dbopen.ds = (((void *)0));
1409 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkIfStmt(MkListOne(MkExpIdentifier(MkIdentifier("db"))), ifDBStmt = MkCompoundStmt(MkList(), MkList()), (((void *)0))));
1410 ifDBStmt->compound.context = __extension__ ({
1411 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1412
1413 __ecereInstance1->parent = databaseOpenStmt->compound.context, __ecereInstance1;
1414 });
1415 sprintf(numIndexesString, "%d", numIndexes);
1416 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.declarations), MkDeclaration(MkListOne(MkSpecifierName("FieldIndex")), MkListOne(MkInitDeclarator(MkDeclaratorArray(MkDeclaratorIdentifier(MkIdentifier("indexes")), MkExpConstant(numIndexesString)), MkInitializerList(MkListOne(MkInitializerList(MkListOne(MkInitializerAssignment(MkExpIdentifier(MkIdentifier("null")))))))))));
1417 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("Begin")), MkList()))));
1418 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.statements), compound = MkCompoundStmt((((void *)0)), tableStatements));
1419 compound->compound.context = __extension__ ({
1420 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1421
1422 __ecereInstance1->parent = ifDBStmt->compound.context, __ecereInstance1;
1423 });
1424 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.statements), (compound = MkCompoundStmt((((void *)0)), addFieldStatements), compound->compound.context = __extension__ ({
1425 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1426
1427 __ecereInstance1->parent = ifDBStmt->compound.context, __ecereInstance1;
1428 }), compound));
1429 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.statements), compound = MkCompoundStmt((((void *)0)), indexStatements));
1430 compound->compound.context = __extension__ ({
1431 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1432
1433 __ecereInstance1->parent = ifDBStmt->compound.context, __ecereInstance1;
1434 });
1435 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ifDBStmt->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("Commit")), MkList()))));
1436 exp->type = 23;
1437 exp->compound = databaseOpenStmt;
1438 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*databaseOpenStmt->compound.statements), MkExpressionStmt(MkListOne(MkExpIdentifier(MkIdentifier("db")))));
1439 tableStatements = (((void *)0));
1440 }
1441 else
1442 {
1443 FreeExpContents(exp);
1444 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No database table defined in this module or database_open already used.\n", (((void *)0))));
1445 exp->type = 16;
1446 }
1447 break;
1448 }
1449 }
1450 }
1451
1452 static void ProcessStatement(struct Statement * stmt)
1453 {
1454 switch(stmt->type)
1455 {
1456 case 0:
1457 ProcessStatement(stmt->labeled.stmt);
1458 break;
1459 case 1:
1460 if(stmt->caseStmt.exp)
1461 {
1462 ProcessExpression(stmt->caseStmt.exp);
1463 }
1464 if(stmt->caseStmt.stmt)
1465 {
1466 ProcessStatement(stmt->caseStmt.stmt);
1467 }
1468 break;
1469 case 14:
1470 {
1471 ProcessDeclaration(stmt->decl);
1472 break;
1473 }
1474 case 2:
1475 {
1476 struct Context * oldContext = curContext;
1477
1478 curContext = stmt->compound.context;
1479 if(stmt->compound.declarations)
1480 {
1481 struct Declaration * decl;
1482
1483 for(decl = (*stmt->compound.declarations).first; decl; decl = decl->next)
1484 {
1485 ProcessDeclaration(decl);
1486 }
1487 }
1488 if(stmt->compound.statements)
1489 {
1490 struct Statement * statement;
1491
1492 for(statement = (*stmt->compound.statements).first; statement; statement = statement->next)
1493 {
1494 ProcessStatement(statement);
1495 }
1496 }
1497 curContext = oldContext;
1498 break;
1499 }
1500 case 3:
1501 {
1502 if(stmt->expressions)
1503 {
1504 struct Expression * exp;
1505
1506 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
1507 {
1508 ProcessExpression(exp);
1509 }
1510 }
1511 break;
1512 }
1513 case 4:
1514 {
1515 struct Expression * exp;
1516
1517 for(exp = (*stmt->ifStmt.exp).first; exp; exp = exp->next)
1518 {
1519 ProcessExpression(exp);
1520 }
1521 if(stmt->ifStmt.stmt)
1522 {
1523 ProcessStatement(stmt->ifStmt.stmt);
1524 }
1525 if(stmt->ifStmt.elseStmt)
1526 {
1527 ProcessStatement(stmt->ifStmt.elseStmt);
1528 }
1529 break;
1530 }
1531 case 5:
1532 {
1533 struct Expression * exp;
1534
1535 for(exp = (*stmt->switchStmt.exp).first; exp; exp = exp->next)
1536 {
1537 ProcessExpression(exp);
1538 }
1539 ProcessStatement(stmt->switchStmt.stmt);
1540 break;
1541 }
1542 case 6:
1543 {
1544 struct Expression * exp;
1545
1546 if(stmt->whileStmt.exp)
1547 {
1548 for(exp = (*stmt->whileStmt.exp).first; exp; exp = exp->next)
1549 {
1550 ProcessExpression(exp);
1551 }
1552 }
1553 if(stmt->whileStmt.stmt)
1554 ProcessStatement(stmt->whileStmt.stmt);
1555 break;
1556 }
1557 case 7:
1558 {
1559 ProcessStatement(stmt->doWhile.stmt);
1560 if(stmt->doWhile.exp)
1561 {
1562 struct Expression * exp;
1563
1564 for(exp = (*stmt->doWhile.exp).first; exp; exp = exp->next)
1565 {
1566 ProcessExpression(exp);
1567 }
1568 }
1569 break;
1570 }
1571 case 8:
1572 {
1573 struct Expression * exp;
1574
1575 if(stmt->forStmt.init)
1576 {
1577 ProcessStatement(stmt->forStmt.init);
1578 }
1579 if(stmt->forStmt.check)
1580 {
1581 ProcessStatement(stmt->forStmt.check);
1582 }
1583 if(stmt->forStmt.increment)
1584 {
1585 for(exp = (*stmt->forStmt.increment).first; exp; exp = exp->next)
1586 {
1587 ProcessExpression(exp);
1588 }
1589 }
1590 if(stmt->forStmt.stmt)
1591 ProcessStatement(stmt->forStmt.stmt);
1592 break;
1593 }
1594 case 9:
1595 break;
1596 case 10:
1597 break;
1598 case 11:
1599 break;
1600 case 12:
1601 if(stmt->expressions)
1602 {
1603 struct Expression * exp;
1604
1605 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
1606 {
1607 ProcessExpression(exp);
1608 }
1609 }
1610 break;
1611 case 15:
1612 case 16:
1613 {
1614 struct Identifier * _watch;
1615
1616 if(stmt->_watch.watcher)
1617 {
1618 ProcessExpression(stmt->_watch.watcher);
1619 }
1620 if(stmt->_watch.object)
1621 {
1622 ProcessExpression(stmt->_watch.object);
1623 }
1624 if(stmt->_watch.watches)
1625 {
1626 for(_watch = (*stmt->_watch.watches).first; _watch; _watch = _watch->next)
1627 {
1628 ProcessIdentifier(_watch);
1629 }
1630 }
1631 break;
1632 }
1633 case 17:
1634 {
1635 struct PropertyWatch * _watch;
1636
1637 if(stmt->_watch.watcher)
1638 {
1639 ProcessExpression(stmt->_watch.watcher);
1640 }
1641 if(stmt->_watch.object)
1642 {
1643 ProcessExpression(stmt->_watch.object);
1644 }
1645 if(stmt->_watch.watches)
1646 {
1647 for(_watch = (*stmt->_watch.watches).first; _watch; _watch = _watch->next)
1648 {
1649 if(_watch->compound)
1650 {
1651 ProcessStatement(_watch->compound);
1652 }
1653 }
1654 }
1655 break;
1656 }
1657 }
1658 }
1659
1660 static void ProcessInitializer(struct Initializer * initializer)
1661 {
1662 switch(initializer->type)
1663 {
1664 case 1:
1665 {
1666 struct Initializer * init;
1667
1668 for(init = (*initializer->list).first; init; init = init->next)
1669 {
1670 ProcessInitializer(init);
1671 }
1672 break;
1673 }
1674 case 0:
1675 ProcessExpression(initializer->exp);
1676 break;
1677 }
1678 }
1679
1680 static void ProcessInitDeclarator(struct InitDeclarator * decl)
1681 {
1682 if(decl->initializer)
1683 ProcessInitializer(decl->initializer);
1684 }
1685
1686 static void ProcessDeclaration(struct Declaration * decl)
1687 {
1688 switch(decl->type)
1689 {
1690 case 0:
1691 {
1692 struct Specifier * spec;
1693
1694 if(decl->specifiers)
1695 {
1696 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1697 {
1698 ProcessSpecifier(spec);
1699 }
1700 }
1701 break;
1702 }
1703 case 1:
1704 {
1705 if(decl->specifiers)
1706 {
1707 struct Specifier * s;
1708
1709 for(s = (*decl->specifiers).first; s; s = s->next)
1710 {
1711 ProcessSpecifier(s);
1712 }
1713 }
1714 if(decl->declarators && (*decl->declarators).first)
1715 {
1716 struct InitDeclarator * d;
1717
1718 for(d = (*decl->declarators).first; d; d = d->next)
1719 {
1720 ProcessInitDeclarator(d);
1721 }
1722 }
1723 break;
1724 }
1725 case 2:
1726 ProcessInstance(decl->inst);
1727 break;
1728 }
1729 }
1730
1731 static void ProcessFunction(struct FunctionDefinition * func)
1732 {
1733 if(func->body)
1734 {
1735 ProcessStatement(func->body);
1736 }
1737 }
1738
1739 static void ProcessMemberInit(struct MemberInit * init)
1740 {
1741 if(init->initializer)
1742 {
1743 ProcessInitializer(init->initializer);
1744 }
1745 }
1746
1747 static void ProcessInstance(struct Instantiation * inst)
1748 {
1749 if(inst->members)
1750 {
1751 struct MembersInit * init;
1752 struct MemberInit * memberInit;
1753
1754 for(init = (*inst->members).first; init; init = init->next)
1755 {
1756 if(init->type == 0 && init->dataMembers)
1757 {
1758 for(memberInit = (*init->dataMembers).first; memberInit; memberInit = memberInit->next)
1759 {
1760 ProcessMemberInit(memberInit);
1761 }
1762 }
1763 if(init->type == 1)
1764 {
1765 ProcessClassFunction(init->function);
1766 }
1767 }
1768 }
1769 }
1770
1771 static void ProcessClassFunction(struct ClassFunction * func)
1772 {
1773 if(func->body)
1774 {
1775 ProcessStatement(func->body);
1776 }
1777 }
1778
1779 static void ProcessProperty(struct PropertyDef * def)
1780 {
1781 if(def->getStmt)
1782 {
1783 ProcessStatement(def->getStmt);
1784 }
1785 if(def->setStmt)
1786 {
1787 ProcessStatement(def->setStmt);
1788 }
1789 }
1790
1791 static void ProcessClassDef(struct ClassDef * def)
1792 {
1793 switch(def->type)
1794 {
1795 case 2:
1796 ProcessDeclaration(def->decl);
1797 break;
1798 case 1:
1799 {
1800 struct MemberInit * init;
1801
1802 for(init = (*def->defProperties).first; init; init = init->next)
1803 {
1804 ProcessMemberInit(init);
1805 }
1806 break;
1807 }
1808 case 11:
1809 if(def->initializer)
1810 ProcessInitializer(def->initializer);
1811 break;
1812 case 0:
1813 ProcessClassFunction(def->function);
1814 break;
1815 case 3:
1816 if(def->propertyDef)
1817 {
1818 ProcessProperty(def->propertyDef);
1819 }
1820 break;
1821 case 4:
1822 if(def->propertyWatch && def->propertyWatch->compound)
1823 {
1824 ProcessStatement(def->propertyWatch->compound);
1825 }
1826 break;
1827 }
1828 }
1829
1830 static void ProcessClass(struct ClassDefinition * _class)
1831 {
1832 if(_class->definitions)
1833 {
1834 struct ClassDef * def;
1835
1836 for(def = (*_class->definitions).first; def; def = def->next)
1837 {
1838 ProcessClassDef(def);
1839 }
1840 }
1841 }
1842
1843 static int curSymbolID = 0;
1844
1845 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
1846
1847 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
1848
1849 extern struct Expression * MkExpString(const char *  string);
1850
1851 extern struct Expression * MkExpInstance(struct Instantiation * inst);
1852
1853 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
1854
1855 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
1856
1857 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
1858
1859 extern struct Context * PushContext(void);
1860
1861 extern struct ClassDefinition * MkClass(struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * baseSpecs, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1862
1863 extern struct Symbol * DeclClass(int symbolID, const char *  name);
1864
1865 extern struct Context * globalContext;
1866
1867 extern void PopContext(struct Context * ctx);
1868
1869 extern struct ClassDef * MkClassDefDefaultProperty(struct __ecereNameSpace__ecere__sys__OldList * defProperties);
1870
1871 extern struct MemberInit * MkMemberInitExp(struct Expression * idExp, struct Initializer * initializer);
1872
1873 extern struct External * MkExternalClass(struct ClassDefinition * _class);
1874
1875 extern int strcmp(const char * , const char * );
1876
1877 extern char *  strcpy(char * , const char * );
1878
1879 extern struct ClassDef * MkClassDefProperty(struct PropertyDef * propertyDef);
1880
1881 extern struct PropertyDef * MkProperty(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl, struct Identifier * id, struct Statement * setStmt, struct Statement * getStmt);
1882
1883 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
1884
1885 extern struct Specifier * CopySpecifier(struct Specifier * spec);
1886
1887 extern struct Declarator * CopyDeclarator(struct Declarator * declarator);
1888
1889 extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
1890
1891 extern struct Identifier * CopyIdentifier(struct Identifier * id);
1892
1893 extern struct Expression * MkExpClass(struct __ecereNameSpace__ecere__sys__OldList *  specifiers, struct Declarator * decl);
1894
1895 extern struct Expression * MkExpIndex(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * index);
1896
1897 extern struct ClassDef * MkClassDefClassPropertyValue(struct Identifier * id, struct Initializer * initializer);
1898
1899 extern struct Expression * MkExpDBTable(char *  table);
1900
1901 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
1902
1903 extern struct Expression * MkExpDBField(char *  table, struct Identifier * id);
1904
1905 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1906
1907 static void ProcessDBTable(struct DBTableDef * table)
1908 {
1909 struct __ecereNameSpace__ecere__sys__OldList * rowClassDefs = MkList(), * idClassDefs = (((void *)0));
1910 char tableName[1024];
1911 char rowClassName[1024];
1912 int len = strlen(table->name);
1913 unsigned int indexed = 0x0;
1914 char tableID[1024];
1915 char nameField[1024];
1916 struct __ecereNameSpace__ecere__sys__OldList * args;
1917 struct __ecereNameSpace__ecere__sys__OldList * members;
1918 int symbolID = curSymbolID;
1919
1920 if(table->symbol)
1921 idClassDefs = MkList();
1922 nameField[0] = (char)0;
1923 memcpy(tableName, table->name + 1, len - 2);
1924 tableName[len - 2] = (char)0;
1925 __ecereNameSpace__ecere__sys__ChangeCh(tableName, ' ', '_');
1926 sprintf(tableID, "__ecereDBTable_%s", tableName);
1927 sprintf(rowClassName, "Row%s", tableName);
1928 __ecereNameSpace__ecere__sys__ChangeCh(rowClassName, ' ', '_');
1929 if(!tableStatements)
1930 {
1931 tableStatements = MkList();
1932 indexStatements = MkList();
1933 addFieldStatements = MkList();
1934 }
1935 {
1936 struct External * external;
1937
1938 external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Table")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(tableID)), (((void *)0))))));
1939 external->declaration->declMode = table->declMode;
1940 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
1941 args = MkList();
1942 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*tableStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(tableID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("OpenTable")), args)))));
1943 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(table->name));
1944 members = MkList();
1945 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpInstance(MkInstantiation((((void *)0)), (((void *)0)), MkListOne(MkMembersInitList(members)))));
1946 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("tableRows")))));
1947 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("create")))));
1948 }
1949 {
1950 struct ClassDefinition * _class;
1951 struct ClassDef * def;
1952 struct External * external;
1953 struct __ecereNameSpace__ecere__sys__OldList * inheritanceSpecs = MkList();
1954
1955 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*inheritanceSpecs), MkSpecifier(PRIVATE));
1956 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*inheritanceSpecs), MkSpecifierName("Row"));
1957 PushContext();
1958 _class = MkClass(DeclClass(globalContext->nextID++, rowClassName), inheritanceSpecs, rowClassDefs);
1959 PopContext(curContext);
1960 def = MkClassDefDefaultProperty(MkListOne(MkMemberInitExp(MkExpIdentifier(MkIdentifier("tbl")), MkInitializerAssignment(MkExpIdentifier(MkIdentifier(tableID))))));
1961 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
1962 _class->symbol->idCode = symbolID;
1963 _class->declMode = table->declMode;
1964 external = MkExternalClass(_class);
1965 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
1966 addAfter = external;
1967 }
1968 if(table->definitions)
1969 {
1970 struct DBTableEntry * entry;
1971
1972 for(entry = (*table->definitions).first; entry; entry = entry->next)
1973 {
1974 switch(entry->type)
1975 {
1976 case 0:
1977 {
1978 unsigned int isIndex = 0x0;
1979 char fieldID[1024];
1980 struct __ecereNameSpace__ecere__sys__OldList * args;
1981 struct Specifier * spec = entry->dataType->qualifiers ? (struct Specifier *)(*entry->dataType->qualifiers).first : (((void *)0));
1982
1983 sprintf(fieldID, "__ecereDBField_%s_%s", tableName, entry->id->string);
1984 if(idClassDefs)
1985 {
1986 if(!nameField[0] && spec->type == 1 && (!strcmp(spec->name, "String") || !strcmp(spec->name, "eda::CIString")))
1987 {
1988 strcpy(nameField, entry->id->string);
1989 }
1990 if(!indexed && spec->type == 1 && !strcmp(spec->name, table->symbol->string))
1991 {
1992 struct Statement * rowSet = MkCompoundStmt(MkList(), MkList());
1993 char name[1024];
1994 struct ClassDef * def;
1995
1996 numIndexes = ((numIndexes > 1) ? numIndexes : 1);
1997 isIndex = 0x1;
1998 indexed = 0x1;
1999 sprintf(name, "_%s", entry->id->string);
2000 curContext = rowSet->compound.context = __extension__ ({
2001 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2002
2003 __ecereInstance1->parent = globalContext, __ecereInstance1;
2004 });
2005 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowSet->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("Find")), args = MkList()))));
2006 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
2007 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("middle")));
2008 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("nil")));
2009 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
2010 curContext = globalContext;
2011 def = MkClassDefProperty(MkProperty(CopyList(entry->dataType->qualifiers, CopySpecifier), CopyDeclarator(entry->dataType->declarator), MkIdentifier(name), rowSet, (((void *)0))));
2012 def->propertyDef->symbol->id = def->propertyDef->symbol->idCode = symbolID;
2013 def->propertyDef->isDBProp = 0x1;
2014 def->memberAccess = 1;
2015 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
2016 }
2017 }
2018 if(rowClassDefs)
2019 {
2020 struct Statement * rowSet = MkCompoundStmt(MkList(), MkList()), * rowGet = MkCompoundStmt(MkList(), MkList());
2021 struct ClassDef * def;
2022
2023 curContext = rowGet->compound.context = __extension__ ({
2024 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2025
2026 __ecereInstance1->parent = globalContext, __ecereInstance1;
2027 });
2028 if(spec->type == 1 && spec->symbol && spec->symbol->registered && spec->symbol->registered->type == 1)
2029 {
2030 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(spec->name), MkExpIdentifier(MkIdentifier("d")), (((void *)0)))));
2031 }
2032 else
2033 {
2034 struct Expression * exp;
2035
2036 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->compound.declarations), MkDeclaration(CopyList(entry->dataType->qualifiers, CopySpecifier), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("d")), MkInitializerAssignment(exp = MkExpConstant("0"))))));
2037 exp->destType = __extension__ ({
2038 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2039
2040 __ecereInstance1->kind = 3, __ecereInstance1->refCount = 1, __ecereInstance1;
2041 });
2042 }
2043 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("GetData")), args = MkList()))));
2044 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
2045 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("d")));
2046 if(spec->type == 1 && spec->symbol && spec->symbol->registered && spec->symbol->registered->type == 1)
2047 {
2048 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("value")), '=', MkExpIdentifier(MkIdentifier("d"))))));
2049 }
2050 else
2051 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowGet->compound.statements), MkReturnStmt(MkListOne(MkExpIdentifier(MkIdentifier("d")))));
2052 curContext = rowSet->compound.context = __extension__ ({
2053 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2054
2055 __ecereInstance1->parent = globalContext, __ecereInstance1;
2056 });
2057 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowSet->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("SetData")), args = MkList()))));
2058 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
2059 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
2060 curContext = globalContext;
2061 def = MkClassDefProperty(MkProperty(CopyList(entry->dataType->qualifiers, CopySpecifier), entry->dataType->declarator, CopyIdentifier(entry->id), rowSet, rowGet));
2062 def->propertyDef->symbol->id = def->propertyDef->symbol->idCode = symbolID;
2063 def->propertyDef->isDBProp = 0x1;
2064 def->memberAccess = 1;
2065 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*rowClassDefs), def);
2066 }
2067 {
2068 struct External * external;
2069
2070 external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Field")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(fieldID)), (((void *)0))))));
2071 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ast), external);
2072 external->declaration->declMode = table->declMode;
2073 args = MkList();
2074 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*addFieldStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(fieldID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("FindField")), args)))));
2075 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(entry->name));
2076 args = MkList();
2077 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*addFieldStatements), MkIfStmt(MkListOne(MkExpOp((((void *)0)), '!', MkExpIdentifier(MkIdentifier(fieldID)))), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(fieldID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("AddField")), args)))), (((void *)0))));
2078 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(entry->name));
2079 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpClass(CopyList(entry->dataType->qualifiers, CopySpecifier), CopyDeclarator(entry->dataType->declarator)));
2080 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant("0"));
2081 }
2082 if(isIndex)
2083 {
2084 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant("0"))), MkIdentifier("field")), '=', MkExpIdentifier(MkIdentifier(fieldID))))));
2085 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant("0"))), MkIdentifier("order")), '=', MkExpIdentifier(MkIdentifier("ascending"))))));
2086 args = MkList();
2087 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(tableID)), MkIdentifier("Index")), args))));
2088 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant("1"));
2089 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("indexes")));
2090 }
2091 break;
2092 }
2093 }
2094 }
2095 }
2096 if(table->symbol)
2097 {
2098 struct ClassDefinition * _class;
2099 struct External * external;
2100 struct ClassDef * def;
2101 struct Expression * exp;
2102
2103 PushContext();
2104 _class = MkClass(table->symbol, MkListOne(MkSpecifierName("Id")), idClassDefs);
2105 PopContext(curContext);
2106 _class->declMode = table->declMode;
2107 external = MkExternalClass(_class);
2108 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), addAfter, external);
2109 addAfter = external;
2110 def = MkClassDefClassPropertyValue(MkIdentifier("table"), MkInitializerAssignment(exp = MkExpOp((((void *)0)), '&', MkExpDBTable(__ecereNameSpace__ecere__sys__CopyString(table->name)))));
2111 ProcessExpression(exp);
2112 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
2113 if(nameField[0])
2114 {
2115 def = MkClassDefClassPropertyValue(MkIdentifier("nameField"), MkInitializerAssignment(exp = MkExpOp((((void *)0)), '&', MkExpDBField(__ecereNameSpace__ecere__sys__CopyString(table->name), MkIdentifier(nameField)))));
2116 ProcessExpression(exp);
2117 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
2118 }
2119 }
2120 if(table->definitions)
2121 {
2122 struct DBTableEntry * entry;
2123
2124 for(entry = (*table->definitions).first; entry; entry = entry->next)
2125 {
2126 switch(entry->type)
2127 {
2128 case 0:
2129 {
2130 char fieldID[1024];
2131 struct __ecereNameSpace__ecere__sys__OldList * args;
2132 struct Specifier * spec = entry->dataType->qualifiers ? (struct Specifier *)(*entry->dataType->qualifiers).first : (((void *)0));
2133
2134 sprintf(fieldID, "__ecereDBField_%s_%s", tableName, entry->id->string);
2135 if(idClassDefs && spec)
2136 {
2137 struct Statement * idSet = MkCompoundStmt(MkList(), MkList()), * idGet = MkCompoundStmt(MkList(), MkList());
2138 struct ClassDef * def;
2139
2140 curContext = idGet->compound.context = __extension__ ({
2141 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2142
2143 __ecereInstance1->parent = globalContext, __ecereInstance1;
2144 });
2145 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(rowClassName), MkExpIdentifier(MkIdentifier("r")), MkListOne(MkMembersInitList(MkListOne(MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("this"))))))))));
2146 if(spec->type == 1 && spec->symbol && spec->symbol->registered && spec->symbol->registered->type == 1)
2147 {
2148 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(spec->name), MkExpIdentifier(MkIdentifier("d")), (((void *)0)))));
2149 }
2150 else
2151 {
2152 struct Expression * exp;
2153
2154 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.declarations), MkDeclaration(CopyList(entry->dataType->qualifiers, CopySpecifier), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("d")), MkInitializerAssignment(exp = MkExpConstant("0"))))));
2155 exp->destType = __extension__ ({
2156 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2157
2158 __ecereInstance1->kind = 3, __ecereInstance1->refCount = 1, __ecereInstance1;
2159 });
2160 }
2161 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("r")), MkIdentifier("GetData")), args = MkList()))));
2162 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
2163 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("d")));
2164 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.statements), MkExpressionStmt(MkListOne(MkExpOp((((void *)0)), DELETE, MkExpIdentifier(MkIdentifier("r"))))));
2165 if(spec->type == 1 && spec->symbol && spec->symbol->registered && spec->symbol->registered->type == 1)
2166 {
2167 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.statements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier("value")), '=', MkExpIdentifier(MkIdentifier("d"))))));
2168 }
2169 else
2170 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idGet->compound.statements), MkReturnStmt(MkListOne(MkExpIdentifier(MkIdentifier("d")))));
2171 curContext = idSet->compound.context = __extension__ ({
2172 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2173
2174 __ecereInstance1->parent = globalContext, __ecereInstance1;
2175 });
2176 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->compound.declarations), MkDeclarationInst(MkInstantiation(MkSpecifierName(rowClassName), MkExpIdentifier(MkIdentifier("r")), MkListOne(MkMembersInitList(MkListOne(MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("this"))))))))));
2177 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->compound.statements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("r")), MkIdentifier("SetData")), args = MkList()))));
2178 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier(fieldID)));
2179 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("value")));
2180 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idSet->compound.statements), MkExpressionStmt(MkListOne(MkExpOp((((void *)0)), DELETE, MkExpIdentifier(MkIdentifier("r"))))));
2181 curContext = globalContext;
2182 def = MkClassDefProperty(MkProperty(CopyList(entry->dataType->qualifiers, CopySpecifier), CopyDeclarator(entry->dataType->declarator), CopyIdentifier(entry->id), idSet, idGet));
2183 def->propertyDef->symbol->id = def->propertyDef->symbol->idCode = symbolID;
2184 def->propertyDef->isDBProp = 0x1;
2185 def->memberAccess = 1;
2186 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*idClassDefs), def);
2187 }
2188 break;
2189 }
2190 case 1:
2191 {
2192 if(entry->items && (*entry->items).count)
2193 {
2194 char indexID[1024];
2195 struct DBIndexItem * item;
2196 int c;
2197 unsigned int needTable = 0x0;
2198 char num[16];
2199
2200 if(entry->id || indexed)
2201 {
2202 if(entry->id || (*entry->items).count == 1)
2203 {
2204 struct External * external;
2205 struct Identifier * id = entry->id ? entry->id : ((struct DBIndexItem *)(*entry->items).first)->id;
2206
2207 sprintf(indexID, "__ecereDBIndex_%s_%s", tableName, id->string);
2208 external = MkExternalDeclaration(MkDeclaration(MkListOne(MkSpecifierName("Table")), MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(indexID)), (((void *)0))))));
2209 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*ast), external);
2210 external->declaration->declMode = table->declMode;
2211 needTable = 0x1;
2212 }
2213 else
2214 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Multiple field index requires a name\n", (((void *)0))));
2215 }
2216 else
2217 {
2218 indexed = 0x1;
2219 strcpy(indexID, tableID);
2220 }
2221 for(c = 0, item = (*entry->items).first; item; item = item->next, c++)
2222 {
2223 char fieldID[1024];
2224
2225 sprintf(num, "%d", c);
2226 sprintf(fieldID, "__ecereDBField_%s_%s", tableName, item->id->string);
2227 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant(num))), MkIdentifier("field")), '=', MkExpIdentifier(MkIdentifier(fieldID))))));
2228 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIndex(MkExpIdentifier(MkIdentifier("indexes")), MkListOne(MkExpConstant(num))), MkIdentifier("order")), '=', MkExpIdentifier(MkIdentifier((item->order == 0) ? "ascending" : "descending"))))));
2229 }
2230 sprintf(num, "%d", c);
2231 numIndexes = ((numIndexes > c) ? numIndexes : c);
2232 if(needTable)
2233 {
2234 args = MkList();
2235 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(indexID)), '=', MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("db")), MkIdentifier("OpenTable")), args)))));
2236 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpString(table->name));
2237 members = MkList();
2238 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpInstance(MkInstantiation((((void *)0)), (((void *)0)), MkListOne(MkMembersInitList(members)))));
2239 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*members), MkMemberInit((((void *)0)), MkInitializerAssignment(MkExpIdentifier(MkIdentifier("tableRows")))));
2240 }
2241 args = MkList();
2242 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*indexStatements), MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier(indexID)), MkIdentifier("Index")), args))));
2243 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpConstant(num));
2244 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpIdentifier(MkIdentifier("indexes")));
2245 }
2246 break;
2247 }
2248 }
2249 }
2250 }
2251 }
2252
2253 extern unsigned int inCompiler;
2254
2255 extern void PrePreProcessClassDefinitions(void);
2256
2257 extern struct External * curExternal;
2258
2259 void ProcessDBTableDefinitions()
2260 {
2261 struct External * external;
2262
2263 addAfter = (((void *)0));
2264 curContext = globalContext;
2265 if(inCompiler)
2266 PrePreProcessClassDefinitions();
2267 DeclClass(0, "Field");
2268 DeclClass(0, "Table");
2269 DeclClass(0, "Row");
2270 DeclClass(0, "Id");
2271 numIndexes = 0;
2272 if(ast != (((void *)0)))
2273 {
2274 for(external = (*ast).first; external; external = external->next)
2275 {
2276 curExternal = external;
2277 if(external->symbol)
2278 curSymbolID = external->symbol->idCode;
2279 addAfter = external->prev;
2280 switch(external->type)
2281 {
2282 case 5:
2283 ProcessDBTable(external->table);
2284 break;
2285 }
2286 }
2287 for(external = (*ast).first; external; external = external->next)
2288 {
2289 curExternal = external;
2290 if(external->symbol)
2291 curSymbolID = external->symbol->idCode;
2292 addAfter = external->prev;
2293 switch(external->type)
2294 {
2295 case 0:
2296 ProcessFunction(external->function);
2297 break;
2298 case 1:
2299 ProcessDeclaration(external->declaration);
2300 break;
2301 case 2:
2302 ProcessClass(external->_class);
2303 break;
2304 }
2305 }
2306 }
2307 curContext = globalContext;
2308 }
2309
2310 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2311
2312 struct __ecereNameSpace__ecere__com__GlobalFunction;
2313
2314 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);
2315
2316 void __ecereRegisterModule_dbpass(struct __ecereNameSpace__ecere__com__Instance * module)
2317 {
2318 struct __ecereNameSpace__ecere__com__Class * class;
2319
2320 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessDBTableDefinitions", "void ProcessDBTableDefinitions(void)", ProcessDBTableDefinitions, module, 1);
2321 }
2322
2323 void __ecereUnregisterModule_dbpass(struct __ecereNameSpace__ecere__com__Instance * module)
2324 {
2325
2326 }
2327