src/shared/xdynrec.pas

   1 (* Copyright (C)  DooM 2D:Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *)
  16 {$INCLUDE a_modes.inc}
  17 {.$DEFINE XDYNREC_USE_FIELDHASH} // actually, it is SLOWER with this
  18 unit xdynrec;
  19
  20 interface
  21
  22 uses
  23   SysUtils, Variants, Classes,
  24   xparser, xstreams, utils, hashtable;
  25
  26
  27 // ////////////////////////////////////////////////////////////////////////// //
  28 type
  29   TDynRecException = class(Exception)
  30   public
  31     constructor Create (const amsg: AnsiString);
  32     constructor CreateFmt (const afmt: AnsiString; const args: array of const);
  33   end;
  34
  35   TDynParseException = class(TDynRecException)
  36   public
  37     tokLine, tokCol: Integer;
  38
  39   public
  40     constructor Create (pr: TTextParser; const amsg: AnsiString);
  41     constructor CreateFmt (pr: TTextParser; const afmt: AnsiString; const args: array of const);
  42   end;
  43
  44
  45 // ////////////////////////////////////////////////////////////////////////// //
  46 type
  47   TDynMapDef = class;
  48   TDynRecord = class;
  49   TDynField = class;
  50   TDynEBS = class;
  51
  52   TDynFieldList = specialize TSimpleList<TDynField>;
  53   TDynRecList = specialize TSimpleList<TDynRecord>;
  54   TDynEBSList = specialize TSimpleList<TDynEBS>;
  55
  56   // this is base type for all scalars (and arrays)
  57   TDynField = class
  58   public
  59     type
  60       TType = (TBool, TChar, TByte, TUByte, TShort, TUShort, TInt, TUInt, TString, TPoint, TSize, TList, TTrigData);
  61       // TPoint: pair of Integers
  62       // TSize: pair of UShorts
  63       // TList: actually, array of records
  64       // TTrigData: array of mMaxDim bytes, but internally a record (mRecRef)
  65       // in binary: arrays of chars are pascal shortstrings (with counter in the first byte)
  66
  67   private
  68     type
  69       TEBS = (TNone, TRec, TEnum, TBitSet);
  70
  71   private
  72     mOwner: TDynRecord; // owner record
  73     mName: AnsiString; // field name
  74     mType: TType; // field type
  75     mIVal: Integer; // for all integer types
  76     mIVal2: Integer; // for point and size
  77     mSVal: AnsiString; // string; for byte and char arrays
  78     mRVal: TDynRecList; // for list
  79     mRHash: THashStrInt; // id -> index in mRVal
  80     mRecRef: TDynRecord; // for TEBS.TRec
  81     mMaxDim: Integer; // for byte and char arrays; <0: not an array; 0: impossible value
  82     mBinOfs: Integer; // offset in binary; <0 - none
  83     mSepPosSize: Boolean; // for points and sizes, use separate fields
  84     mAsT: Boolean; // for points and sizes, use separate fields, names starts with `t`
  85     mDefined: Boolean;
  86     mHasDefault: Boolean;
  87     mWriteDef: Boolean;
  88     mInternal: Boolean;
  89     mNegBool: Boolean;
  90     mBitSetUnique: Boolean; // bitset can contain only one value
  91     mAsMonsterId: Boolean; // special hack for triggers: monster record number+1 in binary (so 0 means "none")
  92     // default value
  93     mDefUnparsed: AnsiString;
  94     mDefSVal: AnsiString; // default string value
  95     mDefIVal, mDefIVal2: Integer; // default integer values
  96     mDefRecRef: TDynRecord;
  97     mEBS: TEBS; // complex type type
  98     mEBSTypeName: AnsiString; // name of enum, bitset or record
  99     mEBSType: TObject; // either TDynRecord or TDynEBS; nil means "simple type"; nil for `TTrigData` too
 100
 101     // for binary parser
 102     mRecRefId: AnsiString;
 103
 104     // for userdata
 105     mTagInt: Integer;
 106     mTagPtr: Pointer;
 107
 108     // for pasgen
 109     mAlias: AnsiString;
 110
 111   private
 112     procedure cleanup ();
 113
 114     procedure parseDefaultValue (); // parse `mDefUnparsed` to `mDefSVal`, `mDefIVal`, `mDefIVal2`, `mDefRecRef`
 115     procedure fixDefaultValue (); // this will NOT clone `mDefRecRef`
 116     function isDefaultValue (): Boolean;
 117
 118     function getListCount (): Integer; inline;
 119     function getListItem (idx: Integer): TDynRecord; inline; overload;
 120     function getListItem (const aname: AnsiString): TDynRecord; inline; overload;
 121
 122     function getRecRefIndex (): Integer;
 123
 124     function getVar (): Variant;
 125     procedure setVar (val: Variant);
 126
 127     procedure setRecRef (arec: TDynRecord);
 128
 129     procedure parseDef (pr: TTextParser); // parse mapdef definition
 130     function definition (): AnsiString; // generate mapdef definition
 131
 132   protected
 133     // returns `true` for duplicate record id
 134     function addListItem (rec: TDynRecord): Boolean; inline;
 135     function removeListItem (const aid: AnsiString): TDynRecord; // returns nil or removed record
 136
 137   public
 138     // get string name for the given type
 139     class function getTypeName (t: TType): AnsiString;
 140
 141   public
 142     constructor Create (const aname: AnsiString; atype: TType);
 143     constructor Create (const aname: AnsiString; val: Variant);
 144     constructor Create (pr: TTextParser);
 145     destructor Destroy (); override;
 146
 147     // clone this field; register all list records in `registerIn`
 148     // "registration" is required to manage record lifetime; use header record if in doubt
 149     // owner will be set to `newOwner`, if it is not `nil`, or to `owner`
 150     // for lists, cloning will clone all list members
 151     function clone (newOwner: TDynRecord=nil; registerIn: TDynRecord=nil): TDynField;
 152
 153     // compare field values (including trigdata)
 154     // WARNING: won't work for lists
 155     function isSimpleEqu (fld: TDynField): Boolean;
 156
 157     // parse string value to appropriate type and set new field value
 158     procedure setValue (const s: AnsiString);
 159
 160     // supports `for rec in field do` (for lists)
 161     function GetEnumerator (): TDynRecList.TEnumerator; inline;
 162
 163   public
 164     // text parser and writer
 165     procedure parseValue (pr: TTextParser);
 166     procedure writeTo (wr: TTextWriter);
 167
 168     // binary parser and writer (DO NOT USE!)
 169     procedure parseBinValue (st: TStream);
 170     procedure writeBinTo (var hasLostData: Boolean; st: TStream);
 171
 172   public
 173     // the following functions are here only for 'mapgen'! DO NOT USE!
 174     // build "alias name" for pascal code
 175     function palias (firstUp: Boolean=false): AnsiString;
 176
 177   public
 178     property owner: TDynRecord read mOwner;
 179     property name: AnsiString read mName; // field name
 180     property baseType: TType read mType; // field type (base for arrays)
 181     property defined: Boolean read mDefined; // was field value set to something by external code?
 182     property internal: Boolean read mInternal write mInternal; // internal field?
 183     property ival: Integer read mIVal; // integer value for int field (for speed), first field (x/w) for `TPoint` and `TSize`
 184     property ival2: Integer read mIVal2; // for `TPoint` and `TSize`, this is second field (y/h)
 185     property sval: AnsiString read mSVal; // string value for string field (for speed)
 186     property hasDefault: Boolean read mHasDefault; // `true` if this field has default value in mapdef
 187     property defsval: AnsiString read mDefSVal; // string representation of default value
 188     property ebs: TEBS read mEBS; // what kind of reference is this? none, enum, bitset, record
 189     property ebstype: TObject read mEBSType; // reference type (nil, TDynRecord, TDynEBS); WARNING: don't modify type!
 190     property ebstypename: AnsiString read mEBSTypeName; // enum/bitset name
 191     property recref: TDynRecord read mRecRef write setRecRef; // referenced record (actual one, you can modify it)
 192     property recrefIndex: Integer read getRecRefIndex; // index of referenced record in header; -1: not found
 193     // for record lists
 194     property count: Integer read getListCount;
 195     property itemAt[idx: Integer]: TDynRecord read getListItem;
 196     property item[const aname: AnsiString]: TDynRecord read getListItem; default; // alas, FPC 3+ lost property overloading feature
 197     // field value as Variant
 198     property value: Variant read getVar write setVar;
 199
 200   public
 201     // userdata (you can use these properties as you want to; they won't be written or read to files)
 202     property tagInt: Integer read mTagInt write mTagInt;
 203     property tagPtr: Pointer read mTagPtr write mTagPtr;
 204
 205   public
 206     // the following properties are here only for 'mapgen'! DO NOT USE!
 207     property negbool: Boolean read mNegBool;
 208     property hasTPrefix: Boolean read mAsT;
 209     property separatePasFields: Boolean read mSepPosSize;
 210     property binOfs: Integer read mBinOfs;
 211     property equToDefault: Boolean read isDefaultValue;
 212   end;
 213
 214
 215   // record, either with actual values, or with type definitions
 216   TDynRecord = class
 217   private
 218     mOwner: TDynMapDef;
 219     mId: AnsiString;
 220     mTypeName: AnsiString;
 221     mSize: Integer;
 222     mFields: TDynFieldList;
 223     {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
 224     mFieldsHash: THashStrInt; // id -> index in mRVal
 225     {$ENDIF}
 226     mTrigTypes: array of AnsiString; // if this is triggerdata, we'll hold list of triggers here
 227     mHeader: Boolean; // true for header record
 228     mBinBlock: Integer; // -1: none
 229     mHeaderRec: TDynRecord; // for "value" records this is header record with data, for "type" records this is header type record
 230
 231     // for userdata
 232     mTagInt: Integer;
 233     mTagPtr: Pointer;
 234
 235     mRec2Free: TDynRecList;
 236
 237   private
 238     procedure parseDef (pr: TTextParser); // parse definition
 239     function definition (): AnsiString;
 240
 241     function findByName (const aname: AnsiString): Integer; inline;
 242     function hasByName (const aname: AnsiString): Boolean; inline;
 243     function getFieldByName (const aname: AnsiString): TDynField; inline;
 244     function getFieldAt (idx: Integer): TDynField; inline;
 245     function getCount (): Integer; inline;
 246
 247     function getIsTrigData (): Boolean; inline;
 248     function getIsForTrig (const aname: AnsiString): Boolean; inline;
 249
 250     function getForTrigCount (): Integer; inline;
 251     function getForTrigAt (idx: Integer): AnsiString; inline;
 252
 253     procedure regrec (rec: TDynRecord);
 254
 255     function getUserVar (const aname: AnsiString): Variant;
 256     procedure setUserVar (const aname: AnsiString; val: Variant);
 257
 258     procedure clearRefRecs (rec: TDynRecord);
 259
 260   protected
 261     function findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
 262     function findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
 263     function addRecordByType (const atypename: AnsiString; rc: TDynRecord): Boolean; // `true`: duplicate record id
 264
 265     procedure addField (fld: TDynField); inline;
 266     function addFieldChecked (fld: TDynField): Boolean; inline; // `true`: duplicate name
 267
 268   public
 269     constructor Create ();
 270     constructor Create (pr: TTextParser); // parse definition
 271     destructor Destroy (); override;
 272
 273     // clone this record; register all list records in `registerIn`
 274     // "registration" is required to manage record lifetime; use header record if in doubt
 275     // all fields are cloned too
 276     function clone (registerIn: TDynRecord): TDynRecord;
 277
 278     // compare records (values of all fields, including trigdata)
 279     // WARNING: won't work for records with list fields
 280     function isSimpleEqu (rec: TDynRecord): Boolean;
 281
 282     // find field with `TriggerType` type
 283     function trigTypeField (): TDynField;
 284
 285     // number of records of the given instance
 286     function instanceCount (const atypename: AnsiString): Integer;
 287
 288     // only for headers: create new record with the given type
 289     // will return cloned record ready for use, or `nil` on unknown type name
 290     // `aid` must not be empty, and must be unique
 291     function newTypedRecord (const atypename, aid: AnsiString): TDynRecord;
 292
 293     // remove record with the given type and id
 294     // return `true` if record was successfully found and removed
 295     // this will do all necessary recref cleanup too
 296     // WARNING: not tested yet
 297     function removeTypedRecord (const atypename, aid: AnsiString): Boolean;
 298
 299     //TODO:
 300     //  [.] API to create triggers
 301     //  [.] API to properly remove triggers (remove trigdata)
 302     //  [.] check if `removeTypedRecord()` does the right thing with inline records
 303     //  [.] for fields: assigning `recref` should remove previously assigned inline record (record without id)
 304     //  [.] other API i forgot
 305
 306   public
 307     // text parser
 308     // `beginEaten`: `true` if "{" was eaten
 309     procedure parseValue (pr: TTextParser; beginEaten: Boolean=false);
 310
 311     // text writer
 312     // `putHeader`: `true` to write complete header, otherwise only "{...}"
 313     procedure writeTo (wr: TTextWriter; putHeader: Boolean=true);
 314
 315     // binary parser and writer (DO NOT USE!)
 316     procedure parseBinValue (st: TStream; forceData: Boolean=false);
 317     procedure writeBinTo (var hasLostData: Boolean; st: TStream; trigbufsz: Integer=-1; onlyFields: Boolean=false);
 318
 319   public
 320     property mapdef: TDynMapDef read mOwner;
 321     property id: AnsiString read mId; // record id in text map
 322     property typeName: AnsiString read mTypeName; // record type name (like "panel", or "trigger")
 323     property has[const aname: AnsiString]: Boolean read hasByName; // do we have field with the given name?
 324     property count: Integer read getCount; // number of fields in this record
 325     property field[const aname: AnsiString]: TDynField read getFieldByName; default; // get field by name
 326     property fieldAt[idx: Integer]: TDynField read getFieldAt; // get field at the given index
 327     property isTrigData: Boolean read getIsTrigData; // is this special "TriggerData" record?
 328     property isForTrig[const aname: AnsiString]: Boolean read getIsForTrig; // can this "TriggerData" be used for the trigger with the given type?
 329     property forTrigCount: Integer read getForTrigCount; // number of trigger type names for "TriggerData"
 330     property forTrigAt[idx: Integer]: AnsiString read getForTrigAt; // trigger type name at the given index for "TriggerData"
 331     property headerRec: TDynRecord read mHeaderRec; // get header record for this one (header contains all other records, enums, bitsets, etc.)
 332     property isHeader: Boolean read mHeader; // is this a header record?
 333
 334   public
 335     // user fields; user can add arbitrary custom fields
 336     // by default, any user field will be marked as "internal"
 337     // note: you can use this to manipulate non-user fields too
 338     property user[const aname: AnsiString]: Variant read getUserVar write setUserVar;
 339
 340   public
 341     // userdata (you can use these properties as you want to; they won't be written or read to files)
 342     property tagInt: Integer read mTagInt write mTagInt;
 343     property tagPtr: Pointer read mTagPtr write mTagPtr;
 344   end;
 345
 346
 347   // bitset/enum definition
 348   TDynEBS = class
 349   private
 350     mOwner: TDynMapDef;
 351     mIsEnum: Boolean;
 352     mTypeName: AnsiString;
 353     mIds: array of AnsiString;
 354     mVals: array of Integer;
 355     mMaxName: AnsiString; // MAX field
 356     mMaxVal: Integer; // max value
 357
 358   private
 359     procedure cleanup ();
 360
 361     procedure parseDef (pr: TTextParser); // parse definition
 362
 363     function findByName (const aname: AnsiString): Integer; inline;
 364     function hasByName (const aname: AnsiString): Boolean; inline;
 365     function getFieldByName (const aname: AnsiString): Integer; inline;
 366
 367     function definition (): AnsiString;
 368     function pasdef (): AnsiString;
 369
 370   public
 371     constructor Create (pr: TTextParser); // parse definition
 372     destructor Destroy (); override;
 373
 374     // find name for the given value
 375     // return empty string if not found
 376     function nameByValue (v: Integer): AnsiString;
 377
 378   public
 379     property mapdef: TDynMapDef read mOwner;
 380     property typeName: AnsiString read mTypeName; // enum/bitset type name
 381     property isEnum: Boolean read mIsEnum; // is this enum? `false` means "bitset"
 382     property has[const aname: AnsiString]: Boolean read hasByName;
 383     property field[const aname: AnsiString]: Integer read getFieldByName;
 384   end;
 385
 386
 387   // parsed "mapdef.txt"
 388   TDynMapDef = class
 389   public
 390     recTypes: TDynRecList; // [0] is always header
 391     trigTypes: TDynRecList; // trigdata
 392     ebsTypes: TDynEBSList; // enums, bitsets
 393
 394   private
 395     procedure parseDef (pr: TTextParser);
 396
 397     function getHeaderRecType (): TDynRecord; inline;
 398
 399     function getRecTypeCount (): Integer; inline;
 400     function getRecTypeAt (idx: Integer): TDynRecord; inline;
 401
 402     function getEBSTypeCount (): Integer; inline;
 403     function getEBSTypeAt (idx: Integer): TDynEBS; inline;
 404
 405     function getTrigTypeCount (): Integer; inline;
 406     function getTrigTypeAt (idx: Integer): TDynRecord; inline;
 407
 408     // creates new header record
 409     function parseTextMap (pr: TTextParser): TDynRecord;
 410
 411     // creates new header record
 412     function parseBinMap (st: TStream): TDynRecord;
 413
 414   public
 415     constructor Create (pr: TTextParser); // parses data definition
 416     destructor Destroy (); override;
 417
 418     function findRecType (const aname: AnsiString): TDynRecord;
 419     function findTrigFor (const aname: AnsiString): TDynRecord;
 420     function findEBSType (const aname: AnsiString): TDynEBS;
 421
 422   public
 423     // parse text or binary map, return new header record
 424     // WARNING! stream must be seekable
 425     function parseMap (st: TStream; wasBinary: PBoolean=nil): TDynRecord;
 426
 427     // returns `true` if the given stream can be a map file
 428     // stream position is 0 on return
 429     // WARNING! stream must be seekable
 430     class function canBeMap (st: TStream): Boolean;
 431
 432   public
 433     // the following functions are here only for 'mapgen'! DO NOT USE!
 434     function pasdefconst (): AnsiString;
 435
 436   public
 437     property headerType: TDynRecord read getHeaderRecType;
 438     // for record types
 439     property recTypeCount: Integer read getRecTypeCount;
 440     property recTypeAt[idx: Integer]: TDynRecord read getRecTypeAt;
 441     property recType[const aname: AnsiString]: TDynRecord read findRecType;
 442     // for enum/bitset types
 443     property ebsTypeCount: Integer read getEBSTypeCount;
 444     property ebsTypeAt[idx: Integer]: TDynEBS read getEBSTypeAt;
 445     property ebsType[const aname: AnsiString]: TDynEBS read findEBSType;
 446     // for trigtypes
 447     property trigTypeCount: Integer read getTrigTypeCount;
 448     property trigTypeAt[idx: Integer]: TDynRecord read getTrigTypeAt;
 449     property trigTypeFor[const aname: AnsiString]: TDynRecord read findTrigFor;
 450   end;
 451
 452
 453 {$IF DEFINED(D2D_DYNREC_PROFILER)}
 454 procedure xdynDumpProfiles ();
 455 {$ENDIF}
 456
 457
 458 implementation
 459
 460 uses
 461   e_log
 462   {$IF DEFINED(D2D_DYNREC_PROFILER)},xprofiler{$ENDIF};
 463
 464
 465 // ////////////////////////////////////////////////////////////////////////// //
 466 function StrEqu (const a, b: AnsiString): Boolean; inline; begin result := (a = b); end;
 467
 468
 469 // ////////////////////////////////////////////////////////////////////////// //
 470 constructor TDynRecException.Create (const amsg: AnsiString);
 471 begin
 472   inherited Create(amsg);
 473 end;
 474
 475 constructor TDynRecException.CreateFmt (const afmt: AnsiString; const args: array of const);
 476 begin
 477   inherited Create(formatstrf(afmt, args));
 478 end;
 479
 480
 481 // ////////////////////////////////////////////////////////////////////////// //
 482 constructor TDynParseException.Create (pr: TTextParser; const amsg: AnsiString);
 483 begin
 484   if (pr <> nil) then begin tokLine := pr.tokLine; tokCol := pr.tokCol; end else begin tokLine := 0; tokCol := 0; end;
 485   inherited Create(amsg);
 486 end;
 487
 488 constructor TDynParseException.CreateFmt (pr: TTextParser; const afmt: AnsiString; const args: array of const);
 489 begin
 490   if (pr <> nil) then begin tokLine := pr.tokLine; tokCol := pr.tokCol; end else begin tokLine := 0; tokCol := 0; end;
 491   inherited Create(formatstrf(afmt, args));
 492 end;
 493
 494
 495 // ////////////////////////////////////////////////////////////////////////// //
 496 function TDynField.GetEnumerator (): TDynRecList.TEnumerator; inline;
 497 begin
 498   //result := TListEnumerator.Create(mRVal);
 499   if (mRVal <> nil) then result := mRVal.GetEnumerator else result := TDynRecList.TEnumerator.Create(nil, 0);
 500 end;
 501
 502
 503 // ////////////////////////////////////////////////////////////////////////// //
 504 constructor TDynField.Create (const aname: AnsiString; atype: TType);
 505 begin
 506   mRVal := nil;
 507   mRecRef := nil;
 508   mRHash := nil;
 509   cleanup();
 510   mName := aname;
 511   mType := atype;
 512   if (mType = TType.TList) then
 513   begin
 514     mRVal := TDynRecList.Create();
 515     mRHash := hashNewStrInt();
 516   end;
 517 end;
 518
 519
 520 constructor TDynField.Create (pr: TTextParser);
 521 begin
 522   cleanup();
 523   parseDef(pr);
 524 end;
 525
 526
 527 constructor TDynField.Create (const aname: AnsiString; val: Variant);
 528   procedure setInt32 (v: LongInt);
 529   begin
 530     case mType of
 531       TType.TBool:
 532              if (v = 0) then mIVal := 0
 533         else if (v = 1) then mIVal := 1
 534         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 535       TType.TByte:
 536              if (v >= -128) and (v <= 127) then mIVal := v
 537         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 538       TType.TUByte:
 539              if (v >= 0) and (v <= 255) then mIVal := v
 540         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 541       TType.TShort:
 542              if (v >= -32768) and (v <= 32767) then mIVal := v
 543         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 544       TType.TUShort:
 545              if (v >= 0) and (v <= 65535) then mIVal := v
 546         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 547       TType.TInt:
 548         mIVal := v;
 549       TType.TUInt:
 550         mIVal := v;
 551       TType.TString:
 552         mSVal := formatstrf('%s', [v]);
 553       else
 554         raise TDynRecException.Create('cannot convert integral variant to field value');
 555     end;
 556   end;
 557 begin
 558   mRVal := nil;
 559   mRecRef := nil;
 560   mRHash := nil;
 561   cleanup();
 562   mName := aname;
 563   case varType(val) of
 564     varEmpty: raise TDynRecException.Create('cannot convert empty variant to field value');
 565     varNull: raise TDynRecException.Create('cannot convert null variant to field value');
 566     varSingle: raise TDynRecException.Create('cannot convert single variant to field value');
 567     varDouble: raise TDynRecException.Create('cannot convert double variant to field value');
 568     varDecimal: raise TDynRecException.Create('cannot convert decimal variant to field value');
 569     varCurrency: raise TDynRecException.Create('cannot convert currency variant to field value');
 570     varDate: raise TDynRecException.Create('cannot convert date variant to field value');
 571     varOleStr: raise TDynRecException.Create('cannot convert olestr variant to field value');
 572     varStrArg: raise TDynRecException.Create('cannot convert stdarg variant to field value');
 573     varString: mType := TType.TString;
 574     varDispatch: raise TDynRecException.Create('cannot convert dispatch variant to field value');
 575     varBoolean: mType := TType.TBool;
 576     varVariant: raise TDynRecException.Create('cannot convert variant variant to field value');
 577     varUnknown: raise TDynRecException.Create('cannot convert unknown variant to field value');
 578     varByte: mType := TType.TUByte;
 579     varWord: mType := TType.TUShort;
 580     varShortInt: mType := TType.TByte;
 581     varSmallint: mType := TType.TShort;
 582     varInteger: mType := TType.TInt;
 583     varInt64: raise TDynRecException.Create('cannot convert int64 variant to field value');
 584     varLongWord: raise TDynRecException.Create('cannot convert longword variant to field value');
 585     varQWord: raise TDynRecException.Create('cannot convert uint64 variant to field value');
 586     varError: raise TDynRecException.Create('cannot convert error variant to field value');
 587     else raise TDynRecException.Create('cannot convert undetermined variant to field value');
 588   end;
 589   value := val;
 590 end;
 591
 592
 593 destructor TDynField.Destroy ();
 594 begin
 595   cleanup();
 596   inherited;
 597 end;
 598
 599
 600 procedure TDynField.cleanup ();
 601 begin
 602   mName := '';
 603   mType := TType.TInt;
 604   mIVal := 0;
 605   mIVal2 := 0;
 606   mSVal := '';
 607   mRVal.Free();
 608   mRVal := nil;
 609   mRHash.Free();
 610   mRHash := nil;
 611   mRecRef := nil;
 612   mMaxDim := -1;
 613   mBinOfs := -1;
 614   mSepPosSize := false;
 615   mAsT := false;
 616   mHasDefault := false;
 617   mDefined := false;
 618   mWriteDef := false;
 619   mInternal := true;
 620   mDefUnparsed := '';
 621   mDefSVal := '';
 622   mDefIVal := 0;
 623   mDefIVal2 := 0;
 624   mDefRecRef := nil;
 625   mEBS := TEBS.TNone;
 626   mEBSTypeName := '';
 627   mEBSType := nil;
 628   mBitSetUnique := false;
 629   mAsMonsterId := false;
 630   mNegBool := false;
 631   mRecRefId := '';
 632   mTagInt := 0;
 633   mTagPtr := nil;
 634   mAlias := '';
 635 end;
 636
 637
 638 function TDynField.clone (newOwner: TDynRecord=nil; registerIn: TDynRecord=nil): TDynField;
 639 var
 640   rec: TDynRecord;
 641 begin
 642   result := TDynField.Create(mName, mType);
 643   result.mOwner := mOwner;
 644   if (newOwner <> nil) then result.mOwner := newOwner else result.mOwner := mOwner;
 645   result.mName := mName;
 646   result.mType := mType;
 647   result.mIVal := mIVal;
 648   result.mIVal2 := mIVal2;
 649   result.mSVal := mSVal;
 650   if (mRVal <> nil) then
 651   begin
 652     if (result.mRVal = nil) then result.mRVal := TDynRecList.Create(mRVal.count);
 653     if (result.mRHash = nil) then result.mRHash := hashNewStrInt();
 654     for rec in mRVal do result.addListItem(rec.clone(registerIn));
 655   end;
 656   result.mRecRef := mRecRef;
 657   result.mMaxDim := mMaxDim;
 658   result.mBinOfs := mBinOfs;
 659   result.mSepPosSize := mSepPosSize;
 660   result.mAsT := mAsT;
 661   result.mDefined := mDefined;
 662   result.mHasDefault := mHasDefault;
 663   result.mWriteDef := mWriteDef;
 664   result.mInternal := mInternal;
 665   result.mNegBool := mNegBool;
 666   result.mBitSetUnique := mBitSetUnique;
 667   result.mAsMonsterId := mAsMonsterId;
 668   result.mDefUnparsed := mDefUnparsed;
 669   result.mDefSVal := mDefSVal;
 670   result.mDefIVal := mDefIVal;
 671   result.mDefIVal2 := mDefIVal2;
 672   result.mDefRecRef := mDefRecRef;
 673   result.mEBS := mEBS;
 674   result.mEBSTypeName := mEBSTypeName;
 675   result.mEBSType := mEBSType;
 676   result.mRecRefId := mRecRefId;
 677   result.mTagInt := mTagInt;
 678   result.mTagPtr := mTagPtr;
 679   result.mAlias := mAlias;
 680 end;
 681
 682
 683 function TDynField.palias (firstUp: Boolean=false): AnsiString;
 684 var
 685   nextUp: Boolean;
 686   ch: AnsiChar;
 687 begin
 688   if (Length(mAlias) > 0) then
 689   begin
 690     if firstUp then result := UpCase1251(mAlias[1])+Copy(mAlias, 2, Length(mAlias)-1) else result := mAlias;
 691   end
 692   else
 693   begin
 694     result := '';
 695     nextUp := firstUp;
 696     for ch in mName do
 697     begin
 698       if (ch = '_') then begin nextUp := true; continue; end;
 699       if nextUp then result += UpCase1251(ch) else result += ch;
 700       nextUp := false;
 701     end;
 702   end;
 703 end;
 704
 705
 706 procedure TDynField.setRecRef (arec: TDynRecord);
 707 var
 708   trc: TDynRecord = nil;
 709 begin
 710   case mEBS of
 711     TEBS.TNone: raise TDynRecException.CreateFmt('cannot set refrec for non-reference field ''%s''', [mName]);
 712     TEBS.TRec:
 713       begin
 714         if (arec <> nil) then
 715         begin
 716           if (mEBSType <> nil) and (mEBSType is TDynRecord) then trc := (mEBSType as TDynRecord);
 717           if (trc = nil) then raise TDynRecException.CreateFmt('cannot set refrec for field ''%s'' (type conflict: improperly initialized field)', [mName]);
 718           if (trc.typeName <> arec.typeName) then raise TDynRecException.CreateFmt('cannot set refrec for field ''%s'' (type conflict: expected ''%s'' got ''%s'')', [mName, trc.typeName, arec.typeName]);
 719         end;
 720         mRecRef := arec;
 721         mDefined := true;
 722         exit;
 723       end;
 724     TEBS.TEnum: raise TDynRecException.CreateFmt('cannot set refrec for enum field ''%s''', [mName]);
 725     TEBS.TBitSet: raise TDynRecException.CreateFmt('cannot set refrec for bitset field ''%s''', [mName]);
 726     else raise TDynRecException.Create('ketmar forgot to process some reftypes');
 727   end;
 728 end;
 729
 730
 731 function TDynField.getVar (): Variant;
 732 begin
 733   if (mEBS = TEBS.TRec) then begin result := LongInt(getRecRefIndex); exit; end;
 734   case mType of
 735     TType.TBool: result := (mIVal <> 0);
 736     TType.TChar: result := mSVal;
 737     TType.TByte: result := ShortInt(mIVal);
 738     TType.TUByte: result := Byte(mIVal);
 739     TType.TShort: result := SmallInt(mIVal);
 740     TType.TUShort: result := Word(mIVal);
 741     TType.TInt: result := LongInt(mIVal);
 742     TType.TUInt: result := LongWord(mIVal);
 743     TType.TString: result := mSVal;
 744     TType.TPoint: raise TDynRecException.Create('cannot convert point field to variant');
 745     TType.TSize: raise TDynRecException.Create('cannot convert size field to variant');
 746     TType.TList: raise TDynRecException.Create('cannot convert list field to variant');
 747     TType.TTrigData: raise TDynRecException.Create('cannot convert trigdata field to variant');
 748     else result := Unassigned; raise TDynRecException.Create('ketmar forgot to handle some field type');
 749   end;
 750 end;
 751
 752
 753 procedure TDynField.setVar (val: Variant);
 754   procedure setInt32 (v: LongInt);
 755   begin
 756     case mType of
 757       TType.TBool:
 758              if (v = 0) then mIVal := 0
 759         else if (v = 1) then mIVal := 1
 760         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 761       TType.TByte:
 762              if (v >= -128) and (v <= 127) then mIVal := v
 763         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 764       TType.TUByte:
 765              if (v >= 0) and (v <= 255) then mIVal := v
 766         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 767       TType.TShort:
 768              if (v >= -32768) and (v <= 32767) then mIVal := v
 769         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 770       TType.TUShort:
 771              if (v >= 0) and (v <= 65535) then mIVal := v
 772         else raise TDynRecException.Create('cannot convert shortint variant to field value');
 773       TType.TInt:
 774         mIVal := v;
 775       TType.TUInt:
 776         mIVal := v;
 777       TType.TString:
 778         mSVal := formatstrf('%s', [v]);
 779       else
 780         raise TDynRecException.Create('cannot convert integral variant to field value');
 781     end;
 782   end;
 783 begin
 784   case varType(val) of
 785     varEmpty: raise TDynRecException.Create('cannot convert empty variant to field value');
 786     varNull: raise TDynRecException.Create('cannot convert null variant to field value');
 787     varSingle: raise TDynRecException.Create('cannot convert single variant to field value');
 788     varDouble: raise TDynRecException.Create('cannot convert double variant to field value');
 789     varDecimal: raise TDynRecException.Create('cannot convert decimal variant to field value');
 790     varCurrency: raise TDynRecException.Create('cannot convert currency variant to field value');
 791     varDate: raise TDynRecException.Create('cannot convert date variant to field value');
 792     varOleStr: raise TDynRecException.Create('cannot convert olestr variant to field value');
 793     varStrArg: raise TDynRecException.Create('cannot convert stdarg variant to field value');
 794     varString:
 795       if (mType = TType.TChar) or (mType = TType.TString) then
 796       begin
 797         mSVal := val;
 798       end
 799       else
 800       begin
 801         raise TDynRecException.Create('cannot convert string variant to field value');
 802       end;
 803     varDispatch: raise TDynRecException.Create('cannot convert dispatch variant to field value');
 804     varBoolean:
 805       case mType of
 806         TType.TBool,
 807         TType.TByte,
 808         TType.TUByte,
 809         TType.TShort,
 810         TType.TUShort,
 811         TType.TInt,
 812         TType.TUInt:
 813           if val then mIVal := 1 else mIVal := 0;
 814         TType.TString:
 815           if val then mSVal := 'true' else mSVal := 'false';
 816         else
 817           raise TDynRecException.Create('cannot convert boolean variant to field value');
 818       end;
 819     varVariant: raise TDynRecException.Create('cannot convert variant variant to field value');
 820     varUnknown: raise TDynRecException.Create('cannot convert unknown variant to field value');
 821     varByte,
 822     varWord,
 823     varShortInt,
 824     varSmallint,
 825     varInteger:
 826       setInt32(val);
 827     varInt64:
 828       if (val < Int64(LongInt($80000000))) or (val > LongInt($7FFFFFFF)) then
 829         raise TDynRecException.Create('cannot convert boolean variant to field value')
 830       else
 831         mIVal := LongInt(val);
 832     varLongWord:
 833       if (val > LongWord($7FFFFFFF)) then raise TDynRecException.Create('cannot convert longword variant to field value')
 834       else setInt32(Integer(val));
 835     varQWord: raise TDynRecException.Create('cannot convert uint64 variant to field value');
 836     varError: raise TDynRecException.Create('cannot convert error variant to field value');
 837     else raise TDynRecException.Create('cannot convert undetermined variant to field value');
 838   end;
 839   mDefined := true;
 840 end;
 841
 842
 843 // won't work for lists
 844 function TDynField.isSimpleEqu (fld: TDynField): Boolean;
 845 begin
 846   if (fld = nil) or (mType <> fld.mType) then begin result := false; exit; end;
 847   case mType of
 848     TType.TBool: result := ((mIVal <> 0) = (fld.mIVal <> 0));
 849     TType.TChar: result := (mSVal = fld.mSVal);
 850     TType.TByte,
 851     TType.TUByte,
 852     TType.TShort,
 853     TType.TUShort,
 854     TType.TInt,
 855     TType.TUInt:
 856       result := (mIVal = fld.mIVal);
 857     TType.TString: result := (mSVal = fld.mSVal);
 858     TType.TPoint,
 859     TType.TSize:
 860       result := ((mIVal = fld.mIVal) and (mIVal2 = fld.mIVal2));
 861     TType.TList: result := false;
 862     TType.TTrigData:
 863       begin
 864         if (mRecRef = nil) then begin result := (fld.mRecRef = nil); exit; end;
 865         result := mRecRef.isSimpleEqu(fld.mRecRef);
 866       end;
 867     else raise TDynRecException.Create('ketmar forgot to handle some field type');
 868   end;
 869 end;
 870
 871
 872 procedure TDynField.setValue (const s: AnsiString);
 873 var
 874   stp: TTextParser;
 875 begin
 876   stp := TStrTextParser.Create(s+';');
 877   try
 878     parseValue(stp);
 879   finally
 880     stp.Free();
 881   end;
 882 end;
 883
 884
 885 procedure TDynField.parseDefaultValue ();
 886 var
 887   stp: TTextParser = nil;
 888   oSVal: AnsiString;
 889   oIVal, oIVal2: Integer;
 890   oRRef: TDynRecord;
 891   oDef: Boolean;
 892 begin
 893   if not mHasDefault then
 894   begin
 895     mDefSVal := '';
 896     mDefIVal := 0;
 897     mDefIVal2 := 0;
 898     mDefRecRef := nil;
 899   end
 900   else
 901   begin
 902     oSVal := mSVal;
 903     oIVal := mIVal;
 904     oIVal2 := mIVal2;
 905     oRRef := mRecRef;
 906     oDef := mDefined;
 907     try
 908       stp := TStrTextParser.Create(mDefUnparsed+';');
 909       parseValue(stp);
 910       mDefSVal := mSVal;
 911       mDefIVal := mIVal;
 912       mDefIVal2 := mIVal2;
 913       mDefRecRef := mRecRef;
 914     finally
 915       mSVal := oSVal;
 916       mIVal := oIVal;
 917       mIVal2 := oIVal2;
 918       mRecRef := oRRef;
 919       mDefined := oDef;
 920       stp.Free();
 921     end;
 922   end;
 923 end;
 924
 925
 926 // default value should be parsed
 927 procedure TDynField.fixDefaultValue ();
 928 begin
 929   if mDefined then exit;
 930   if not mHasDefault then
 931   begin
 932     if mInternal then exit;
 933     raise TDynRecException.CreateFmt('field ''%s'' in record ''%s'' of record type ''%s'' is not set', [mName, mOwner.mId, mOwner.mTypeName]);
 934   end;
 935   if (mEBS = TEBS.TRec) then mRecRef := mDefRecRef;
 936   mSVal := mDefSVal;
 937   mIVal := mDefIVal;
 938   mIVal2 := mDefIVal2;
 939   mDefined := true;
 940 end;
 941
 942
 943 // default value should be parsed
 944 function TDynField.isDefaultValue (): Boolean;
 945 begin
 946   if not mHasDefault then begin result := false; exit; end;
 947   if (mEBS = TEBS.TRec) then begin result := (mRecRef = mDefRecRef); exit; end;
 948   case mType of
 949     TType.TChar, TType.TString: result := (mSVal = mDefSVal);
 950     TType.TPoint, TType.TSize: result := (mIVal = mDefIVal2) and (mIVal2 = mDefIVal2);
 951     TType.TList, TType.TTrigData: result := false; // no default values for those types
 952     else result := (mIVal = mDefIVal);
 953   end;
 954 end;
 955
 956
 957 function TDynField.getListCount (): Integer; inline;
 958 begin
 959   if (mRVal <> nil) then result := mRVal.count else result := 0;
 960 end;
 961
 962
 963 function TDynField.getListItem (idx: Integer): TDynRecord; inline; overload;
 964 begin
 965   if (mRVal <> nil) and (idx >= 0) and (idx < mRVal.count) then result := mRVal[idx] else result := nil;
 966 end;
 967
 968
 969 function TDynField.getListItem (const aname: AnsiString): TDynRecord; inline; overload;
 970 var
 971   idx: Integer;
 972 begin
 973   if (mRVal <> nil) and mRHash.get(aname, idx) then result := mRVal[idx] else result := nil;
 974 end;
 975
 976
 977 function TDynField.addListItem (rec: TDynRecord): Boolean; inline;
 978 begin
 979   result := false;
 980   if (mRVal <> nil) then
 981   begin
 982     mRVal.append(rec);
 983     if (Length(rec.mId) > 0) then result := mRHash.put(rec.mId, mRVal.count-1);
 984   end;
 985 end;
 986
 987
 988 function TDynField.removeListItem (const aid: AnsiString): TDynRecord;
 989 var
 990   f, idx: Integer;
 991 begin
 992   result := nil;
 993   if mRHash.get(aid, idx) then
 994   begin
 995     assert((idx >= 0) and (idx < mRVal.count));
 996     result := mRVal[idx];
 997     // fix hash and list
 998     for f := idx+1 to mRVal.count-1 do
 999     begin
1000       if (Length(mRVal[f].mId) > 0) then mRHash.put(mRVal[f].mId, f-1);
1001     end;
1002     mRHash.del(aid);
1003     mRVal.delete(idx);
1004   end;
1005 end;
1006
1007
1008 class function TDynField.getTypeName (t: TType): AnsiString;
1009 begin
1010   case t of
1011     TType.TBool: result := 'bool';
1012     TType.TChar: result := 'char';
1013     TType.TByte: result := 'byte';
1014     TType.TUByte: result := 'ubyte';
1015     TType.TShort: result := 'short';
1016     TType.TUShort: result := 'ushort';
1017     TType.TInt: result := 'int';
1018     TType.TUInt: result := 'uint';
1019     TType.TString: result := 'string';
1020     TType.TPoint: result := 'point';
1021     TType.TSize: result := 'size';
1022     TType.TList: result := 'array';
1023     TType.TTrigData: result := 'trigdata';
1024     else raise TDynRecException.Create('ketmar forgot to handle some field type');
1025   end;
1026 end;
1027
1028
1029 function TDynField.definition (): AnsiString;
1030 begin
1031   result := quoteStr(mName)+' type ';
1032   result += getTypeName(mType);
1033   if (Length(mAlias) > 0) then result += ' alias '+mAlias;
1034   if (mMaxDim >= 0) then result += Format('[%d]', [mMaxDim]);
1035   if (mBinOfs >= 0) then result += Format(' offset %d', [mBinOfs]);
1036   case mEBS of
1037     TEBS.TNone: begin end;
1038     TEBS.TRec: result += ' '+mEBSTypeName;
1039     TEBS.TEnum: result += ' enum '+mEBSTypeName;
1040     TEBS.TBitSet: begin result += ' bitset '; if mBitSetUnique then result += 'unique '; result += mEBSTypeName; end;
1041   end;
1042   if mAsMonsterId then result += ' as monsterid';
1043   if mHasDefault and (Length(mDefUnparsed) > 0) then result += ' default '+mDefUnparsed;
1044   if mSepPosSize then
1045   begin
1046          if (mType = TType.TPoint) then begin if (mAsT) then result += ' as txy' else result += ' as xy'; end
1047     else if (mType = TType.TSize) then begin if (mAsT) then result += ' as twh' else result += ' as wh'; end;
1048   end;
1049   if mWriteDef then result += ' writedefault';
1050   if mInternal then result += ' internal';
1051 end;
1052
1053
1054 procedure TDynField.parseDef (pr: TTextParser);
1055 var
1056   fldname: AnsiString;
1057   fldtype: AnsiString;
1058   fldofs: Integer;
1059   fldrecname: AnsiString;
1060   asxy, aswh, ast: Boolean;
1061   ainternal: Boolean;
1062   writedef: Boolean;
1063   defstr: AnsiString;
1064   defint, defint2: Integer;
1065   hasdefStr: Boolean;
1066   hasdefInt: Boolean;
1067   hasdefId: Boolean;
1068   lmaxdim: Integer;
1069   lebs: TDynField.TEBS;
1070   unique: Boolean;
1071   asmonid: Boolean;
1072   defech: AnsiChar;
1073   xalias: AnsiString;
1074 begin
1075   fldname := '';
1076   fldtype := '';
1077   fldofs := -1;
1078   fldrecname := '';
1079   asxy := false;
1080   aswh := false;
1081   ast := false;
1082   ainternal := false;
1083   writedef := false;
1084   defstr := '';
1085   defint := 0;
1086   defint2 := 0;
1087   hasdefStr := false;
1088   hasdefInt := false;
1089   hasdefId := false;
1090   unique := false;
1091   asmonid := false;
1092   lmaxdim := -1;
1093   lebs := TDynField.TEBS.TNone;
1094   xalias := '';
1095
1096   // field name
1097   fldname := pr.expectStrOrId();
1098
1099   while (pr.tokType <> pr.TTSemi) do
1100   begin
1101     if pr.eatId('type') then
1102     begin
1103       if (Length(fldtype) > 0) then raise TDynParseException.CreateFmt(pr, 'duplicate type definition for field ''%s''', [fldname]);
1104       // field type
1105       fldtype := pr.expectId();
1106       // fixed-size array?
1107       if pr.eatDelim('[') then
1108       begin
1109         lmaxdim := pr.expectInt();
1110         // arbitrary limits
1111         if (lmaxdim < 1) or (lmaxdim > 32768) then raise TDynParseException.CreateFmt(pr, 'invalid field ''%s'' array size', [fldname]);
1112         pr.expectDelim(']');
1113       end;
1114       continue;
1115     end;
1116
1117     if pr.eatId('alias') then
1118     begin
1119       if (Length(xalias) > 0) then raise TDynParseException.CreateFmt(pr, 'duplicate alias definition for field ''%s''', [fldname]);
1120       xalias := pr.expectId();
1121       continue;
1122     end;
1123
1124     if pr.eatId('offset') then
1125     begin
1126       if (fldofs >= 0) then raise TDynParseException.CreateFmt(pr, 'duplicate field ''%s'' offset', [fldname]);
1127       fldofs := pr.expectInt();
1128       if (fldofs < 0) then raise TDynParseException.CreateFmt(pr, 'invalid field ''%s'' offset', [fldname]);
1129       continue;
1130     end;
1131
1132     if pr.eatId('as') then
1133     begin
1134            if pr.eatId('xy') then asxy := true
1135       else if pr.eatId('wh') then aswh := true
1136       else if pr.eatId('txy') then begin asxy := true; ast := true; end
1137       else if pr.eatId('twh') then begin aswh := true; ast := true; end
1138       else if pr.eatId('monsterid') then begin asmonid := true; end
1139       else raise TDynParseException.CreateFmt(pr, 'invalid field ''%s'' as what?', [fldname]);
1140       continue;
1141     end;
1142
1143     if pr.eatId('enum') then
1144     begin
1145       lebs := TDynField.TEBS.TEnum;
1146       if (Length(fldrecname) <> 0) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' already typed as ''%s''', [fldname, fldrecname]);
1147       fldrecname := pr.expectId();
1148       continue;
1149     end;
1150
1151     if pr.eatId('bitset') then
1152     begin
1153       lebs := TDynField.TEBS.TBitSet;
1154       if (Length(fldrecname) <> 0) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' already typed as ''%s''', [fldname, fldrecname]);
1155       unique := pr.eatId('unique');
1156       fldrecname := pr.expectId();
1157       continue;
1158     end;
1159
1160     if pr.eatId('default') then
1161     begin
1162       if hasdefStr or hasdefInt or hasdefId then raise TDynParseException.CreateFmt(pr, 'field ''%s'' has duplicate default', [fldname]);
1163       case pr.tokType of
1164         pr.TTStr:
1165           begin
1166             hasdefStr := true;
1167             defstr := pr.expectStr(true); // allow empty strings
1168           end;
1169         pr.TTId:
1170           begin
1171             hasdefId := true;
1172             defstr := pr.expectId();
1173           end;
1174         pr.TTInt:
1175           begin
1176             hasdefInt := true;
1177             defint := pr.expectInt();
1178           end;
1179         pr.TTDelim:
1180           begin
1181             hasdefInt := true;
1182             if pr.eatDelim('[') then defech := ']' else begin pr.expectDelim('('); defech := ')'; end;
1183             defint := pr.expectInt();
1184             defint2 := pr.expectInt();
1185             pr.expectDelim(defech);
1186           end;
1187         else
1188           raise TDynParseException.CreateFmt(pr, 'field ''%s'' has invalid default', [fldname]);
1189       end;
1190       continue;
1191     end;
1192
1193     if pr.eatId('writedefault') then
1194     begin
1195       writedef := true;
1196       continue;
1197     end;
1198
1199     if pr.eatId('internal') then
1200     begin
1201       ainternal := true;
1202       continue;
1203     end;
1204
1205     // record type, no special modifiers
1206     if (pr.tokType <> pr.TTId) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' has something unexpected in definition', [fldname]);
1207
1208     if (Length(fldrecname) <> 0) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' already typed as ''%s''', [fldname, fldrecname]);
1209     fldrecname := pr.expectId();
1210     lebs := TDynField.TEBS.TRec;
1211   end;
1212
1213   pr.expectTT(pr.TTSemi);
1214
1215   // create field
1216   mName := fldname;
1217        if (fldtype = 'bool') then mType := TType.TBool
1218   else if (fldtype = 'negbool') then begin mType := TType.TBool; mNegBool := true; end
1219   else if (fldtype = 'char') then mType := TType.TChar
1220   else if (fldtype = 'byte') then mType := TType.TByte
1221   else if (fldtype = 'ubyte') then mType := TType.TUByte
1222   else if (fldtype = 'short') then mType := TType.TShort
1223   else if (fldtype = 'ushort') then mType := TType.TUShort
1224   else if (fldtype = 'int') then mType := TType.TInt
1225   else if (fldtype = 'uint') then mType := TType.TUInt
1226   else if (fldtype = 'string') then mType := TType.TString
1227   else if (fldtype = 'point') then mType := TType.TPoint
1228   else if (fldtype = 'size') then mType := TType.TSize
1229   else if (fldtype = 'trigdata') then mType := TType.TTrigData
1230   else
1231   begin
1232     // record types defaults to int
1233     if (Length(fldrecname) > 0) then
1234     begin
1235       mType := TType.TInt;
1236     end
1237     else
1238     begin
1239       if (Length(fldtype) = 0) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' has no type', [fldname])
1240       else raise TDynParseException.CreateFmt(pr, 'field ''%s'' has invalid type ''%s''', [fldname, fldtype]);
1241     end;
1242   end;
1243
1244   // check for valid arrays
1245   if (lmaxdim > 0) and (mType <> TType.TChar) and (mType <> TType.TTrigData) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' cannot be array', [fldname, fldtype]);
1246
1247   // check for valid trigdata or record type
1248   if (mType = TType.TTrigData) then
1249   begin
1250     // trigdata
1251     if (lmaxdim < 1) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' cannot be non-array', [fldname, 'trigdata']);
1252     if (Length(fldrecname) > 0) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' cannot have another type', [fldname, 'trigdata']);
1253     lebs := TDynField.TEBS.TRec;
1254   end
1255   else if (Length(fldrecname) > 0) then
1256   begin
1257     // record
1258     if not (mType in [TType.TByte, TType.TUByte, TType.TShort, TType.TUShort, TType.TInt, TType.TUInt]) then
1259     begin
1260       raise TDynParseException.CreateFmt(pr, 'field ''%s'' of record type ''%s'' cannot have type ''%s''', [fldname, fldrecname, fldtype]);
1261     end;
1262   end;
1263
1264   // setup default value
1265        if hasdefStr then self.mDefUnparsed := quoteStr(defstr)
1266   else if hasdefId then self.mDefUnparsed := defstr
1267   else if hasdefInt then
1268   begin
1269          if (mType = TType.TPoint) then self.mDefUnparsed := Format('(%d %d)', [defint, defint2])
1270     else if (mType = TType.TSize) then self.mDefUnparsed := Format('[%d %d]', [defint, defint2])
1271     else self.mDefUnparsed := Format('%d', [defint]);
1272   end;
1273
1274   self.mHasDefault := (hasdefStr or hasdefId or hasdefInt);
1275   self.mEBS := lebs;
1276   self.mEBSTypeName := fldrecname;
1277   self.mBitSetUnique := unique;
1278   self.mAsMonsterId := asmonid;
1279   self.mMaxDim := lmaxdim;
1280   self.mBinOfs := fldofs;
1281   self.mSepPosSize := (asxy or aswh);
1282   self.mAsT := ast;
1283   self.mWriteDef := writedef;
1284   self.mInternal := ainternal;
1285   self.mAlias := xalias;
1286 end;
1287
1288
1289 function TDynField.getRecRefIndex (): Integer;
1290 begin
1291   if (mRecRef = nil) then begin result := -1; exit; end;
1292   result := mOwner.findRecordNumByType(mEBSTypeName, mRecRef);
1293 end;
1294
1295
1296 procedure TDynField.writeBinTo (var hasLostData: Boolean; st: TStream);
1297 var
1298   s: AnsiString;
1299   f: Integer;
1300   maxv: Integer;
1301   buf: PByte;
1302   ws: TStream = nil;
1303 begin
1304   case mEBS of
1305     TEBS.TNone: begin end;
1306     TEBS.TRec:
1307       begin
1308         if (mMaxDim >= 0) then
1309         begin
1310           // this must be triggerdata
1311           if (mType <> TType.TTrigData) then
1312           begin
1313             raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]);
1314           end;
1315           // write triggerdata
1316           GetMem(buf, mMaxDim);
1317           if (buf = nil) then raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]);
1318           try
1319             FillChar(buf^, mMaxDim, 0);
1320             if (mRecRef <> nil) then
1321             begin
1322               ws := TSFSMemoryChunkStream.Create(buf, mMaxDim);
1323               mRecRef.writeBinTo(hasLostData, ws, mMaxDim); // as trigdata
1324             end;
1325             st.WriteBuffer(buf^, mMaxDim);
1326           finally
1327             ws.Free();
1328             if (buf <> nil) then FreeMem(buf);
1329           end;
1330           exit;
1331         end;
1332         // record reference
1333         case mType of
1334           TType.TByte: maxv := 127;
1335           TType.TUByte: maxv := 254;
1336           TType.TShort: maxv := 32767;
1337           TType.TUShort: maxv := 65534;
1338           TType.TInt: maxv := $7fffffff;
1339           TType.TUInt: maxv := $7fffffff;
1340           else raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]);
1341         end;
1342         // find record number
1343         if (mRecRef <> nil) then
1344         begin
1345           f := mOwner.findRecordNumByType(mEBSTypeName, mRecRef);
1346           if (f < 0) then raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' not found in record list', [mEBSTypeName, mName]);
1347           if mAsMonsterId then Inc(f);
1348           if (f > maxv) then raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' has too big index', [mEBSTypeName, mName]);
1349         end
1350         else
1351         begin
1352           if mAsMonsterId then f := 0 else f := -1;
1353         end;
1354         case mType of
1355           TType.TByte, TType.TUByte: writeInt(st, Byte(f));
1356           TType.TShort, TType.TUShort: writeInt(st, SmallInt(f));
1357           TType.TInt, TType.TUInt: writeInt(st, LongWord(f));
1358           else raise TDynRecException.CreateFmt('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]);
1359         end;
1360         exit;
1361       end;
1362     TEBS.TEnum: begin end;
1363     TEBS.TBitSet: begin end;
1364     else raise TDynRecException.Create('ketmar forgot to handle some EBS type');
1365   end;
1366
1367   case mType of
1368     TType.TBool:
1369       begin
1370         if not mNegBool then
1371         begin
1372           if (mIVal <> 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
1373         end
1374         else
1375         begin
1376           if (mIVal = 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
1377         end;
1378         exit;
1379       end;
1380     TType.TChar:
1381       begin
1382         if (mMaxDim = 0) then raise TDynRecException.CreateFmt('invalid string size definition for field ''%s''', [mName]);
1383         if (mMaxDim < 0) then
1384         begin
1385           if (Length(mSVal) <> 1) then raise TDynRecException.CreateFmt('invalid string size definition for field ''%s''', [mName]);
1386           writeInt(st, Byte(mSVal[1]));
1387         end
1388         else
1389         begin
1390           if (Length(mSVal) > mMaxDim) then raise TDynRecException.CreateFmt('invalid string size definition for field ''%s''', [mName]);
1391           s := utf2win(mSVal);
1392           if (Length(s) > 0) then st.WriteBuffer(PChar(s)^, Length(s));
1393           for f := Length(s) to mMaxDim do writeInt(st, Byte(0));
1394         end;
1395         exit;
1396       end;
1397     TType.TByte,
1398     TType.TUByte:
1399       begin
1400         // triggerdata array was processed earlier
1401         if (mMaxDim >= 0) then TDynRecException.CreateFmt('byte array in field ''%s'' cannot be written', [mName]);
1402         writeInt(st, Byte(mIVal));
1403         exit;
1404       end;
1405     TType.TShort,
1406     TType.TUShort:
1407       begin
1408         if (mMaxDim >= 0) then raise TDynRecException.CreateFmt('short array in field ''%s'' cannot be written', [mName]);
1409         writeInt(st, Word(mIVal));
1410         exit;
1411       end;
1412     TType.TInt,
1413     TType.TUInt:
1414       begin
1415         if (mMaxDim >= 0) then raise TDynRecException.CreateFmt('int array in field ''%s'' cannot be written', [mName]);
1416         writeInt(st, LongWord(mIVal));
1417         exit;
1418       end;
1419     TType.TString:
1420       begin
1421         raise TDynRecException.CreateFmt('cannot write string field ''%s''', [mName]);
1422       end;
1423     TType.TPoint:
1424       begin
1425         if (mMaxDim >= 0) then raise TDynRecException.CreateFmt('pos/size array in field ''%s'' cannot be written', [mName]);
1426         writeInt(st, LongInt(mIVal));
1427         writeInt(st, LongInt(mIVal2));
1428         exit;
1429       end;
1430     TType.TSize:
1431       begin
1432         if (mMaxDim >= 0) then raise TDynRecException.CreateFmt('pos/size array in field ''%s'' cannot be written', [mName]);
1433         writeInt(st, Word(mIVal));
1434         writeInt(st, Word(mIVal2));
1435         exit;
1436       end;
1437     TType.TList:
1438       raise TDynRecException.Create('cannot write lists to binary format');
1439     TType.TTrigData:
1440       raise TDynRecException.Create('cannot write triggers to binary format (internal error)');
1441     else raise TDynRecException.Create('ketmar forgot to handle some field type');
1442   end;
1443 end;
1444
1445
1446 procedure TDynField.writeTo (wr: TTextWriter);
1447 var
1448   es: TDynEBS = nil;
1449   f, mask: Integer;
1450   first, found: Boolean;
1451 begin
1452   wr.put(mName);
1453   wr.put(' ');
1454   case mEBS of
1455     TEBS.TNone: begin end;
1456     TEBS.TRec:
1457       begin
1458         if (mRecRef = nil) then
1459         begin
1460           if (mType = TType.TTrigData) then wr.put('{}'#10) else wr.put('null;'#10);
1461         end
1462         else if (Length(mRecRef.mId) = 0) then
1463         begin
1464           mRecRef.writeTo(wr, false); // only data, no header
1465         end
1466         else
1467         begin
1468           wr.put(mRecRef.mId);
1469           wr.put(';'#10);
1470         end;
1471         exit;
1472       end;
1473     TEBS.TEnum:
1474       begin
1475         //def := mOwner.mOwner;
1476         //es := def.ebsType[mEBSTypeName];
1477         es := nil;
1478         if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
1479         if (es = nil) or (not es.mIsEnum) then raise TDynRecException.CreateFmt('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1480         for f := 0 to High(es.mVals) do
1481         begin
1482           if (es.mVals[f] = mIVal) then
1483           begin
1484             wr.put(es.mIds[f]);
1485             wr.put(';'#10);
1486             exit;
1487           end;
1488         end;
1489         raise TDynRecException.CreateFmt('value %d in record enum type ''%s'' for field ''%s'' not found', [mIVal, mEBSTypeName, mName]);
1490       end;
1491     TEBS.TBitSet:
1492       begin
1493         //def := mOwner.mOwner;
1494         //es := def.ebsType[mEBSTypeName];
1495         es := nil;
1496         if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
1497         if (es = nil) or es.mIsEnum then raise TDynRecException.CreateFmt('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1498         // none?
1499         if (mIVal = 0) then
1500         begin
1501           for f := 0 to High(es.mVals) do
1502           begin
1503             if (es.mVals[f] = 0) then
1504             begin
1505               wr.put(es.mIds[f]);
1506               wr.put(';'#10);
1507               exit;
1508             end;
1509           end;
1510           raise TDynRecException.CreateFmt('value %d in record bitset type ''%s'' for field ''%s'' not found', [0, mEBSTypeName, mName]);
1511         end;
1512         // not none
1513         mask := 1;
1514         first := true;
1515         while (mask <> 0) do
1516         begin
1517           if ((mIVal and mask) <> 0) then
1518           begin
1519             found := false;
1520             for f := 0 to High(es.mVals) do
1521             begin
1522               if (es.mVals[f] = mask) then
1523               begin
1524                 if not first then wr.put(' | ') else first := false;
1525                 wr.put(es.mIds[f]);
1526                 found := true;
1527                 break;
1528               end;
1529             end;
1530             if not found then raise TDynRecException.CreateFmt('value %d in record bitset type ''%s'' for field ''%s'' not found', [mask, mEBSTypeName, mName]);
1531           end;
1532           mask := mask shl 1;
1533         end;
1534         wr.put(';'#10);
1535         exit;
1536       end;
1537     else raise TDynRecException.Create('ketmar forgot to handle some EBS type');
1538   end;
1539
1540   case mType of
1541     TType.TBool:
1542       begin
1543         if (mIVal = 0) then wr.put('false;'#10) else wr.put('true;'#10);
1544         exit;
1545       end;
1546     TType.TChar:
1547       begin
1548         if (mMaxDim = 0) then raise TDynRecException.CreateFmt('invalid string size definition for field ''%s''', [mName]);
1549         wr.put(quoteStr(mSVal));
1550         wr.put(';'#10);
1551         exit;
1552       end;
1553     TType.TByte,
1554     TType.TUByte,
1555     TType.TShort,
1556     TType.TUShort,
1557     TType.TInt,
1558     TType.TUInt:
1559       begin
1560         wr.put('%d;'#10, [mIVal]);
1561         exit;
1562       end;
1563     TType.TString:
1564       begin
1565         wr.put(quoteStr(mSVal));
1566         wr.put(';'#10);
1567         exit;
1568       end;
1569     TType.TPoint,
1570     TType.TSize:
1571       begin
1572         wr.put('(%d %d);'#10, [mIVal, mIVal2]);
1573         exit;
1574       end;
1575     TType.TList:
1576       begin
1577         assert(false);
1578         exit;
1579       end;
1580     TType.TTrigData:
1581       begin
1582         assert(false);
1583         exit;
1584       end;
1585     else raise TDynRecException.Create('ketmar forgot to handle some field type');
1586   end;
1587   raise TDynRecException.CreateFmt('cannot parse field ''%s'' yet', [mName]);
1588 end;
1589
1590
1591 procedure TDynField.parseBinValue (st: TStream);
1592 var
1593   rec, rc: TDynRecord;
1594   tfld: TDynField;
1595   es: TDynEBS = nil;
1596   tdata: PByte = nil;
1597   f, mask: Integer;
1598   s: AnsiString;
1599 begin
1600   case mEBS of
1601     TEBS.TNone: begin end;
1602     TEBS.TRec:
1603       begin
1604         // this must be triggerdata
1605         if (mType = TType.TTrigData) then
1606         begin
1607           assert(mMaxDim > 0);
1608           rec := mOwner;
1609           // find trigger definition
1610           tfld := rec.trigTypeField();
1611           if (tfld = nil) then raise TDynRecException.CreateFmt('triggerdata value for field ''%s'' in record ''%s'' without TriggerType field', [mName, rec.mTypeName]);
1612           rc := mOwner.mOwner.trigTypeFor[tfld.mSVal]; // find in mapdef
1613           if (rc = nil) then raise TDynRecException.CreateFmt('triggerdata definition for field ''%s'' in record ''%s'' with type ''%s'' not found', [mName, rec.mTypeName, tfld.mSVal]);
1614           rc := rc.clone(mOwner.mHeaderRec);
1615           rc.mHeaderRec := mOwner.mHeaderRec;
1616           // on error, it will be freed by memowner
1617           rc.parseBinValue(st, true);
1618           mRecRef := rc;
1619           mDefined := true;
1620           exit;
1621         end
1622         else
1623         begin
1624           // not a trigger data
1625           case mType of
1626             TType.TByte: f := readShortInt(st);
1627             TType.TUByte: f := readByte(st);
1628             TType.TShort: f := readSmallInt(st);
1629             TType.TUShort: f := readWord(st);
1630             TType.TInt: f := readLongInt(st);
1631             TType.TUInt: f := readLongWord(st);
1632             else raise TDynRecException.CreateFmt('invalid non-numeric type ''%s'' for field ''%s'' of record ''%s''', [getTypeName(mType), mName, mEBSTypeName]);
1633           end;
1634           if mAsMonsterId then Dec(f);
1635           if (f < 0) then mRecRefId := '' else mRecRefId := Format('%s%d', [mEBSTypeName, f]);
1636         end;
1637         mDefined := true;
1638         exit;
1639       end;
1640     TEBS.TEnum,
1641     TEBS.TBitSet:
1642       begin
1643         assert(mMaxDim < 0);
1644         case mType of
1645           TType.TByte: f := readShortInt(st);
1646           TType.TUByte: f := readByte(st);
1647           TType.TShort: f := readSmallInt(st);
1648           TType.TUShort: f := readWord(st);
1649           TType.TInt: f := readLongInt(st);
1650           TType.TUInt: f := readLongWord(st);
1651           else raise TDynRecException.CreateFmt('invalid non-numeric type ''%s'' for field ''%s'' of record ''%s''', [getTypeName(mType), mName, mEBSTypeName]);
1652         end;
1653         es := nil;
1654         if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
1655         if (es = nil) or (es.mIsEnum <> (mEBS = TEBS.TEnum)) then raise TDynRecException.CreateFmt('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1656         mIVal := f;
1657         // build enum/bitfield values
1658         if (mEBS = TEBS.TEnum) then
1659         begin
1660           mSVal := es.nameByValue(mIVal);
1661           if (Length(mSVal) = 0) then raise TDynRecException.CreateFmt('record enum type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mIVal]);
1662         end
1663         else
1664         begin
1665           // special for 'none'
1666           if (mIVal = 0) then
1667           begin
1668             mSVal := es.nameByValue(mIVal);
1669             if (Length(mSVal) = 0) then raise TDynRecException.CreateFmt('record bitset type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mIVal]);
1670           end
1671           else
1672           begin
1673             mSVal := '';
1674             mask := 1;
1675             while (mask <> 0) do
1676             begin
1677               if ((mIVal and mask) <> 0) then
1678               begin
1679                 s := es.nameByValue(mask);
1680                 if (Length(s) = 0) then raise TDynRecException.CreateFmt('record bitset type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mask]);
1681                 if (Length(mSVal) <> 0) then mSVal += '+';
1682                 mSVal += s;
1683               end;
1684               mask := mask shl 1;
1685             end;
1686           end;
1687         end;
1688         //writeln('ebs <', es.mName, '>: ', mSVal);
1689         mDefined := true;
1690         exit;
1691       end;
1692     else raise TDynRecException.Create('ketmar forgot to handle some EBS type');
1693   end;
1694
1695   case mType of
1696     TType.TBool:
1697       begin
1698         f := readByte(st);
1699         if (f <> 0) then f := 1;
1700         if mNegBool then f := 1-f;
1701         mIVal := f;
1702         mDefined := true;
1703         exit;
1704       end;
1705     TType.TChar:
1706       begin
1707         if (mMaxDim < 0) then
1708         begin
1709           mIVal := readByte(st);
1710         end
1711         else
1712         begin
1713           mSVal := '';
1714           GetMem(tdata, mMaxDim);
1715           try
1716             st.ReadBuffer(tdata^, mMaxDim);
1717             f := 0;
1718             while (f < mMaxDim) and (tdata[f] <> 0) do Inc(f);
1719             if (f > 0) then
1720             begin
1721               SetLength(mSVal, f);
1722               Move(tdata^, PChar(mSVal)^, f);
1723               mSVal := win2utf(mSVal);
1724             end;
1725           finally
1726             FreeMem(tdata);
1727           end;
1728         end;
1729         mDefined := true;
1730         exit;
1731       end;
1732     TType.TByte: begin mIVal := readShortInt(st); mDefined := true; exit; end;
1733     TType.TUByte: begin mIVal := readByte(st); mDefined := true; exit; end;
1734     TType.TShort: begin mIVal := readSmallInt(st); mDefined := true; exit; end;
1735     TType.TUShort: begin mIVal := readWord(st); mDefined := true; exit; end;
1736     TType.TInt: begin mIVal := readLongInt(st); mDefined := true; exit; end;
1737     TType.TUInt: begin mIVal := readLongWord(st); mDefined := true; exit; end;
1738     TType.TString:
1739       begin
1740         raise TDynRecException.Create('cannot read strings from binaries yet');
1741         exit;
1742       end;
1743     TType.TPoint:
1744       begin
1745         mIVal := readLongInt(st);
1746         mIVal2 := readLongInt(st);
1747         mDefined := true;
1748         exit;
1749       end;
1750     TType.TSize:
1751       begin
1752         mIVal := readWord(st);
1753         mIVal2 := readWord(st);
1754         mDefined := true;
1755         exit;
1756       end;
1757     TType.TList:
1758       begin
1759         assert(false);
1760         exit;
1761       end;
1762     TType.TTrigData:
1763       begin
1764         assert(false);
1765         exit;
1766       end;
1767     else raise TDynRecException.Create('ketmar forgot to handle some field type');
1768   end;
1769   raise TDynRecException.CreateFmt('cannot parse field ''%s'' yet', [mName]);
1770 end;
1771
1772
1773 procedure TDynField.parseValue (pr: TTextParser);
1774
1775   procedure parseInt (min, max: Integer);
1776   begin
1777     mIVal := pr.expectInt();
1778     if (mIVal < min) or (mIVal > max) then raise TDynParseException.CreateFmt(pr, 'invalid %s value for field ''%s''', [getTypeName(mType), mName]);
1779     mDefined := true;
1780   end;
1781
1782 var
1783   rec, rc: TDynRecord;
1784   es: TDynEBS = nil;
1785   tfld: TDynField;
1786   tk: AnsiString;
1787   edim: AnsiChar;
1788 begin
1789   if (pr.tokType = pr.TTEOF) then raise TDynParseException.Create(pr, 'field value expected');
1790   if (pr.tokType = pr.TTSemi) then raise TDynParseException.Create(pr, 'extra semicolon');
1791   // if this field should contain struct, convert type and parse struct
1792   case mEBS of
1793     TEBS.TNone: begin end;
1794     TEBS.TRec:
1795       begin
1796         // ugly hack. sorry.
1797         if (mType = TType.TTrigData) then
1798         begin
1799           pr.expectTT(pr.TTBegin);
1800           if (pr.tokType = pr.TTEnd) then
1801           begin
1802             // '{}'
1803             mRecRef := nil;
1804             pr.expectTT(pr.TTEnd);
1805           end
1806           else
1807           begin
1808             rec := mOwner;
1809             // find trigger definition
1810             tfld := rec.trigTypeField();
1811             if (tfld = nil) then raise TDynParseException.CreateFmt(pr, 'triggerdata value for field ''%s'' in record ''%s'' without ''type'' field', [mName, rec.mTypeName]);
1812             rc := mOwner.mOwner.trigTypeFor[tfld.mSVal]; // find in mapdef
1813             if (rc = nil) then raise TDynParseException.CreateFmt(pr, 'triggerdata definition for field ''%s'' in record ''%s'' with type ''%s'' not found', [mName, rec.mTypeName, tfld.mSVal]);
1814             rc := rc.clone(mOwner.mHeaderRec);
1815             rc.mHeaderRec := mOwner.mHeaderRec;
1816             //writeln(rc.definition);
1817             // on error, it will be freed by memowner
1818             rc.parseValue(pr, true);
1819             mRecRef := rc;
1820           end;
1821           mDefined := true;
1822           pr.eatTT(pr.TTSemi); // hack: allow (but don't require) semicolon after inline records
1823           exit;
1824         end;
1825         // other record types
1826         if (pr.tokType = pr.TTId) then
1827         begin
1828           if pr.eatId('null') then
1829           begin
1830             mRecRef := nil;
1831           end
1832           else
1833           begin
1834             rec := mOwner.findRecordByTypeId(mEBSTypeName, pr.tokStr);
1835             if (rec = nil) then
1836             begin
1837               mRecRefId := pr.tokStr;
1838             end
1839             else
1840             begin
1841               mRecRef := rec;
1842               mRecRefId := '';
1843             end;
1844             pr.expectId();
1845           end;
1846           mDefined := true;
1847           pr.expectTT(pr.TTSemi);
1848           exit;
1849         end
1850         else if (pr.tokType = pr.TTBegin) then
1851         begin
1852           //rec := mOwner.mOwner.recType[mEBSTypeName]; // find in mapdef
1853           rec := nil;
1854           if (mEBSType <> nil) and (mEBSType is TDynRecord) then rec := (mEBSType as TDynRecord);
1855           if (rec = nil) then raise TDynParseException.CreateFmt(pr, 'record type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1856           rc := rec.clone(mOwner.mHeaderRec);
1857           rc.mHeaderRec := mOwner.mHeaderRec;
1858           rc.parseValue(pr);
1859           mRecRef := rc;
1860           mDefined := true;
1861           if mOwner.addRecordByType(mEBSTypeName, rc) then
1862           begin
1863             raise TDynParseException.CreateFmt(pr, 'duplicate record with id ''%s'' for field ''%s'' in record ''%s''', [rc.mId, mName, mOwner.mTypeName]);
1864           end;
1865           pr.eatTT(pr.TTSemi); // hack: allow (but don't require) semicolon after inline records
1866           exit;
1867         end;
1868         pr.expectTT(pr.TTBegin);
1869       end;
1870     TEBS.TEnum:
1871       begin
1872         //es := mOwner.mOwner.ebsType[mEBSTypeName]; // find in mapdef
1873         es := nil;
1874         if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
1875         if (es = nil) or (not es.mIsEnum) then raise TDynParseException.CreateFmt(pr, 'record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1876         tk := pr.expectId();
1877         if not es.has[tk] then raise TDynParseException.CreateFmt(pr, 'record enum value ''%s'' of type ''%s'' for field ''%s'' not found', [tk, mEBSTypeName, mName]);
1878         mIVal := es.field[tk];
1879         mSVal := tk;
1880         //writeln('ENUM ', mEBSName, '; element <', mSVal, '> with value ', mIVal);
1881         mDefined := true;
1882         pr.expectTT(pr.TTSemi);
1883         exit;
1884       end;
1885     TEBS.TBitSet:
1886       begin
1887         //es := mOwner.mOwner.ebsType[mEBSTypeName]; // find in mapdef
1888         es := nil;
1889         if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
1890         if (es = nil) or es.mIsEnum then raise TDynParseException.CreateFmt(pr, 'record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]);
1891         mIVal := 0;
1892         while true do
1893         begin
1894           tk := pr.expectId();
1895           if not es.has[tk] then raise TDynParseException.CreateFmt(pr, 'record bitset value ''%s'' of type ''%s'' for field ''%s'' not found', [tk, mEBSTypeName, mName]);
1896           mIVal := mIVal or es.field[tk];
1897           mSVal := tk;
1898           if (pr.tokType <> pr.TTDelim) or ((pr.tokChar <> '|') and (pr.tokChar <> '+')) then break;
1899           if mBitSetUnique then raise TDynParseException.CreateFmt(pr, 'record bitset of type ''%s'' for field ''%s'' expects only one value', [tk, mEBSTypeName, mName]);
1900           pr.skipToken(); // plus or pipe
1901         end;
1902         mDefined := true;
1903         pr.expectTT(pr.TTSemi);
1904         exit;
1905       end;
1906     else raise TDynParseException.Create(pr, 'ketmar forgot to handle some EBS type');
1907   end;
1908
1909   case mType of
1910     TType.TBool:
1911       begin
1912              if pr.eatId('true') or pr.eatId('tan') or pr.eatId('yes') then mIVal := 1
1913         else if pr.eatId('false') or pr.eatId('ona') or pr.eatId('no') then mIVal := 0
1914         else raise TDynParseException.CreateFmt(pr, 'invalid bool value for field ''%s''', [mName]);
1915         mDefined := true;
1916         pr.expectTT(pr.TTSemi);
1917         exit;
1918       end;
1919     TType.TChar:
1920       begin
1921         if (mMaxDim = 0) then raise TDynParseException.CreateFmt(pr, 'invalid string size definition for field ''%s''', [mName]);
1922         mSVal := pr.expectStr(true);
1923         if (mMaxDim < 0) then
1924         begin
1925           // single char
1926           if (Length(mSVal) <> 1) then raise TDynParseException.CreateFmt(pr, 'invalid string size for field ''%s''', [mName]);
1927           mIVal := Integer(mSVal[1]);
1928           mSVal := '';
1929         end
1930         else
1931         begin
1932           // string
1933           if (Length(mSVal) > mMaxDim) then raise TDynParseException.CreateFmt(pr, 'invalid string size for field ''%s''', [mName]);
1934         end;
1935         mDefined := true;
1936         pr.expectTT(pr.TTSemi);
1937         exit;
1938       end;
1939     TType.TByte:
1940       begin
1941         parseInt(-128, 127);
1942         pr.expectTT(pr.TTSemi);
1943         exit;
1944       end;
1945     TType.TUByte:
1946       begin
1947         parseInt(0, 255);
1948         pr.expectTT(pr.TTSemi);
1949         exit;
1950       end;
1951     TType.TShort:
1952       begin
1953         parseInt(-32768, 32768);
1954         pr.expectTT(pr.TTSemi);
1955         exit;
1956       end;
1957     TType.TUShort:
1958       begin
1959         parseInt(0, 65535);
1960         pr.expectTT(pr.TTSemi);
1961         exit;
1962       end;
1963     TType.TInt:
1964       begin
1965         parseInt(Integer($80000000), $7fffffff);
1966         pr.expectTT(pr.TTSemi);
1967         exit;
1968       end;
1969     TType.TUInt:
1970       begin
1971         parseInt(0, $7fffffff); //FIXME
1972         pr.expectTT(pr.TTSemi);
1973         exit;
1974       end;
1975     TType.TString:
1976       begin
1977         mSVal := pr.expectStr(true);
1978         mDefined := true;
1979         pr.expectTT(pr.TTSemi);
1980         exit;
1981       end;
1982     TType.TPoint,
1983     TType.TSize:
1984       begin
1985         if pr.eatDelim('[') then edim := ']' else begin pr.expectDelim('('); edim := ')'; end;
1986         mIVal := pr.expectInt();
1987         if (mType = TType.TSize) then
1988         begin
1989           if (mIVal < 0) or (mIVal > 32767) then raise TDynParseException.CreateFmt(pr, 'invalid %s value for field ''%s''', [getTypeName(mType), mName]);
1990         end;
1991         mIVal2 := pr.expectInt();
1992         if (mType = TType.TSize) then
1993         begin
1994           if (mIVal2 < 0) or (mIVal2 > 32767) then raise TDynParseException.CreateFmt(pr, 'invalid %s value for field ''%s''', [getTypeName(mType), mName]);
1995         end;
1996         mDefined := true;
1997         pr.expectDelim(edim);
1998         pr.expectTT(pr.TTSemi);
1999         exit;
2000       end;
2001     TType.TList:
2002       begin
2003         assert(false);
2004         exit;
2005       end;
2006     TType.TTrigData:
2007       begin
2008         assert(false);
2009         exit;
2010       end;
2011     else raise TDynParseException.Create(pr, 'ketmar forgot to handle some field type');
2012   end;
2013   raise TDynParseException.CreateFmt(pr, 'cannot parse field ''%s'' yet', [mName]);
2014 end;
2015
2016
2017 // ////////////////////////////////////////////////////////////////////////// //
2018 constructor TDynRecord.Create (pr: TTextParser);
2019 begin
2020   if (pr = nil) then raise TDynParseException.Create(pr, 'cannot create record type without type definition');
2021   mId := '';
2022   mTypeName := '';
2023   mSize := 0;
2024   mFields := TDynFieldList.Create();
2025   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2026   mFieldsHash := hashNewStrInt();
2027   {$ENDIF}
2028   mTrigTypes := nil;
2029   mHeader := false;
2030   mHeaderRec := nil;
2031   mBinBlock := -1;
2032   mTagInt := 0;
2033   mTagPtr := nil;
2034   parseDef(pr);
2035 end;
2036
2037
2038 constructor TDynRecord.Create ();
2039 begin
2040   mTypeName := '';
2041   mSize := 0;
2042   mFields := TDynFieldList.Create();
2043   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2044   mFieldsHash := hashNewStrInt();
2045   {$ENDIF}
2046   mTrigTypes := nil;
2047   mHeader := false;
2048   mHeaderRec := nil;
2049   mTagInt := 0;
2050   mTagPtr := nil;
2051   mRec2Free := nil;
2052 end;
2053
2054
2055 destructor TDynRecord.Destroy ();
2056 var
2057   fld: TDynField;
2058   rec: TDynRecord;
2059 begin
2060   if (mRec2Free <> nil) then
2061   begin
2062     for rec in mRec2Free do
2063     begin
2064       if (rec <> self) then
2065       begin
2066         //writeln(formatstrf('freeing: 0x%08x; name=%s; id=%s', [Pointer(rec), rec.mName, rec.mId]));
2067         rec.Free();
2068       end;
2069     end;
2070     mRec2Free.Free();
2071     mRec2Free := nil;
2072   end;
2073   mTypeName := '';
2074   for fld in mFields do fld.Free();
2075   mFields.Free();
2076   mFields := nil;
2077   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2078   mFieldsHash.Free();
2079   mFieldsHash := nil;
2080   {$ENDIF}
2081   mTrigTypes := nil;
2082   mHeaderRec := nil;
2083   mTagInt := 0;
2084   mTagPtr := nil;
2085   inherited;
2086 end;
2087
2088
2089 procedure TDynRecord.regrec (rec: TDynRecord);
2090 begin
2091   if (rec <> nil) and (rec <> self) then
2092   begin
2093     if (mRec2Free = nil) then mRec2Free := TDynRecList.Create();
2094     mRec2Free.append(rec);
2095   end;
2096 end;
2097
2098
2099 procedure TDynRecord.addField (fld: TDynField); inline;
2100 begin
2101   if (fld = nil) then raise TDynRecException.Create('cannot append nil field to record');
2102   mFields.append(fld);
2103   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2104   if (Length(fld.mName) > 0) then mFieldsHash.put(fld.mName, mFields.count-1);
2105   {$ENDIF}
2106 end;
2107
2108
2109 function TDynRecord.addFieldChecked (fld: TDynField): Boolean; inline; // `true`: duplicate name
2110 begin
2111   result := false;
2112   if (fld = nil) then raise TDynRecException.Create('cannot append nil field to record');
2113   {$IF not DEFINED(XDYNREC_USE_FIELDHASH)}
2114   if (Length(fld.mName) > 0) then result := hasByName(fld.mName);
2115   {$ENDIF}
2116   mFields.append(fld);
2117   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2118   if (Length(fld.mName) > 0) then result := mFieldsHash.put(fld.mName, mFields.count-1);
2119   {$ENDIF}
2120 end;
2121
2122
2123 function TDynRecord.findByName (const aname: AnsiString): Integer; inline;
2124 begin
2125   {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
2126   if not mFieldsHash.get(aname, result) then result := -1;
2127   {$ELSE}
2128   result := 0;
2129   while (result < mFields.count) do
2130   begin
2131     if StrEqu(aname, mFields[result].mName) then exit;
2132     Inc(result);
2133   end;
2134   result := -1;
2135   {$ENDIF}
2136 end;
2137
2138
2139 function TDynRecord.hasByName (const aname: AnsiString): Boolean; inline;
2140 begin
2141   result := (findByName(aname) >= 0);
2142 end;
2143
2144
2145 function TDynRecord.getFieldByName (const aname: AnsiString): TDynField; inline;
2146 var
2147   f: Integer;
2148 begin
2149   f := findByName(aname);
2150   if (f >= 0) then result := mFields[f] else result := nil;
2151 end;
2152
2153
2154 function TDynRecord.getFieldAt (idx: Integer): TDynField; inline;
2155 begin
2156   if (idx >= 0) and (idx < mFields.count) then result := mFields[idx] else result := nil;
2157 end;
2158
2159
2160 function TDynRecord.getCount (): Integer; inline;
2161 begin
2162   result := mFields.count;
2163 end;
2164
2165
2166 function TDynRecord.getIsTrigData (): Boolean; inline;
2167 begin
2168   result := (Length(mTrigTypes) > 0);
2169 end;
2170
2171
2172 function TDynRecord.getIsForTrig (const aname: AnsiString): Boolean; inline;
2173 var
2174   f: Integer;
2175 begin
2176   result := true;
2177   for f := 0 to High(mTrigTypes) do if StrEqu(mTrigTypes[f], aname) then exit;
2178   result := false;
2179 end;
2180
2181
2182 function TDynRecord.getForTrigCount (): Integer; inline;
2183 begin
2184   result := Length(mTrigTypes);
2185 end;
2186
2187
2188 function TDynRecord.getForTrigAt (idx: Integer): AnsiString; inline;
2189 begin
2190   if (idx >= 0) and (idx < Length(mTrigTypes)) then result := mTrigTypes[idx] else result := '';
2191 end;
2192
2193
2194 function TDynRecord.clone (registerIn: TDynRecord): TDynRecord;
2195 var
2196   fld: TDynField;
2197   f: Integer;
2198 begin
2199   result := TDynRecord.Create();
2200   result.mOwner := mOwner;
2201   result.mId := mId;
2202   result.mTypeName := mTypeName;
2203   result.mSize := mSize;
2204   result.mHeader := mHeader;
2205   result.mBinBlock := mBinBlock;
2206   result.mHeaderRec := mHeaderRec;
2207   result.mTagInt := mTagInt;
2208   result.mTagPtr := mTagPtr;
2209   if (mFields.count > 0) then
2210   begin
2211     result.mFields.capacity := mFields.count;
2212     for fld in mFields do result.addField(fld.clone(result, registerIn));
2213   end;
2214   SetLength(result.mTrigTypes, Length(mTrigTypes));
2215   for f := 0 to High(mTrigTypes) do result.mTrigTypes[f] := mTrigTypes[f];
2216   if (registerIn <> nil) then registerIn.regrec(result);
2217 end;
2218
2219
2220 function TDynRecord.findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
2221 var
2222   fld: TDynField;
2223   idx: Integer;
2224 begin
2225   result := nil;
2226   if (Length(aid) = 0) then exit;
2227   // find record data
2228   fld := mHeaderRec.field[atypename];
2229   if (fld = nil) then exit;
2230   if (fld.mType <> fld.TType.TList) then raise TDynRecException.CreateFmt('cannot get record of type ''%s'' due to name conflict with ordinary field', [atypename]);
2231   // find by id
2232   if (fld.mRVal <> nil) then
2233   begin
2234     if fld.mRHash.get(aid, idx) then begin result := fld.mRVal[idx]; exit; end;
2235   end;
2236   // alas
2237 end;
2238
2239
2240 function TDynRecord.findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
2241 var
2242   fld: TDynField;
2243   idx: Integer;
2244 begin
2245   result := -1;
2246   // find record data
2247   fld := mHeaderRec.field[atypename];
2248   if (fld = nil) then exit;
2249   if (fld.mType <> fld.TType.TList) then raise TDynRecException.CreateFmt('cannot get record of type ''%s'' due to name conflict with ordinary field', [atypename]);
2250   // find by ref
2251   if (fld.mRVal <> nil) then
2252   begin
2253     for idx := 0 to fld.mRVal.count-1 do
2254     begin
2255       if (fld.mRVal[idx] = rc) then begin result := idx; exit; end;
2256     end;
2257   end;
2258   // alas
2259 end;
2260
2261
2262 function TDynRecord.addRecordByType (const atypename: AnsiString; rc: TDynRecord): Boolean;
2263 var
2264   fld: TDynField;
2265 begin
2266   // find record data
2267   fld := mHeaderRec.field[atypename];
2268   if (fld = nil) then
2269   begin
2270     // first record
2271     fld := TDynField.Create(atypename, TDynField.TType.TList);
2272     fld.mOwner := mHeaderRec;
2273     mHeaderRec.addField(fld);
2274   end;
2275   if (fld.mType <> fld.TType.TList) then raise TDynRecException.CreateFmt('cannot append record of type ''%s'' due to name conflict with ordinary field', [atypename]);
2276   // append
2277   if (fld.mRVal = nil) then
2278   begin
2279     fld.mRVal := TDynRecList.Create();
2280     fld.mRHash := hashNewStrInt();
2281   end;
2282   result := fld.addListItem(rc);
2283 end;
2284
2285
2286 function TDynRecord.isSimpleEqu (rec: TDynRecord): Boolean;
2287 var
2288   f: Integer;
2289 begin
2290   if (rec = nil) then begin result := false; exit; end; // self.mRecRef can't be `nil` here
2291   if (rec = self) then begin result := true; exit; end;
2292   if (mFields.count <> rec.mFields.count) then begin result := false; exit; end;
2293   result := false;
2294   for f := 0 to mFields.count-1 do
2295   begin
2296     if not mFields[f].isSimpleEqu(rec.mFields[f]) then exit;
2297   end;
2298   result := true;
2299 end;
2300
2301
2302 function TDynRecord.trigTypeField (): TDynField;
2303 var
2304   fld: TDynField;
2305   es: TDynEBS = nil;
2306 begin
2307   for fld in mFields do
2308   begin
2309     if (fld.mEBS <> TDynField.TEBS.TEnum) then continue;
2310     if not (fld.mEBSType is TDynEBS) then continue;
2311     es := (fld.mEBSType as TDynEBS);
2312     assert(es <> nil);
2313     if StrEqu(es.mTypeName, 'TriggerType') then begin result := fld; exit; end;
2314   end;
2315   result := nil;
2316 end;
2317
2318
2319 // number of records of the given instance
2320 function TDynRecord.instanceCount (const atypename: AnsiString): Integer;
2321 var
2322   fld: TDynField;
2323 begin
2324   result := 0;
2325   fld := field[atypename];
2326   if (fld <> nil) and (fld.mType = fld.TType.TList) then result := fld.mRVal.count;
2327 end;
2328
2329
2330 function TDynRecord.newTypedRecord (const atypename, aid: AnsiString): TDynRecord;
2331 var
2332   trc: TDynRecord;
2333   fld: TDynField;
2334 begin
2335   if not mHeader then raise TDynRecException.Create('cannot create new records with non-header');
2336   if (Length(aid) = 0) then raise TDynRecException.CreateFmt('cannot create new record of type ''%s'' without id', [atypename]);
2337   trc := mapdef.recType[atypename];
2338   if (trc = nil) then begin result := nil; exit; end;
2339   // check if aid is unique
2340   fld := field[atypename];
2341   if (fld <> nil) and (fld.getListItem(aid) <> nil) then raise TDynRecException.CreateFmt('cannot create record of type ''%s'' with duplicate id ''%s''', [atypename, aid]);
2342   result := trc.clone(self);
2343   result.mId := aid;
2344   addRecordByType(atypename, result);
2345 end;
2346
2347
2348 procedure TDynRecord.clearRefRecs (rec: TDynRecord);
2349   procedure clearRefs (fld: TDynField);
2350   var
2351     rc: TDynRecord;
2352   begin
2353     if (fld = nil) then exit;
2354     if (fld.mRecRef = rec) then fld.mRecRef := nil;
2355     if (fld.mType = fld.TType.TList) then for rc in fld.mRVal do rc.clearRefRecs(rec);
2356   end;
2357 var
2358   fld: TDynField;
2359 begin
2360   if (rec = nil) or (mFields = nil) then exit;
2361   for fld in mFields do clearRefs(fld);
2362 end;
2363
2364
2365 // remove record with the given type and id
2366 // return `true` if record was successfully found and removed
2367 // this will do all necessary recref cleanup too
2368 function TDynRecord.removeTypedRecord (const atypename, aid: AnsiString): Boolean;
2369 var
2370   trc, rec: TDynRecord;
2371   fld: TDynField;
2372   f: Integer;
2373   doFree: Boolean = false;
2374 begin
2375   result := false;
2376   if not mHeader then raise TDynRecException.Create('cannot remove records with non-header');
2377   if (Length(aid) = 0) then exit;
2378   trc := mapdef.recType[atypename];
2379   if (trc = nil) then exit;
2380   fld := field[atypename];
2381   if (fld = nil) then exit;
2382   rec := fld.removeListItem(aid);
2383   if (rec = nil) then exit;
2384   clearRefRecs(rec);
2385   for f := 0 to mRec2Free.count-1 do
2386   begin
2387     if (mRec2Free[f] = rec) then
2388     begin
2389       mRec2Free[f] := nil;
2390       doFree := true;
2391     end;
2392   end;
2393   if doFree then rec.Free();
2394 end;
2395
2396
2397 function TDynRecord.getUserVar (const aname: AnsiString): Variant;
2398 var
2399   fld: TDynField;
2400 begin
2401   fld := getFieldByName(aname);
2402   if (fld = nil) then result := Unassigned else result := fld.value;
2403 end;
2404
2405
2406 procedure TDynRecord.setUserVar (const aname: AnsiString; val: Variant);
2407 var
2408   fld: TDynField;
2409 begin
2410   fld := getFieldByName(aname);
2411   if (fld = nil) then
2412   begin
2413     if (Length(aname) = 0) then raise TDynRecException.Create('cannot create nameless user field');
2414     fld := TDynField.Create(aname, val);
2415     fld.mOwner := self;
2416     fld.mInternal := true;
2417     addField(fld);
2418   end
2419   else
2420   begin
2421     fld.value := val;
2422   end;
2423 end;
2424
2425
2426 procedure TDynRecord.parseDef (pr: TTextParser);
2427 var
2428   fld: TDynField;
2429   tdn: AnsiString;
2430 begin
2431   if pr.eatId('TriggerData') then
2432   begin
2433     pr.expectId('for');
2434     if pr.eatDelim('(') then
2435     begin
2436       while true do
2437       begin
2438         while pr.eatTT(pr.TTComma) do begin end;
2439         if pr.eatDelim(')') then break;
2440         tdn := pr.expectId();
2441         if isForTrig[tdn] then raise TDynParseException.CreateFmt(pr, 'duplicate trigdata ''%s'' trigtype ''%s''', [mTypeName, tdn]);
2442         SetLength(mTrigTypes, Length(mTrigTypes)+1);
2443         mTrigTypes[High(mTrigTypes)] := tdn;
2444       end;
2445     end
2446     else
2447     begin
2448       tdn := pr.expectId();
2449       SetLength(mTrigTypes, 1);
2450       mTrigTypes[0] := tdn;
2451     end;
2452     mTypeName := 'TriggerData';
2453   end
2454   else
2455   begin
2456     mTypeName := pr.expectStrOrId();
2457     while (pr.tokType <> pr.TTBegin) do
2458     begin
2459       if pr.eatId('header') then begin mHeader := true; continue; end;
2460       if pr.eatId('size') then
2461       begin
2462         if (mSize > 0) then raise TDynParseException.CreateFmt(pr, 'duplicate `size` in record ''%s''', [mTypeName]);
2463         mSize := pr.expectInt();
2464         if (mSize < 1) then raise TDynParseException.CreateFmt(pr, 'invalid record ''%s'' size: %d', [mTypeName, mSize]);
2465         pr.expectId('bytes');
2466         continue;
2467       end;
2468       if pr.eatId('binblock') then
2469       begin
2470         if (mBinBlock >= 0) then raise TDynParseException.CreateFmt(pr, 'duplicate `binblock` in record ''%s''', [mTypeName]);
2471         mBinBlock := pr.expectInt();
2472         if (mBinBlock < 1) then raise TDynParseException.CreateFmt(pr, 'invalid record ''%s'' binblock: %d', [mTypeName, mBinBlock]);
2473         continue;
2474       end;
2475     end;
2476   end;
2477
2478   pr.expectTT(pr.TTBegin);
2479   // load fields
2480   while (pr.tokType <> pr.TTEnd) do
2481   begin
2482     fld := TDynField.Create(pr);
2483     // append
2484     fld.mOwner := self;
2485     if addFieldChecked(fld) then
2486     begin
2487       fld.Free();
2488       raise TDynParseException.CreateFmt(pr, 'duplicate field ''%s''', [fld.name]);
2489     end;
2490     // done with field
2491   end;
2492   pr.expectTT(pr.TTEnd);
2493 end;
2494
2495
2496 function TDynRecord.definition (): AnsiString;
2497 var
2498   f: Integer;
2499 begin
2500   if isTrigData then
2501   begin
2502     // trigger data
2503     result := 'TriggerData for ';
2504     if (Length(mTrigTypes) > 1) then
2505     begin
2506       result += '(';
2507       for f := 0 to High(mTrigTypes) do
2508       begin
2509         if (f <> 0) then result += ', ';
2510         result += mTrigTypes[f];
2511       end;
2512       result += ')';
2513     end
2514     else
2515     begin
2516       result += mTrigTypes[0];
2517     end;
2518   end
2519   else
2520   begin
2521     // record
2522     result := quoteStr(mTypeName);
2523     if (mSize >= 0) then result += Format(' size %d bytes', [mSize]);
2524     if mHeader then result += ' header';
2525   end;
2526   result += ' {'#10;
2527   for f := 0 to mFields.count-1 do
2528   begin
2529     result += '  ';
2530     result += mFields[f].definition;
2531     result += ';'#10;
2532   end;
2533   result += '}';
2534 end;
2535
2536
2537 procedure TDynRecord.parseBinValue (st: TStream; forceData: Boolean=false);
2538 var
2539   sign: string[4];
2540   btype: Integer;
2541   bsize: Integer;
2542   buf: PByte = nil;
2543   loaded: array[0..255] of Boolean;
2544   rec, rect: TDynRecord;
2545   fld: TDynField;
2546   f: Integer;
2547   mst: TSFSMemoryChunkStream = nil;
2548
2549   procedure linkNames (rec: TDynRecord);
2550   var
2551     fld: TDynField;
2552     rt: TDynRecord;
2553   begin
2554     //writeln('*** rec: ', rec.mName, '.', rec.mId, ' (', rec.mFields.count, ')');
2555     for fld in rec.mFields do
2556     begin
2557       if (fld.mType = TDynField.TType.TTrigData) then
2558       begin
2559         if (fld.mRecRef <> nil) then linkNames(fld.mRecRef);
2560         continue;
2561       end;
2562       if (Length(fld.mRecRefId) = 0) then continue;
2563       assert(fld.mEBSType <> nil);
2564       rt := findRecordByTypeId(fld.mEBSTypeName, fld.mRecRefId);
2565       if (rt = nil) then
2566       begin
2567         e_LogWritefln('record of type ''%s'' with id ''%s'' links to inexistant record of type ''%s'' with id ''%s''', [rec.mTypeName, rec.mId, fld.mEBSTypeName, fld.mRecRefId], MSG_WARNING);
2568         //raise TDynRecException.CreateFmt('record of type ''%s'' with id ''%s'' links to inexistant record of type ''%s'' with id ''%s''', [rec.mName, rec.mId, fld.mEBSTypeName, fld.mRecRefId]);
2569       end;
2570       //writeln(' ', rec.mName, '.', rec.mId, ':', fld.mName, ' -> ', rt.mName, '.', rt.mId, ' (', fld.mEBSTypeName, '.', fld.mRecRefId, ')');
2571       fld.mRecRefId := '';
2572       fld.mRecRef := rt;
2573       fld.mDefined := true;
2574     end;
2575     for fld in rec.mFields do
2576     begin
2577       //writeln('  ', fld.mName);
2578       fld.fixDefaultValue(); // just in case
2579     end;
2580   end;
2581
2582 begin
2583   for f := 0 to High(loaded) do loaded[f] := false;
2584   mst := TSFSMemoryChunkStream.Create(nil, 0);
2585   try
2586     if mHeader and not forceData then
2587     begin
2588       // parse map file as sequence of blocks
2589       sign[0] := #4;
2590       st.ReadBuffer(sign[1], 4);
2591       if (sign <> 'MAP'#1) then raise TDynRecException.Create('invalid binary map signature');
2592       // parse blocks
2593       while (st.position < st.size) do
2594       begin
2595         btype := readByte(st);
2596         if (btype = 0) then break; // no more blocks
2597         readLongWord(st); // reserved
2598         bsize := readLongInt(st);
2599         {$IF DEFINED(D2D_XDYN_DEBUG)}writeln('btype=', btype, '; bsize=', bsize);{$ENDIF}
2600         if (bsize < 0) or (bsize > $1fffffff) then raise TDynRecException.CreateFmt('block of type %d has invalid size %d', [btype, bsize]);
2601         if loaded[btype] then raise TDynRecException.CreateFmt('block of type %d already loaded', [btype]);
2602         loaded[btype] := true;
2603         // find record type for this block
2604         rect := nil;
2605         for rec in mOwner.recTypes do if (rec.mBinBlock = btype) then begin rect := rec; break; end;
2606         if (rect = nil) then raise TDynRecException.CreateFmt('block of type %d has no corresponding record', [btype]);
2607         //writeln('found type ''', rec.mName, ''' for block type ', btype);
2608         if (rec.mSize = 0) or ((bsize mod rec.mSize) <> 0) then raise TDynRecException.CreateFmt('block of type %d has invalid number of records', [btype]);
2609         // header?
2610         if (rect.mHeader) then
2611         begin
2612           if (bsize <> mSize) then raise TDynRecException.CreateFmt('header block of type %d has invalid number of records', [btype]);
2613           GetMem(buf, bsize);
2614           st.ReadBuffer(buf^, bsize);
2615           mst.setup(buf, mSize);
2616           parseBinValue(mst, true); // force parsing data
2617         end
2618         else
2619         begin
2620           // create list for this type
2621           fld := TDynField.Create(rec.mTypeName, TDynField.TType.TList);
2622           fld.mOwner := self;
2623           addField(fld);
2624           if (bsize > 0) then
2625           begin
2626             GetMem(buf, bsize);
2627             st.ReadBuffer(buf^, bsize);
2628             for f := 0 to (bsize div rec.mSize)-1 do
2629             begin
2630               mst.setup(buf+f*rec.mSize, rec.mSize);
2631               rec := rect.clone(self);
2632               rec.mHeaderRec := self;
2633               rec.parseBinValue(mst);
2634               rec.mId := Format('%s%d', [rec.mTypeName, f]);
2635               fld.addListItem(rec);
2636               //writeln('parsed ''', rec.mId, '''...');
2637             end;
2638           end;
2639         end;
2640         FreeMem(buf);
2641         buf := nil;
2642         //st.position := st.position+bsize;
2643       end;
2644       // link fields
2645       for fld in mFields do
2646       begin
2647         if (fld.mType <> TDynField.TType.TList) then continue;
2648         for rec in fld.mRVal do linkNames(rec);
2649       end;
2650       exit;
2651     end;
2652
2653     // read fields
2654     if StrEqu(mTypeName, 'TriggerData') then mSize := Integer(st.size-st.position);
2655     if (mSize < 1) then raise TDynRecException.CreateFmt('cannot read record of type ''%s'' with unknown size', [mTypeName]);
2656     GetMem(buf, mSize);
2657     st.ReadBuffer(buf^, mSize);
2658     for fld in mFields do
2659     begin
2660       if fld.mInternal then continue;
2661       if (fld.mBinOfs < 0) then continue;
2662       if (fld.mBinOfs >= st.size) then raise TDynRecException.CreateFmt('record of type ''%s'' has invalid field ''%s''', [fld.mName]);
2663       mst.setup(buf+fld.mBinOfs, mSize-fld.mBinOfs);
2664       //writeln('parsing ''', mName, '.', fld.mName, '''...');
2665       fld.parseBinValue(mst);
2666     end;
2667   finally
2668     mst.Free();
2669     if (buf <> nil) then FreeMem(buf);
2670   end;
2671 end;
2672
2673
2674 procedure TDynRecord.writeBinTo (var hasLostData: Boolean; st: TStream; trigbufsz: Integer=-1; onlyFields: Boolean=false);
2675 var
2676   fld: TDynField;
2677   rec, rv: TDynRecord;
2678   buf: PByte = nil;
2679   ws: TStream = nil;
2680   blk, blkmax: Integer;
2681   bufsz: Integer = 0;
2682   blksz: Integer;
2683 begin
2684   if (trigbufsz < 0) then
2685   begin
2686     if (mBinBlock < 1) then raise TDynRecException.Create('cannot write binary record without block number');
2687     if (mSize < 1) then raise TDynRecException.Create('cannot write binary record without size');
2688     bufsz := mSize;
2689   end
2690   else
2691   begin
2692     bufsz := trigbufsz;
2693   end;
2694   try
2695     GetMem(buf, bufsz);
2696     FillChar(buf^, bufsz, 0);
2697     ws := TSFSMemoryChunkStream.Create(buf, bufsz);
2698
2699     // write normal fields
2700     for fld in mFields do
2701     begin
2702       // record list?
2703       if (fld.mType = fld.TType.TList) then continue; // later
2704       if fld.mInternal then continue;
2705       if (fld.mBinOfs < 0) then
2706       begin
2707         if not fld.equToDefault then hasLostData := true;
2708         continue;
2709       end;
2710       if (fld.mBinOfs >= bufsz) then raise TDynRecException.Create('binary value offset is outside of the buffer');
2711       TSFSMemoryChunkStream(ws).setup(buf+fld.mBinOfs, bufsz-fld.mBinOfs);
2712       //writeln('writing field <', fld.mName, '>');
2713       fld.writeBinTo(hasLostData, ws);
2714     end;
2715
2716     // write block with normal fields
2717     if mHeader and not onlyFields then
2718     begin
2719       //writeln('writing header...');
2720       // signature and version
2721       writeIntBE(st, LongWord($4D415001));
2722       writeInt(st, Byte(mBinBlock)); // type
2723       writeInt(st, LongWord(0)); // reserved
2724       writeInt(st, LongWord(bufsz)); // size
2725     end;
2726     st.WriteBuffer(buf^, bufsz);
2727
2728     ws.Free(); ws := nil;
2729     FreeMem(buf); buf := nil;
2730
2731     // write other blocks, if any
2732     if mHeader and not onlyFields then
2733     begin
2734       // calculate blkmax
2735       blkmax := 0;
2736       for fld in mFields do
2737       begin
2738         // record list?
2739         if (fld.mType = fld.TType.TList) then
2740         begin
2741           if (fld.mRVal = nil) or (fld.mRVal.count = 0) then continue;
2742           rec := mOwner.recType[fld.mName];
2743           if (rec = nil) then continue;
2744           if (rec.mBinBlock <= 0) then continue;
2745           if (blkmax < rec.mBinBlock) then blkmax := rec.mBinBlock;
2746         end;
2747       end;
2748       // write blocks
2749       for blk := 1 to blkmax do
2750       begin
2751         if (blk = mBinBlock) then continue;
2752         ws := nil;
2753         for fld in mFields do
2754         begin
2755           // record list?
2756           if (fld.mType = fld.TType.TList) then
2757           begin
2758             if (fld.mRVal = nil) or (fld.mRVal.count = 0) then continue;
2759             rec := mOwner.recType[fld.mName];
2760             if (rec = nil) then continue;
2761             if (rec.mBinBlock <> blk) then continue;
2762             if (ws = nil) then ws := TMemoryStream.Create();
2763             for rv in fld.mRVal do rv.writeBinTo(hasLostData, ws);
2764           end;
2765         end;
2766         // flush block
2767         if (ws <> nil) then
2768         begin
2769           blksz := Integer(ws.position);
2770           ws.position := 0;
2771           writeInt(st, Byte(blk)); // type
2772           writeInt(st, LongWord(0)); // reserved
2773           writeInt(st, LongWord(blksz)); // size
2774           st.CopyFrom(ws, blksz);
2775           ws.Free();
2776           ws := nil;
2777         end;
2778       end;
2779       // write end marker
2780       writeInt(st, Byte(0));
2781       writeInt(st, LongWord(0));
2782       writeInt(st, LongWord(0));
2783     end;
2784   finally
2785     ws.Free();
2786     if (buf <> nil) then FreeMem(buf);
2787   end;
2788 end;
2789
2790
2791 procedure TDynRecord.writeTo (wr: TTextWriter; putHeader: Boolean=true);
2792 var
2793   fld: TDynField;
2794   rec: TDynRecord;
2795   putTypeComment: Boolean;
2796   f: Integer;
2797 begin
2798   if putHeader then
2799   begin
2800     wr.put(mTypeName);
2801     if (Length(mId) > 0) then begin wr.put(' '); wr.put(mId); end;
2802     wr.put(' ');
2803   end;
2804   wr.put('{'#10);
2805   wr.indent();
2806   try
2807     for fld in mFields do
2808     begin
2809       // record list?
2810       if (fld.mType = fld.TType.TList) then
2811       begin
2812         if not mHeader then raise TDynRecException.Create('record list in non-header record');
2813         if (fld.mRVal <> nil) and (fld.mRVal.count > 0) then
2814         begin
2815           putTypeComment := true;
2816           for rec in fld.mRVal do
2817           begin
2818             if (rec = nil) or (Length(rec.mId) = 0) then continue;
2819             if putTypeComment then
2820             begin
2821               wr.put(#10);
2822               if (80-wr.curIndent*2 >= 2) then
2823               begin
2824                 wr.putIndent();
2825                 for f := wr.curIndent to 80-wr.curIndent do wr.put('/');
2826                 wr.put(#10);
2827               end;
2828               putTypeComment := false;
2829               wr.putIndent();
2830               wr.put('// ');
2831               wr.put(fld.name);
2832               wr.put(#10);
2833             end
2834             else
2835             begin
2836               wr.put(#10);
2837             end;
2838             wr.putIndent();
2839             rec.writeTo(wr, true);
2840           end;
2841         end;
2842         continue;
2843       end;
2844       if fld.mInternal then continue;
2845       if (not fld.mWriteDef) and fld.isDefaultValue then continue;
2846       wr.putIndent();
2847       fld.writeTo(wr);
2848     end;
2849   finally
2850     wr.unindent();
2851   end;
2852   wr.putIndent();
2853   wr.put('}'#10);
2854 end;
2855
2856
2857 {$IF DEFINED(D2D_DYNREC_PROFILER)}
2858 var
2859   profCloneRec: UInt64 = 0;
2860   profFindRecType: UInt64 = 0;
2861   profFieldSearching: UInt64 = 0;
2862   profListDupChecking: UInt64 = 0;
2863   profAddRecByType: UInt64 = 0;
2864   profFieldValParsing: UInt64 = 0;
2865   profFixDefaults: UInt64 = 0;
2866   profRecValParse: UInt64 = 0;
2867
2868 procedure xdynDumpProfiles ();
2869 begin
2870   writeln('=== XDYNREC PROFILES ===');
2871   writeln('record cloning: ', profCloneRec div 1000, '.', profCloneRec mod 1000, ' milliseconds');
2872   writeln('findRecType   : ', profFindRecType div 1000, '.', profFindRecType mod 1000, ' milliseconds');
2873   writeln('field[]       : ', profFieldSearching div 1000, '.', profFieldSearching mod 1000, ' milliseconds');
2874   writeln('list dup check: ', profListDupChecking div 1000, '.', profListDupChecking mod 1000, ' milliseconds');
2875   writeln('addRecByType  : ', profAddRecByType div 1000, '.', profAddRecByType mod 1000, ' milliseconds');
2876   writeln('field valparse: ', profFieldValParsing div 1000, '.', profFieldValParsing mod 1000, ' milliseconds');
2877   writeln('fix defaults  : ', profFixDefaults div 1000, '.', profFixDefaults mod 1000, ' milliseconds');
2878   writeln('recvalparse   : ', profRecValParse div 1000, '.', profRecValParse mod 1000, ' milliseconds');
2879 end;
2880 {$ENDIF}
2881
2882
2883 procedure TDynRecord.parseValue (pr: TTextParser; beginEaten: Boolean=false);
2884 var
2885   fld: TDynField;
2886   rec: TDynRecord = nil;
2887   trc{, rv}: TDynRecord;
2888   {$IF DEFINED(D2D_DYNREC_PROFILER)}
2889   stt, stall: UInt64;
2890   {$ENDIF}
2891
2892   procedure linkNames (rec: TDynRecord);
2893   var
2894     fld: TDynField;
2895     rt: TDynRecord;
2896   begin
2897     //writeln('*** rec: ', rec.mName, '.', rec.mId, ' (', rec.mFields.count, ')');
2898     for fld in rec.mFields do
2899     begin
2900       if (fld.mType = TDynField.TType.TTrigData) then
2901       begin
2902         if (fld.mRecRef <> nil) then linkNames(fld.mRecRef);
2903         continue;
2904       end;
2905       if (Length(fld.mRecRefId) = 0) then continue;
2906       assert(fld.mEBSType <> nil);
2907       rt := findRecordByTypeId(fld.mEBSTypeName, fld.mRecRefId);
2908       if (rt = nil) then
2909       begin
2910         //e_LogWritefln('record of type ''%s'' with id ''%s'' links to inexistant record of type ''%s'' with id ''%s''', [rec.mName, rec.mId, fld.mEBSTypeName, fld.mRecRefId], MSG_WARNING);
2911         raise TDynParseException.CreateFmt(pr, 'record of type ''%s'' with id ''%s'' links to inexistant record of type ''%s'' with id ''%s''', [rec.mTypeName, rec.mId, fld.mEBSTypeName, fld.mRecRefId]);
2912       end;
2913       //writeln(' ', rec.mName, '.', rec.mId, ':', fld.mName, ' -> ', rt.mName, '.', rt.mId, ' (', fld.mEBSTypeName, '.', fld.mRecRefId, ')');
2914       fld.mRecRefId := '';
2915       fld.mRecRef := rt;
2916       fld.mDefined := true;
2917     end;
2918     for fld in rec.mFields do
2919     begin
2920       //writeln('  ', fld.mName);
2921       fld.fixDefaultValue(); // just in case
2922     end;
2923   end;
2924
2925 begin
2926   if (mOwner = nil) then raise TDynParseException.CreateFmt(pr, 'can''t parse record ''%s'' value without owner', [mTypeName]);
2927
2928   {$IF DEFINED(D2D_DYNREC_PROFILER)}stall := curTimeMicro();{$ENDIF}
2929
2930   // not a header?
2931   if not mHeader then
2932   begin
2933     // id?
2934     if (not beginEaten) and (pr.tokType = pr.TTId) then mId := pr.expectId();
2935   end
2936   else
2937   begin
2938     assert(mHeaderRec = self);
2939   end;
2940
2941   //writeln('parsing record <', mName, '>');
2942   if not beginEaten then pr.expectTT(pr.TTBegin);
2943   while (pr.tokType <> pr.TTEnd) do
2944   begin
2945     if (pr.tokType <> pr.TTId) then raise TDynParseException.Create(pr, 'identifier expected');
2946     //writeln('<', mName, '.', pr.tokStr, '>');
2947
2948     // records
2949     if mHeader then
2950     begin
2951       // add records with this type (if any)
2952       {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
2953       trc := mOwner.recType[pr.tokStr];
2954       {$IF DEFINED(D2D_DYNREC_PROFILER)}profFindRecType := curTimeMicro()-stt;{$ENDIF}
2955       if (trc <> nil) then
2956       begin
2957         {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
2958         rec := trc.clone(mHeaderRec);
2959         {$IF DEFINED(D2D_DYNREC_PROFILER)}profCloneRec := curTimeMicro()-stt;{$ENDIF}
2960         rec.mHeaderRec := mHeaderRec;
2961         // on error, it will be freed by memowner
2962         pr.skipToken();
2963         rec.parseValue(pr);
2964         {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
2965         addRecordByType(rec.mTypeName, rec);
2966         {$IF DEFINED(D2D_DYNREC_PROFILER)}profAddRecByType := curTimeMicro()-stt;{$ENDIF}
2967         continue;
2968       end;
2969     end;
2970
2971     // fields
2972     {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
2973     //writeln('0: <', mName, '.', pr.tokStr, '>');
2974     fld := field[pr.tokStr];
2975     //writeln('1: <', mName, '.', pr.tokStr, '>');
2976     {$IF DEFINED(D2D_DYNREC_PROFILER)}profFieldSearching := curTimeMicro()-stt;{$ENDIF}
2977     if (fld <> nil) then
2978     begin
2979       //writeln('2: <', mName, '.', pr.tokStr, '>');
2980       if fld.defined then raise TDynParseException.CreateFmt(pr, 'duplicate field ''%s'' in record ''%s''', [fld.mName, mTypeName]);
2981       if fld.internal then raise TDynParseException.CreateFmt(pr, 'internal field ''%s'' in record ''%s''', [fld.mName, mTypeName]);
2982       pr.skipToken(); // skip field name
2983       //writeln('3: <', mName, '.', pr.tokStr, '>:', pr.tokType);
2984       {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
2985       fld.parseValue(pr);
2986       {$IF DEFINED(D2D_DYNREC_PROFILER)}profFieldValParsing := curTimeMicro()-stt;{$ENDIF}
2987       continue;
2988     end;
2989
2990     // something is wrong
2991     raise TDynParseException.CreateFmt(pr, 'unknown field ''%s'' in record ''%s''', [pr.tokStr, mTypeName]);
2992   end;
2993   pr.expectTT(pr.TTEnd);
2994
2995   if mHeader then
2996   begin
2997     // link fields
2998     for fld in mFields do
2999     begin
3000       if (fld.mType <> TDynField.TType.TList) then continue;
3001       for rec in fld.mRVal do linkNames(rec);
3002     end;
3003   end;
3004
3005   // fix field defaults
3006   {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
3007   for fld in mFields do fld.fixDefaultValue();
3008   {$IF DEFINED(D2D_DYNREC_PROFILER)}profFixDefaults := curTimeMicro()-stt;{$ENDIF}
3009   //writeln('done parsing record <', mName, '>');
3010   //{$IF DEFINED(D2D_DYNREC_PROFILER)}writeln('stall: ', curTimeMicro()-stall);{$ENDIF}
3011   {$IF DEFINED(D2D_DYNREC_PROFILER)}profRecValParse := curTimeMicro()-stall;{$ENDIF}
3012 end;
3013
3014
3015 // ////////////////////////////////////////////////////////////////////////// //
3016 constructor TDynEBS.Create (pr: TTextParser);
3017 begin
3018   cleanup();
3019   parseDef(pr);
3020 end;
3021
3022
3023 destructor TDynEBS.Destroy ();
3024 begin
3025   cleanup();
3026   inherited;
3027 end;
3028
3029
3030 procedure TDynEBS.cleanup ();
3031 begin
3032   mIsEnum := false;
3033   mTypeName := '';
3034   mIds := nil;
3035   mVals := nil;
3036   mMaxName := '';
3037   mMaxVal := 0;
3038 end;
3039
3040
3041 function TDynEBS.findByName (const aname: AnsiString): Integer;
3042 begin
3043   result := 0;
3044   while (result < Length(mIds)) do
3045   begin
3046     if StrEqu(aname, mIds[result]) then exit;
3047     Inc(result);
3048   end;
3049   result := -1;
3050 end;
3051
3052
3053 function TDynEBS.hasByName (const aname: AnsiString): Boolean; inline;
3054 begin
3055   result := (findByName(aname) >= 0);
3056 end;
3057
3058
3059 function TDynEBS.getFieldByName (const aname: AnsiString): Integer; inline;
3060 var
3061   f: Integer;
3062 begin
3063   f := findByName(aname);
3064   if (f >= 0) then result := mVals[f] else result := 0;
3065 end;
3066
3067
3068 function TDynEBS.definition (): AnsiString;
3069 var
3070   f, cv: Integer;
3071 begin
3072   if mIsEnum then result :='enum ' else result := 'bitset ';
3073   result += mTypeName;
3074   result += ' {'#10;
3075   // fields
3076   if mIsEnum then cv := 0 else cv := 1;
3077   for f := 0 to High(mIds) do
3078   begin
3079     if (mIds[f] = mMaxName) then continue;
3080     result += '  '+mIds[f];
3081     if (mVals[f] <> cv) then
3082     begin
3083       result += Format(' = %d', [mVals[f]]);
3084       if mIsEnum then cv := mVals[f];
3085       result += ','#10;
3086     end
3087     else
3088     begin
3089       result += Format(', // %d'#10, [mVals[f]]);
3090     end;
3091     if mIsEnum then Inc(cv) else if (mVals[f] = cv) then cv := cv shl 1;
3092   end;
3093   // max field
3094   if (Length(mMaxName) > 0) then result += '  '+mMaxName+' = MAX,'#10;
3095   result += '}';
3096 end;
3097
3098
3099 function TDynEBS.pasdef (): AnsiString;
3100 var
3101   f: Integer;
3102 begin
3103   result := '// '+mTypeName+#10'const'#10;
3104   // fields
3105   for f := 0 to High(mIds) do
3106   begin
3107     result += formatstrf('  %s = %d;'#10, [mIds[f], mVals[f]]);
3108   end;
3109 end;
3110
3111
3112 function TDynEBS.nameByValue (v: Integer): AnsiString;
3113 var
3114   f: Integer;
3115 begin
3116   for f := 0 to High(mVals) do
3117   begin
3118     if (mVals[f] = v) then begin result := mIds[f]; exit; end;
3119   end;
3120   result := '';
3121 end;
3122
3123
3124 procedure TDynEBS.parseDef (pr: TTextParser);
3125 var
3126   idname: AnsiString;
3127   cv, v: Integer;
3128   f: Integer;
3129   skipAdd: Boolean;
3130   hasV: Boolean;
3131 begin
3132        if pr.eatId('enum') then mIsEnum := true
3133   else if pr.eatId('bitset') then mIsEnum := false
3134   else pr.expectId('enum');
3135   mTypeName := pr.expectId();
3136   mMaxVal := Integer($80000000);
3137   if mIsEnum then cv := 0 else cv := 1;
3138   pr.expectTT(pr.TTBegin);
3139   while (pr.tokType <> pr.TTEnd) do
3140   begin
3141     idname := pr.expectId();
3142     for f := 0 to High(mIds) do
3143     begin
3144       if StrEqu(mIds[f], idname) then raise TDynParseException.CreateFmt(pr, 'duplicate field ''%s'' in enum/bitset ''%s''', [idname, mTypeName]);
3145     end;
3146     if StrEqu(mMaxName, idname) then raise TDynParseException.CreateFmt(pr, 'duplicate field ''%s'' in enum/bitset ''%s''', [idname, mTypeName]);
3147     skipAdd := false;
3148     hasV := false;
3149     v := cv;
3150     // has value?
3151     if pr.eatDelim('=') then
3152     begin
3153       if pr.eatId('MAX') then
3154       begin
3155         if (Length(mMaxName) > 0) then raise TDynParseException.CreateFmt(pr, 'duplicate max field ''%s'' in enum/bitset ''%s''', [idname, mTypeName]);
3156         mMaxName := idname;
3157         skipAdd := true;
3158       end
3159       else
3160       begin
3161         v := pr.expectInt();
3162           if mIsEnum then cv := v;
3163         hasV := true;
3164       end;
3165     end;
3166     // append it?
3167     if not skipAdd then
3168     begin
3169       // fix maxvalue
3170       if mIsEnum or (not hasV) then
3171       begin
3172         if (mMaxVal < v) then mMaxVal := v;
3173       end;
3174       SetLength(mIds, Length(mIds)+1);
3175       mIds[High(mIds)] := idname;
3176       SetLength(mVals, Length(mIds));
3177       mVals[High(mVals)] := v;
3178       // next cv
3179       if mIsEnum or (not hasV) then
3180       begin
3181         if mIsEnum then Inc(cv) else cv := cv shl 1;
3182       end;
3183     end;
3184     if (pr.tokType = pr.TTEnd) then break;
3185     pr.expectTT(pr.TTComma);
3186     while pr.eatTT(pr.TTComma) do begin end;
3187   end;
3188   pr.expectTT(pr.TTEnd);
3189   // add max field
3190   if (Length(mMaxName) > 0) then
3191   begin
3192     SetLength(mIds, Length(mIds)+1);
3193     mIds[High(mIds)] := mMaxName;
3194     SetLength(mVals, Length(mIds));
3195     mVals[High(mVals)] := mMaxVal;
3196   end;
3197 end;
3198
3199
3200 // ////////////////////////////////////////////////////////////////////////// //
3201 constructor TDynMapDef.Create (pr: TTextParser);
3202 begin
3203   recTypes := TDynRecList.Create();
3204   trigTypes := TDynRecList.Create();
3205   ebsTypes := TDynEBSList.Create();
3206   parseDef(pr);
3207 end;
3208
3209
3210 destructor TDynMapDef.Destroy ();
3211 var
3212   rec: TDynRecord;
3213   ebs: TDynEBS;
3214 begin
3215   //!!!FIXME!!! check who owns trigs and recs!
3216   for rec in recTypes do rec.Free();
3217   for rec in trigTypes do rec.Free();
3218   for ebs in ebsTypes do ebs.Free();
3219   recTypes.Free();
3220   trigTypes.Free();
3221   ebsTypes.Free();
3222   recTypes := nil;
3223   trigTypes := nil;
3224   ebsTypes := nil;
3225   inherited;
3226 end;
3227
3228
3229 function TDynMapDef.getHeaderRecType (): TDynRecord; inline;
3230 begin
3231   if (recTypes.count = 0) then raise TDynRecException.Create('no header in empty mapdef');
3232   result := recTypes[0];
3233 end;
3234
3235
3236 function TDynMapDef.findRecType (const aname: AnsiString): TDynRecord;
3237 var
3238   rec: TDynRecord;
3239 begin
3240   for rec in recTypes do
3241   begin
3242     if StrEqu(rec.typeName, aname) then begin result := rec; exit; end;
3243   end;
3244   result := nil;
3245 end;
3246
3247
3248 function TDynMapDef.findTrigFor (const aname: AnsiString): TDynRecord;
3249 var
3250   rec: TDynRecord;
3251 begin
3252   for rec in trigTypes do
3253   begin
3254     if (rec.isForTrig[aname]) then begin result := rec; exit; end;
3255   end;
3256   result := nil;
3257 end;
3258
3259
3260 function TDynMapDef.findEBSType (const aname: AnsiString): TDynEBS;
3261 var
3262   ebs: TDynEBS;
3263 begin
3264   for ebs in ebsTypes do
3265   begin
3266     if StrEqu(ebs.typeName, aname) then begin result := ebs; exit; end;
3267   end;
3268   result := nil;
3269 end;
3270
3271
3272 procedure TDynMapDef.parseDef (pr: TTextParser);
3273 var
3274   rec, hdr: TDynRecord;
3275   eb: TDynEBS;
3276   f: Integer;
3277
3278   // setup header links and type links
3279   procedure linkRecord (rec: TDynRecord);
3280   var
3281     fld: TDynField;
3282   begin
3283     rec.mHeaderRec := recTypes[0];
3284     for fld in rec.mFields do
3285     begin
3286       if (fld.mType = fld.TType.TTrigData) then continue;
3287       case fld.mEBS of
3288         TDynField.TEBS.TNone: begin end;
3289         TDynField.TEBS.TRec:
3290           begin
3291             fld.mEBSType := findRecType(fld.mEBSTypeName);
3292             if (fld.mEBSType = nil) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' has no correcponding record definition', [fld.mName, fld.mEBSTypeName]);
3293           end;
3294         TDynField.TEBS.TEnum,
3295         TDynField.TEBS.TBitSet:
3296           begin
3297             fld.mEBSType := findEBSType(fld.mEBSTypeName);
3298             if (fld.mEBSType = nil) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' has no correcponding enum/bitset', [fld.mName, fld.mEBSTypeName]);
3299             if ((fld.mEBS = TDynField.TEBS.TEnum) <> (fld.mEBSType as TDynEBS).mIsEnum) then raise TDynParseException.CreateFmt(pr, 'field ''%s'' of type ''%s'' enum/bitset type conflict', [fld.mName, fld.mEBSTypeName]);
3300           end;
3301       end;
3302     end;
3303   end;
3304
3305   // setup default values
3306   procedure fixRecordDefaults (rec: TDynRecord);
3307   var
3308     fld: TDynField;
3309   begin
3310     for fld in rec.mFields do if fld.mHasDefault then fld.parseDefaultValue();
3311   end;
3312
3313 begin
3314   hdr := nil;
3315   while true do
3316   begin
3317     if not pr.skipBlanks() then break;
3318
3319     if (pr.tokType = pr.TTId) then
3320     begin
3321       // enum or bitset
3322       if (pr.tokStr = 'enum') or (pr.tokStr = 'bitset') then
3323       begin
3324         eb := TDynEBS.Create(pr);
3325         if (findEBSType(eb.typeName) <> nil) then
3326         begin
3327           eb.Free();
3328           raise TDynParseException.CreateFmt(pr, 'duplicate enum/bitset ''%s''', [eb.typeName]);
3329         end;
3330         eb.mOwner := self;
3331         ebsTypes.append(eb);
3332         //writeln(eb.definition); writeln;
3333         continue;
3334       end;
3335
3336       // triggerdata
3337       if (pr.tokStr = 'TriggerData') then
3338       begin
3339         rec := TDynRecord.Create(pr);
3340         for f := 0 to High(rec.mTrigTypes) do
3341         begin
3342           if (findTrigFor(rec.mTrigTypes[f]) <> nil) then
3343           begin
3344             rec.Free();
3345             raise TDynParseException.CreateFmt(pr, 'duplicate trigdata ''%s''', [rec.mTrigTypes[f]]);
3346           end;
3347         end;
3348         rec.mOwner := self;
3349         trigTypes.append(rec);
3350         //writeln(dr.definition); writeln;
3351         continue;
3352       end;
3353     end;
3354
3355     rec := TDynRecord.Create(pr);
3356     //writeln(dr.definition); writeln;
3357     if (findRecType(rec.typeName) <> nil) then begin rec.Free(); raise TDynParseException.CreateFmt(pr, 'duplicate record ''%s''', [rec.typeName]); end;
3358     if (hdr <> nil) and StrEqu(rec.typeName, hdr.typeName) then begin rec.Free(); raise TDynParseException.CreateFmt(pr, 'duplicate record ''%s''', [rec.typeName]); end;
3359     rec.mOwner := self;
3360     if rec.mHeader then
3361     begin
3362       if (hdr <> nil) then begin rec.Free(); raise TDynParseException.CreateFmt(pr, 'duplicate header record ''%s'' (previous is ''%s'')', [rec.typeName, hdr.typeName]); end;
3363       hdr := rec;
3364     end
3365     else
3366     begin
3367       recTypes.append(rec);
3368     end;
3369   end;
3370
3371   // put header record to top
3372   if (hdr = nil) then raise TDynParseException.Create(pr, 'header definition not found in mapdef');
3373   recTypes.append(nil);
3374   for f := recTypes.count-1 downto 1 do recTypes[f] := recTypes[f-1];
3375   recTypes[0] := hdr;
3376
3377   // setup header links and type links
3378   for rec in recTypes do linkRecord(rec);
3379   for rec in trigTypes do linkRecord(rec);
3380
3381   // setup default values
3382   for rec in recTypes do fixRecordDefaults(rec);
3383   for rec in trigTypes do fixRecordDefaults(rec);
3384 end;
3385
3386
3387 // ////////////////////////////////////////////////////////////////////////// //
3388 function TDynMapDef.parseTextMap (pr: TTextParser): TDynRecord;
3389 var
3390   res: TDynRecord = nil;
3391 begin
3392   result := nil;
3393   try
3394     pr.expectId(headerType.typeName);
3395     res := headerType.clone(nil);
3396     res.mHeaderRec := res;
3397     res.parseValue(pr);
3398     result := res;
3399     res := nil;
3400   finally
3401     res.Free();
3402   end;
3403 end;
3404
3405
3406 function TDynMapDef.parseBinMap (st: TStream): TDynRecord;
3407 var
3408   res: TDynRecord = nil;
3409 begin
3410   result := nil;
3411   try
3412     res := headerType.clone(nil);
3413     res.mHeaderRec := res;
3414     res.parseBinValue(st);
3415     result := res;
3416     res := nil;
3417   finally
3418     res.Free();
3419   end;
3420 end;
3421
3422
3423 // WARNING! stream must be seekable
3424 function TDynMapDef.parseMap (st: TStream; wasBinary: PBoolean=nil): TDynRecord;
3425 var
3426   sign: packed array[0..3] of AnsiChar;
3427   pr: TTextParser;
3428 begin
3429   if (wasBinary <> nil) then wasBinary^ := false;
3430   st.position := 0;
3431   st.ReadBuffer(sign[0], 4);
3432   st.position := 0;
3433   if (sign[0] = 'M') and (sign[1] = 'A') and (sign[2] = 'P') then
3434   begin
3435     if (sign[3] = #1) then
3436     begin
3437       if (wasBinary <> nil) then wasBinary^ := true;
3438       result := parseBinMap(st);
3439       exit;
3440     end;
3441     raise TDynRecException.Create('invalid binary map version');
3442   end
3443   else
3444   begin
3445     pr := TFileTextParser.Create(st, false); // `st` is not owned
3446     try
3447       try
3448         result := parseTextMap(pr);
3449       except on e: Exception do
3450         raise TDynParseException.Create(pr, e.message);
3451       end;
3452     finally
3453       pr.Free();
3454     end;
3455   end;
3456 end;
3457
3458
3459 // returns `true` if the given stream can be a map file
3460 // stream position is 0 on return
3461 // WARNING! stream must be seekable
3462 class function TDynMapDef.canBeMap (st: TStream): Boolean;
3463 var
3464   sign: packed array[0..3] of AnsiChar;
3465   pr: TTextParser;
3466 begin
3467   result := false;
3468   st.position := 0;
3469   st.ReadBuffer(sign[0], 4);
3470   if (sign[0] = 'M') and (sign[1] = 'A') and (sign[2] = 'P') then
3471   begin
3472     result := (sign[3] = #1);
3473   end
3474   else
3475   begin
3476     st.position := 0;
3477     pr := TFileTextParser.Create(st, false); // `st` is not owned
3478     result := (pr.tokType = pr.TTId) and (pr.tokStr = 'map');
3479     pr.Free();
3480   end;
3481   st.position := 0;
3482 end;
3483
3484
3485 function TDynMapDef.pasdefconst (): AnsiString;
3486 var
3487   ebs: TDynEBS;
3488 begin
3489   result := '';
3490   result += '// ////////////////////////////////////////////////////////////////////////// //'#10;
3491   result += '// enums and bitsets'#10;
3492   for ebs in ebsTypes do result += #10+ebs.pasdef();
3493 end;
3494
3495
3496 function TDynMapDef.getRecTypeCount (): Integer; inline; begin result := recTypes.count; end;
3497 function TDynMapDef.getRecTypeAt (idx: Integer): TDynRecord; inline; begin if (idx >= 0) and (idx < recTypes.count) then result := recTypes[idx] else result := nil; end;
3498
3499 function TDynMapDef.getEBSTypeCount (): Integer; inline; begin result := ebsTypes.count; end;
3500 function TDynMapDef.getEBSTypeAt (idx: Integer): TDynEBS; inline; begin if (idx >= 0) and (idx < ebsTypes.count) then result := ebsTypes[idx] else result := nil; end;
3501
3502 function TDynMapDef.getTrigTypeCount (): Integer; inline; begin result := trigTypes.count; end;
3503 function TDynMapDef.getTrigTypeAt (idx: Integer): TDynRecord; inline; begin if (idx >= 0) and (idx < trigTypes.count) then result := trigTypes[idx] else result := nil; end;
3504
3505
3506 end.