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

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