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