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

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