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

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