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

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