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