X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fshared%2Fxdynrec.pas;h=f129dd035af96a9b8c12f84feec6bf58a35349b8;hb=6d6df4e3427cd01e03e172984c9d0d391ff38032;hp=2d8f430e961b42869074883a327fb405fa8e0f90;hpb=27db2871c8507404a1957487d66d037e0bbc81da;p=d2df-sdl.git

diff --git a/src/shared/xdynrec.pas b/src/shared/xdynrec.pas
index 2d8f430..f129dd0 100644
--- a/src/shared/xdynrec.pas
+++ b/src/shared/xdynrec.pas
@@ -20,29 +20,31 @@ interface
 
 uses
   Classes,
-  xparser, xstreams;
+  xparser, xstreams, utils;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
 type
   TDynMapDef = class;
   TDynRecord = class;
+  TDynField = class;
+  TDynEBS = class;
+
+  TDynFieldList = specialize TSimpleList<TDynField>;
+  TDynRecList = specialize TSimpleList<TDynRecord>;
+  TDynEBSList = specialize TSimpleList<TDynEBS>;
 
   // this is base type for all scalars (and arrays)
   TDynField = class
   public
     type
       TType = (TBool, TChar, TByte, TUByte, TShort, TUShort, TInt, TUInt, TString, TPoint, TSize, TList, TTrigData);
-      // TPoint: pair of Shorts
+      // TPoint: pair of Integers
       // TSize: pair of UShorts
       // TList: actually, array of records
-      // TTrigData: array of bytes
+      // TTrigData: array of mMaxDim bytes, but internally a record (mRecRef)
       // arrays of chars are pascal shortstrings (with counter in the first byte)
 
-    type
-      TDynFieldArray = array of TDynField;
-      TDynRecordArray = array of TDynRecord;
-
   private
     type
       TEBS = (TNone, TRec, TEnum, TBitSet);
@@ -55,34 +57,38 @@ type
     mIVal: Integer; // for all integer types
     mIVal2: Integer; // for point and size
     mSVal: AnsiString; // string; for byte and char arrays
-    mRVal: TDynRecordArray; // for list
-    mRecRef: TDynRecord; // for record
-    mMaxDim: Integer; // for byte and char arrays; <0: not an array
+    mRVal: TDynRecList; // for list
+    mRecRef: TDynRecord; // for TEBS.TRec
+    mMaxDim: Integer; // for byte and char arrays; <0: not an array; 0: impossible value
     mBinOfs: Integer; // offset in binary; <0 - none
     mRecOfs: Integer; // offset in record; <0 - none
     mSepPosSize: Boolean; // for points and sizes, use separate fields
     mAsT: Boolean; // for points and sizes, use separate fields, names starts with `t`
     mDefined: Boolean;
     mHasDefault: Boolean;
-    mDefaultValueSet: Boolean;
     mOmitDef: Boolean;
     mInternal: Boolean;
-    // default values
-    mDefSVal: AnsiString;
-    mEBS: TEBS;
-    mEBSTypeName: AnsiString; // name of enum, bitset or record
-    mBitSetUnique: Boolean; // bitset can contain only one value
     mNegBool: Boolean;
+    mBitSetUnique: Boolean; // bitset can contain only one value
+    // default value
+    mDefUnparsed: AnsiString;
+    mDefSVal: AnsiString; // default string value
+    mDefIVal, mDefIVal2: Integer; // default integer values
+    mDefRecRef: TDynRecord;
+    mEBS: TEBS; // complex type type
+    mEBSTypeName: AnsiString; // name of enum, bitset or record
+    mEBSType: TObject; // either TDynRecord or TDynEBS; nil means "simple type"; nil for `TTrigData` too
 
-    // temp
-    mDefId: AnsiString;
+    // for binary parser
+    mRecRefId: AnsiString;
 
   private
     procedure cleanup ();
 
     procedure parseDef (pr: TTextParser);
 
-    procedure fixDefaultValue ();
+    procedure parseDefaultValue (); // parse `mDefUnparsed` to `mDefSVal`, `mDefIVal`, `mDefIVal2`, `mDefRecRef`
+    procedure fixDefaultValue (); // this will NOT clone `mDefRecRef`
     function isDefaultValue (): Boolean;
 
   public
@@ -93,34 +99,35 @@ type
     class function getTypeName (t: TType): AnsiString;
 
     function definition (): AnsiString;
+    function pasdef (): AnsiString;
 
-    function clone (): TDynField;
+    function clone (newOwner: TDynRecord=nil): TDynField;
 
-    procedure parseValue (pr: TTextParser; curheader: TDynRecord);
+    procedure parseValue (pr: TTextParser);
     procedure parseBinValue (st: TStream);
 
     procedure writeTo (wr: TTextWriter);
-    procedure writeBinTo (st: TStream; curheader: TDynRecord);
+    procedure writeBinTo (st: TStream);
 
     // won't work for lists
     function isSimpleEqu (fld: TDynField): Boolean;
 
+    procedure setValue (const s: AnsiString);
+
   public
     property pasname: AnsiString read mPasName;
     property name: AnsiString read mName;
     property baseType: TType read mType;
     property defined: Boolean read mDefined write mDefined;
     property internal: Boolean read mInternal write mInternal;
-    //property ival: Integer read mIVal write setIVal;
-    //property sval: AnsiString read mSVal write setSVal;
-    property list: TDynRecordArray read mRVal write mRVal;
-    property maxdim: Integer read mMaxDim; // for fixed-size arrays
-    property binOfs: Integer read mBinOfs; // offset in binary; <0 - none
-    property recOfs: Integer read mRecOfs; // offset in record; <0 - none
+    property ival: Integer read mIVal;
+    property sval: AnsiString read mSVal;
     property hasDefault: Boolean read mHasDefault;
-    property defsval: AnsiString read mDefSVal write mDefSVal;
-    property ebstype: TEBS read mEBS write mEBS;
-    property ebstypename: AnsiString read mEBSTypeName write mEBSTypeName; // enum/bitset name
+    property defsval: AnsiString read mDefSVal;
+    property ebs: TEBS read mEBS;
+    property ebstype: TObject read mEBSType;
+    property ebstypename: AnsiString read mEBSTypeName; // enum/bitset name
+    property list: TDynRecList read mRVal; // for list
 
     property x: Integer read mIVal;
     property w: Integer read mIVal;
@@ -129,6 +136,7 @@ type
   end;
 
 
+  // "value" header record contains TList fields, with name equal to record type
   TDynRecord = class
   private
     mOwner: TDynMapDef;
@@ -136,10 +144,11 @@ type
     mPasName: AnsiString;
     mName: AnsiString;
     mSize: Integer;
-    mFields: TDynField.TDynFieldArray;
+    mFields: TDynFieldList;
     mTrigTypes: array of AnsiString; // if this is triggerdata, we'll hold list of triggers here
     mHeader: Boolean; // true for header record
     mBinBlock: Integer; // -1: none
+    mHeaderRec: TDynRecord; // for "value" records this is header record with data, for "type" records this is header type record
 
   private
     procedure parseDef (pr: TTextParser); // parse definition
@@ -151,34 +160,49 @@ type
     function getIsTrigData (): Boolean; inline;
     function getIsForTrig (const aname: AnsiString): Boolean; inline;
 
+  protected
+    function findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
+    function findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
+    procedure addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+
   public
     constructor Create ();
     constructor Create (pr: TTextParser); // parse definition
     destructor Destroy (); override;
 
     function definition (): AnsiString;
+    function pasdef (): AnsiString;
 
     function clone (): TDynRecord;
 
-    procedure parseValue (pr: TTextParser; curheader: TDynRecord);
-    procedure parseBinValue (st: TStream);
+    function isSimpleEqu (rec: TDynRecord): Boolean;
+
+    procedure parseValue (pr: TTextParser; beginEaten: Boolean=false);
+    procedure parseBinValue (st: TStream; forceData: Boolean=false);
 
     procedure writeTo (wr: TTextWriter; putHeader: Boolean=true);
-    procedure writeBinTo (st: TStream; curheader: TDynRecord; trigbufsz: Integer=-1);
+    procedure writeBinTo (st: TStream; trigbufsz: Integer=-1; onlyFields: Boolean=false);
+
+    // find field with `TriggerType` type
+    function trigTypeField (): TDynField;
+
+    // number of records of the given instance
+    function instanceCount (const typename: AnsiString): Integer;
 
   public
     property id: AnsiString read mId; // for map parser
     property pasname: AnsiString read mPasName;
     property name: AnsiString read mName; // record name
     property size: Integer read mSize; // size in bytes
-    property fields: TDynField.TDynFieldArray read mFields write mFields;
+    property fields: TDynFieldList read mFields;
     property has[const aname: AnsiString]: Boolean read hasByName;
     property field[const aname: AnsiString]: TDynField read getFieldByName;
     property isTrigData: Boolean read getIsTrigData;
     property isForTrig[const aname: AnsiString]: Boolean read getIsForTrig;
+    property headerType: TDynRecord read mHeaderRec;
+    property isHeader: Boolean read mHeader;
   end;
 
-
   TDynEBS = class
   private
     mOwner: TDynMapDef;
@@ -203,6 +227,10 @@ type
     destructor Destroy (); override;
 
     function definition (): AnsiString;
+    function pasdef (): AnsiString;
+
+    // return empty string if not found
+    function nameByValue (v: Integer): AnsiString;
 
   public
     property name: AnsiString read mName; // record name
@@ -213,15 +241,10 @@ type
 
 
   TDynMapDef = class
-  private
-    procedure addRecordByType (const atypename: AnsiString; rc: TDynRecord; curheader: TDynRecord);
-    function findRecordByTypeId (const atypename, aid: AnsiString; curheader: TDynRecord): TDynRecord;
-    function findRecordNumByType (const atypename: AnsiString; rc: TDynRecord; curheader: TDynRecord): Integer;
-
   public
-    recTypes: array of TDynRecord; // [0] is always header
-    trigTypes: array of TDynRecord; // trigdata
-    ebsTypes: array of TDynEBS; // enums, bitsets
+    recTypes: TDynRecList; // [0] is always header
+    trigTypes: TDynRecList; // trigdata
+    ebsTypes: TDynEBSList; // enums, bitsets
 
   private
     procedure parseDef (pr: TTextParser);
@@ -236,6 +259,8 @@ type
     function findTrigFor (const aname: AnsiString): TDynRecord;
     function findEBSType (const aname: AnsiString): TDynEBS;
 
+    function pasdef (): AnsiString;
+
     // creates new header record
     function parseMap (pr: TTextParser): TDynRecord;
 
@@ -250,8 +275,11 @@ type
 implementation
 
 uses
-  SysUtils,
-  utils;
+  SysUtils;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+function StrEqu (const a, b: AnsiString): Boolean; inline; begin result := (a = b); end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
@@ -262,6 +290,7 @@ begin
   cleanup();
   mName := aname;
   mType := atype;
+  if (mType = TType.TList) then mRVal := TDynRecList.Create();
 end;
 
 
@@ -286,6 +315,7 @@ begin
   mIVal := 0;
   mIVal2 := 0;
   mSVal := '';
+  mRVal.Free();
   mRVal := nil;
   mRecRef := nil;
   mMaxDim := -1;
@@ -297,30 +327,43 @@ begin
   mDefined := false;
   mOmitDef := false;
   mInternal := true;
+  mDefUnparsed := '';
   mDefSVal := '';
+  mDefIVal := 0;
+  mDefIVal2 := 0;
+  mDefRecRef := nil;
   mEBS := TEBS.TNone;
   mEBSTypeName := '';
+  mEBSType := nil;
   mBitSetUnique := false;
   mNegBool := false;
-  mDefId := '';
-  mDefaultValueSet := false;
+  mRecRefId := '';
+  if (mType = TType.TList) then mRVal := TDynRecList.Create();
 end;
 
 
-function TDynField.clone (): TDynField;
+function TDynField.clone (newOwner: TDynRecord=nil): TDynField;
 var
-  f: Integer;
+  rec: TDynRecord;
 begin
   result := TDynField.Create(mName, mType);
   result.mOwner := mOwner;
+  if (newOwner <> nil) then result.mOwner := newOwner else result.mOwner := mOwner;
   result.mPasName := mPasName;
   result.mName := mName;
   result.mType := mType;
   result.mIVal := mIVal;
   result.mIVal2 := mIVal2;
   result.mSVal := mSVal;
-  SetLength(result.mRVal, Length(mRVal));
-  for f := 0 to High(mRVal) do result.mRVal[f] := mRVal[f].clone();
+  if (mRVal <> nil) then
+  begin
+    result.mRVal := TDynRecList.Create(mRVal.count);
+    for rec in mRVal do result.mRVal.append(rec.clone());
+  end
+  else
+  begin
+    if (mType = TType.TList) then result.mRVal := TDynRecList.Create() else result.mRVal := nil;
+  end;
   result.mRecRef := mRecRef;
   result.mMaxDim := mMaxDim;
   result.mBinOfs := mBinOfs;
@@ -331,13 +374,17 @@ begin
   result.mHasDefault := mHasDefault;
   result.mOmitDef := mOmitDef;
   result.mInternal := mInternal;
+  result.mNegBool := mNegBool;
+  result.mBitSetUnique := mBitSetUnique;
+  result.mDefUnparsed := mDefUnparsed;
   result.mDefSVal := mDefSVal;
+  result.mDefIVal := mDefIVal;
+  result.mDefIVal2 := mDefIVal2;
+  result.mDefRecRef := mDefRecRef;
   result.mEBS := mEBS;
   result.mEBSTypeName := mEBSTypeName;
-  result.mBitSetUnique := mBitSetUnique;
-  result.mNegBool := mNegBool;
-  result.mDefId := mDefId;
-  result.mDefaultValueSet := mDefaultValueSet;
+  result.mEBSType := mEBSType;
+  result.mRecRefId := mRecRefId;
 end;
 
 
@@ -360,75 +407,97 @@ begin
     TType.TSize:
       result := ((mIVal = fld.mIVal) and (mIVal2 = fld.mIVal2));
     TType.TList: result := false;
-    TType.TTrigData: result := false;
+    TType.TTrigData:
+      begin
+        if (mRecRef = nil) then begin result := (fld.mRecRef = nil); exit; end;
+        result := mRecRef.isSimpleEqu(fld.mRecRef);
+      end;
     else raise Exception.Create('ketmar forgot to handle some field type');
   end;
 end;
 
 
-procedure TDynField.fixDefaultValue ();
+procedure TDynField.setValue (const s: AnsiString);
 var
   stp: TTextParser;
-  s: AnsiString;
 begin
-  if not mDefined then
+  stp := TStrTextParser.Create(s+';');
+  try
+    parseValue(stp);
+  finally
+    stp.Free();
+  end;
+end;
+
+
+procedure TDynField.parseDefaultValue ();
+var
+  stp: TTextParser = nil;
+  oSVal: AnsiString;
+  oIVal, oIVal2: Integer;
+  oRRef: TDynRecord;
+  oDef: Boolean;
+begin
+  if not mHasDefault then
   begin
-    if not mHasDefault then
-    begin
-      if mInternal then exit;
-      raise Exception.Create(Format('field ''%s'' in record ''%s'' of record type ''%s'' is not set', [mName, mOwner.mId, mOwner.mName]));
-    end;
-    if (mEBS = TEBS.TRec) then
-    begin
-      if (CompareText(mDefSVal, 'null') <> 0) then raise Exception.Create(Format('field ''%s'' in record ''%s'' of record type ''%s'' has non-null default value ''%s''', [mName, mOwner.mId, mOwner.mName, mDefSVal]));
-      mDefined := true;
-      assert(mRecRef = nil);
-      mDefaultValueSet := true;
-      exit;
-    end;
-    s := '';
-    case mType of
-      TType.TChar, TType.TString: s := TTextParser.quote(mDefSVal)+';';
-      TType.TPoint, TType.TSize: assert(false); // no default values for these types yet
-      else s := mDefSVal+';';
-    end;
-    //mDefined := true;
-    //writeln('DEFAULT for <', mName, '>: <', s, '>');
-    stp := TStrTextParser.Create(s);
+    mDefSVal := '';
+    mDefIVal := 0;
+    mDefIVal2 := 0;
+    mDefRecRef := nil;
+  end
+  else
+  begin
+    oSVal := mSVal;
+    oIVal := mIVal;
+    oIVal2 := mIVal2;
+    oRRef := mRecRef;
+    oDef := mDefined;
     try
-      parseValue(stp, nil);
+      stp := TStrTextParser.Create(mDefUnparsed+';');
+      parseValue(stp);
+      mDefSVal := mSVal;
+      mDefIVal := mIVal;
+      mDefIVal2 := mIVal2;
+      mDefRecRef := mRecRef;
     finally
+      mSVal := oSVal;
+      mIVal := oIVal;
+      mIVal2 := oIVal2;
+      mRecRef := oRRef;
+      mDefined := oDef;
       stp.Free();
     end;
-    assert(mDefined);
-    mDefaultValueSet := true;
   end;
 end;
 
 
+// default value should be parsed
+procedure TDynField.fixDefaultValue ();
+begin
+  if mDefined then exit;
+  if not mHasDefault then
+  begin
+    if mInternal then exit;
+    raise Exception.Create(Format('field ''%s'' in record ''%s'' of record type ''%s'' is not set', [mName, mOwner.mId, mOwner.mName]));
+  end;
+  if (mEBS = TEBS.TRec) then mRecRef := mDefRecRef;
+  mSVal := mDefSVal;
+  mIVal := mDefIVal;
+  mIVal2 := mDefIVal2;
+  mDefined := true;
+end;
+
+
+// default value should be parsed
 function TDynField.isDefaultValue (): Boolean;
-var
-  fld: TDynField = nil;
-  stp: TTextParser = nil;
-  s: AnsiString;
 begin
   if not mHasDefault then begin result := false; exit; end;
-  //result := mDefaultValueSet;
-  if (mEBS = TEBS.TRec) then begin result := (mRecRef = nil); exit; end;
-  s := '';
+  if (mEBS = TEBS.TRec) then begin result := (mRecRef = mDefRecRef); exit; end;
   case mType of
-    TType.TChar, TType.TString: s := TTextParser.quote(mDefSVal)+';';
-    TType.TPoint, TType.TSize: begin result := false; exit; end; // no default values for these types yet
-    else s := mDefSVal+';';
-  end;
-  stp := TStrTextParser.Create(s);
-  try
-    fld := clone();
-    fld.parseValue(stp, nil);
-    result := isSimpleEqu(fld);
-  finally
-    fld.Free();
-    stp.Free();
+    TType.TChar, TType.TString: result := (mSVal = mDefSVal);
+    TType.TPoint, TType.TSize: result := (mIVal = mDefIVal2) and (mIVal2 = mDefIVal2);
+    TType.TList, TType.TTrigData: result := false; // no default values for those types
+    else result := (mIVal = mDefIVal);
   end;
 end;
 
@@ -456,7 +525,7 @@ end;
 
 function TDynField.definition (): AnsiString;
 begin
-  result := mPasName+' is '+TTextParser.quote(mName)+' type ';
+  result := mPasName+' is '+quoteStr(mName)+' type ';
   result += getTypeName(mType);
   if (mMaxDim >= 0) then result += Format('[%d]', [mMaxDim]);
   if (mRecOfs >= 0) then result += Format(' offset %d', [mRecOfs]);
@@ -466,25 +535,7 @@ begin
     TEBS.TEnum: result += ' enum '+mEBSTypeName;
     TEBS.TBitSet: begin result += ' bitset '; if mBitSetUnique then result += 'unique '; result += mEBSTypeName; end;
   end;
-  if mHasDefault then
-  begin
-    if (mType = TType.TChar) or (mType = TType.TString) then result += ' default '+TTextParser.quote(mDefSVal)
-    else if (Length(mDefSVal) > 0) then result += ' default '+mDefSVal;
-    {
-    else
-    begin
-      if (mType = TType.TBool) then
-      begin
-        result += ' default ';
-        if (mDefIVal <> 0) then result += 'true' else result += 'false';
-      end
-      else
-      begin
-        result += Format(' default %d', [mDefIVal]);
-      end;
-    end;
-    }
-  end;
+  if mHasDefault and (Length(mDefUnparsed) > 0) then result += ' default '+mDefUnparsed;
   if mSepPosSize then
   begin
          if (mType = TType.TPoint) then begin if (mAsT) then result += ' as txy' else result += ' as xy'; end
@@ -495,6 +546,34 @@ begin
 end;
 
 
+function TDynField.pasdef (): AnsiString;
+begin
+  result := mPasName+': ';
+  case mType of
+    TType.TBool: result += 'Boolean;';
+    TType.TChar: if (mMaxDim > 0) then result += formatstrf('Char%d;', [mMaxDim]) else result += 'Char;';
+    TType.TByte: result += 'ShortInt;';
+    TType.TUByte: result += 'Byte;';
+    TType.TShort: result += 'SmallInt;';
+    TType.TUShort: result += 'Word;';
+    TType.TInt: result += 'LongInt;';
+    TType.TUInt: result += 'LongWord;';
+    TType.TString: result += 'AnsiString;';
+    TType.TPoint:
+           if mAsT then result := 'tX, tY: Integer;'
+      else if mSepPosSize then result := 'X, Y: Integer;'
+      else result += 'TDFPoint;';
+    TType.TSize:
+           if mAsT then result := 'tWidth, tHeight: Word;'
+      else if mSepPosSize then result := 'Width, Height: Word;'
+      else result += 'TSize;';
+    TType.TList: assert(false);
+    TType.TTrigData: result += formatstrf('Byte%d;', [mMaxDim]);
+    else raise Exception.Create('ketmar forgot to handle some field type');
+  end;
+end;
+
+
 procedure TDynField.parseDef (pr: TTextParser);
 var
   fldname: AnsiString;
@@ -545,7 +624,7 @@ begin
   if pr.eatDelim('[') then
   begin
     lmaxdim := pr.expectInt();
-    if (lmaxdim < 1) then raise Exception.Create(Format('invali field ''%s'' array size', [fldname]));
+    if (lmaxdim < 1) then raise Exception.Create(Format('invalid field ''%s'' array size', [fldname]));
     pr.expectDelim(']');
   end;
 
@@ -649,19 +728,18 @@ begin
   else if (fldtype = 'trigdata') then mType := TType.TTrigData
   else raise Exception.Create(Format('field ''%s'' has invalid type ''%s''', [fldname, fldtype]));
 
-  {if hasdefId and (self.baseType = self.TType.TBool) then
+  if (lmaxdim > 0) and (mType <> TType.TChar) and (mType <> TType.TTrigData) then raise Exception.Create(Format('field ''%s'' of type ''%s'' cannot be array', [fldname, fldtype]));
+  if (mType = TType.TTrigData) then
   begin
-         if (defstr = 'true') or (defstr = 'tan') or (defstr = 'yes') then self.mDefIVal := 1
-    else if (defstr = 'false') or (defstr = 'ona') or (defstr = 'no') then self.mDefIVal := 0
-    else raise Exception.Create(Format('field ''%s'' has invalid boolean default ''%s''', [fldname, defstr]));
-  end
-  else}
-  begin
-         if hasdefStr then self.mDefSVal := defstr
-    else if hasdefInt then self.mDefSVal := Format('%d', [defint])
-    else if hasdefId then self.mDefSVal := defstr;
+    if (lmaxdim < 1) then raise Exception.Create(Format('field ''%s'' of type ''%s'' cannot be array', [fldname, fldtype]));
+    if (Length(fldrecname) > 0) then raise Exception.Create(Format('field ''%s'' of type ''%s'' cannot have another type', [fldname, fldtype]));
+    lebs := TDynField.TEBS.TRec;
   end;
 
+       if hasdefStr then self.mDefUnparsed := quoteStr(defstr)
+  else if hasdefInt then self.mDefUnparsed := Format('%d', [defint])
+  else if hasdefId then self.mDefUnparsed := defstr;
+
   self.mHasDefault := (hasdefStr or hasdefId or hasdefInt);
   self.mPasName := fldpasname;
   self.mEBS := lebs;
@@ -677,7 +755,7 @@ begin
 end;
 
 
-procedure TDynField.writeBinTo (st: TStream; curheader: TDynRecord);
+procedure TDynField.writeBinTo (st: TStream);
 var
   s: AnsiString;
   f: Integer;
@@ -689,20 +767,14 @@ begin
     TEBS.TNone: begin end;
     TEBS.TRec:
       begin
-        // this must be byte/word/int
         if (mMaxDim >= 0) then
         begin
           // this must be triggerdata
-          if (CompareText(mEBSTypeName, 'triggerdata') <> 0) then
+          if (mType <> TType.TTrigData) then
           begin
             raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
           end;
           // write triggerdata
-          case mType of
-            TType.TChar, TType.TByte, TType.TUByte: begin end;
-            else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
-          end;
-          //writeln('trigdata size: ', mMaxDim);
           GetMem(buf, mMaxDim);
           if (buf = nil) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
           try
@@ -710,7 +782,7 @@ begin
             if (mRecRef <> nil) then
             begin
               ws := TSFSMemoryChunkStream.Create(buf, mMaxDim);
-              mRecRef.writeBinTo(ws, curheader, mMaxDim); // as trigdata
+              mRecRef.writeBinTo(ws, mMaxDim); // as trigdata
             end;
             st.WriteBuffer(buf^, mMaxDim);
           finally
@@ -719,17 +791,7 @@ begin
           end;
           exit;
         end;
-        if (mRecRef = nil) then
-        begin
-          // no ref, write -1
-          case mType of
-            TType.TByte, TType.TUByte: writeInt(st, Byte(-1));
-            TType.TShort, TType.TUShort: writeInt(st, SmallInt(-1));
-            TType.TInt, TType.TUInt: writeInt(st, Integer(-1));
-            else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
-          end;
-          exit;
-        end;
+        // record reference
         case mType of
           TType.TByte: maxv := 127;
           TType.TUByte: maxv := 254;
@@ -740,13 +802,20 @@ begin
           else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
         end;
         // find record number
-        f := mOwner.mOwner.findRecordNumByType(mEBSTypeName, mRecRef, curheader);
-        if (f < 0) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' not found in record list', [mEBSTypeName, mName]));
-        if (f > maxv) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' has too big index', [mEBSTypeName, mName]));
+        if (mRecRef <> nil) then
+        begin
+          f := mOwner.findRecordNumByType(mEBSTypeName, mRecRef);
+          if (f < 0) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' not found in record list', [mEBSTypeName, mName]));
+          if (f > maxv) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' has too big index', [mEBSTypeName, mName]));
+        end
+        else
+        begin
+          f := -1;
+        end;
         case mType of
           TType.TByte, TType.TUByte: writeInt(st, Byte(f));
           TType.TShort, TType.TUShort: writeInt(st, SmallInt(f));
-          TType.TInt, TType.TUInt: writeInt(st, Integer(f));
+          TType.TInt, TType.TUInt: writeInt(st, LongWord(f));
           else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
         end;
         exit;
@@ -759,7 +828,14 @@ begin
   case mType of
     TType.TBool:
       begin
-        if (mIVal <> 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
+        if not mNegBool then
+        begin
+          if (mIVal <> 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
+        end
+        else
+        begin
+          if (mIVal = 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
+        end;
         exit;
       end;
     TType.TChar:
@@ -773,9 +849,7 @@ begin
         else
         begin
           if (Length(mSVal) > mMaxDim) then raise Exception.Create(Format('invalid string size definition for field ''%s''', [mName]));
-          //FillChar(s[0], sizeof(s), 0);
-          s := utfTo1251(mSVal);
-          //writeln('writing char[', mMaxDim, '] <', mName, '>: ', TTextParser.quote(s));
+          s := utf2win(mSVal);
           if (Length(s) > 0) then st.WriteBuffer(PChar(s)^, Length(s));
           for f := Length(s) to mMaxDim do writeInt(st, Byte(0));
         end;
@@ -784,30 +858,22 @@ begin
     TType.TByte,
     TType.TUByte:
       begin
-        // either array, and this should be triggerdata, or byte
-        if (mMaxDim < 0) then
-        begin
-          // byte
-          writeInt(st, Byte(mIVal));
-        end
-        else
-        begin
-          // array
-          raise Exception.Create(Format('byte array in field ''%s'' cannot be written', [mName]));
-        end;
+        // triggerdata array was processed earlier
+        if (mMaxDim >= 0) then Exception.Create(Format('byte array in field ''%s'' cannot be written', [mName]));
+        writeInt(st, Byte(mIVal));
         exit;
       end;
     TType.TShort,
     TType.TUShort:
       begin
-        if (mMaxDim > 0) then raise Exception.Create(Format('short array in field ''%s'' cannot be written', [mName]));
+        if (mMaxDim >= 0) then raise Exception.Create(Format('short array in field ''%s'' cannot be written', [mName]));
         writeInt(st, Word(mIVal));
         exit;
       end;
     TType.TInt,
     TType.TUInt:
       begin
-        if (mMaxDim > 0) then raise Exception.Create(Format('int array in field ''%s'' cannot be written', [mName]));
+        if (mMaxDim >= 0) then raise Exception.Create(Format('int array in field ''%s'' cannot be written', [mName]));
         writeInt(st, LongWord(mIVal));
         exit;
       end;
@@ -815,10 +881,16 @@ begin
       begin
         raise Exception.Create(Format('cannot write string field ''%s''', [mName]));
       end;
-    TType.TPoint,
+    TType.TPoint:
+      begin
+        if (mMaxDim >= 0) then raise Exception.Create(Format('pos/size array in field ''%s'' cannot be written', [mName]));
+        writeInt(st, LongInt(mIVal));
+        writeInt(st, LongInt(mIVal2));
+        exit;
+      end;
     TType.TSize:
       begin
-        if (mMaxDim > 0) then raise Exception.Create(Format('pos/size array in field ''%s'' cannot be written', [mName]));
+        if (mMaxDim >= 0) then raise Exception.Create(Format('pos/size array in field ''%s'' cannot be written', [mName]));
         writeInt(st, Word(mIVal));
         writeInt(st, Word(mIVal2));
         exit;
@@ -840,21 +912,19 @@ end;
 
 procedure TDynField.writeTo (wr: TTextWriter);
 var
-  def: TDynMapDef;
   es: TDynEBS = nil;
   f, mask: Integer;
   first, found: Boolean;
 begin
   wr.put(mName);
   wr.put(' ');
-  // if this field should contain struct, convert type and parse struct
   case mEBS of
     TEBS.TNone: begin end;
     TEBS.TRec:
       begin
         if (mRecRef = nil) then
         begin
-          wr.put('null;'#10);
+          if (mType = TType.TTrigData) then wr.put('{}'#10) else wr.put('null;'#10);
         end
         else if (Length(mRecRef.mId) = 0) then
         begin
@@ -869,9 +939,11 @@ begin
       end;
     TEBS.TEnum:
       begin
-        def := mOwner.mOwner;
-        es := def.findEBSType(mEBSTypeName);
-        if (es = nil) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+        //def := mOwner.mOwner;
+        //es := def.findEBSType(mEBSTypeName);
+        es := nil;
+        if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
+        if (es = nil) or (not es.mIsEnum) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
         for f := 0 to High(es.mVals) do
         begin
           if (es.mVals[f] = mIVal) then
@@ -885,9 +957,11 @@ begin
       end;
     TEBS.TBitSet:
       begin
-        def := mOwner.mOwner;
-        es := def.findEBSType(mEBSTypeName);
-        if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+        //def := mOwner.mOwner;
+        //es := def.findEBSType(mEBSTypeName);
+        es := nil;
+        if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
+        if (es = nil) or es.mIsEnum then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
         // none?
         if (mIVal = 0) then
         begin
@@ -939,7 +1013,7 @@ begin
     TType.TChar:
       begin
         if (mMaxDim = 0) then raise Exception.Create(Format('invalid string size definition for field ''%s''', [mName]));
-        wr.put(TTextParser.quote(mSVal));
+        wr.put(quoteStr(mSVal));
         wr.put(';'#10);
         exit;
       end;
@@ -955,7 +1029,7 @@ begin
       end;
     TType.TString:
       begin
-        wr.put(TTextParser.quote(mSVal));
+        wr.put(quoteStr(mSVal));
         wr.put(';'#10);
         exit;
       end;
@@ -980,8 +1054,192 @@ begin
   raise Exception.Create(Format('cannot parse field ''%s'' yet', [mName]));
 end;
 
+procedure TDynField.parseBinValue (st: TStream);
+var
+  rec, rc: TDynRecord;
+  tfld: TDynField;
+  es: TDynEBS = nil;
+  tdata: PByte = nil;
+  f, mask: Integer;
+  s: AnsiString;
+begin
+  case mEBS of
+    TEBS.TNone: begin end;
+    TEBS.TRec:
+      begin
+        // this must be triggerdata
+        if (mType = TType.TTrigData) then
+        begin
+          assert(mMaxDim > 0);
+          rec := mOwner;
+          // find trigger definition
+          tfld := rec.trigTypeField();
+          if (tfld = nil) then raise Exception.Create(Format('triggerdata value for field ''%s'' in record ''%s'' without TriggerType field', [mName, rec.mName]));
+          rc := mOwner.mOwner.findTrigFor(tfld.mSVal); // find in mapdef
+          if (rc = nil) then raise Exception.Create(Format('triggerdata definition for field ''%s'' in record ''%s'' with type ''%s'' not found', [mName, rec.mName, tfld.mSVal]));
+          rc := rc.clone();
+          rc.mHeaderRec := mOwner.mHeaderRec;
+          try
+            rc.parseBinValue(st, true);
+            mRecRef := rc;
+            rc := nil;
+          finally
+            rc.Free();
+          end;
+          mDefined := true;
+          exit;
+        end
+        else
+        begin
+          // not a trigger data
+          case mType of
+            TType.TByte: f := readShortInt(st);
+            TType.TUByte: f := readByte(st);
+            TType.TShort: f := readSmallInt(st);
+            TType.TUShort: f := readWord(st);
+            TType.TInt: f := readLongInt(st);
+            TType.TUInt: f := readLongWord(st);
+            else raise Exception.Create(Format('invalid non-numeric type ''%s'' for field ''%s'' of record ''%s''', [getTypeName(mType), mName, mEBSTypeName]));
+          end;
+          if (f < 0) then mRecRefId := '' else mRecRefId := Format('%s%d', [mEBSTypeName, f]);
+        end;
+        mDefined := true;
+        exit;
+      end;
+    TEBS.TEnum,
+    TEBS.TBitSet:
+      begin
+        assert(mMaxDim < 0);
+        case mType of
+          TType.TByte: f := readShortInt(st);
+          TType.TUByte: f := readByte(st);
+          TType.TShort: f := readSmallInt(st);
+          TType.TUShort: f := readWord(st);
+          TType.TInt: f := readLongInt(st);
+          TType.TUInt: f := readLongWord(st);
+          else raise Exception.Create(Format('invalid non-numeric type ''%s'' for field ''%s'' of record ''%s''', [getTypeName(mType), mName, mEBSTypeName]));
+        end;
+        es := nil;
+        if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
+        if (es = nil) or (es.mIsEnum <> (mEBS = TEBS.TEnum)) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+        mIVal := f;
+        // build enum/bitfield values
+        if (mEBS = TEBS.TEnum) then
+        begin
+          mSVal := es.nameByValue(mIVal);
+          if (Length(mSVal) = 0) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mIVal]));
+        end
+        else
+        begin
+          // special for 'none'
+          if (mIVal = 0) then
+          begin
+            mSVal := es.nameByValue(mIVal);
+            if (Length(mSVal) = 0) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mIVal]));
+          end
+          else
+          begin
+            mSVal := '';
+            mask := 1;
+            while (mask <> 0) do
+            begin
+              if ((mIVal and mask) <> 0) then
+              begin
+                s := es.nameByValue(mask);
+                if (Length(s) = 0) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' has invalid value %d', [mEBSTypeName, mName, mask]));
+                if (Length(mSVal) <> 0) then mSVal += '+';
+                mSVal += s;
+              end;
+              mask := mask shl 1;
+            end;
+          end;
+        end;
+        //writeln('ebs <', es.mName, '>: ', mSVal);
+        mDefined := true;
+        exit;
+      end;
+    else raise Exception.Create('ketmar forgot to handle some EBS type');
+  end;
+
+  case mType of
+    TType.TBool:
+      begin
+        f := readByte(st);
+        if (f <> 0) then f := 1;
+        if mNegBool then f := 1-f;
+        mIVal := f;
+        mDefined := true;
+        exit;
+      end;
+    TType.TChar:
+      begin
+        if (mMaxDim < 0) then
+        begin
+          mIVal := readByte(st);
+        end
+        else
+        begin
+          mSVal := '';
+          GetMem(tdata, mMaxDim);
+          try
+            st.ReadBuffer(tdata^, mMaxDim);
+            f := 0;
+            while (f < mMaxDim) and (tdata[f] <> 0) do Inc(f);
+            if (f > 0) then
+            begin
+              SetLength(mSVal, f);
+              Move(tdata^, PChar(mSVal)^, f);
+              mSVal := win2utf(mSVal);
+            end;
+          finally
+            FreeMem(tdata);
+          end;
+        end;
+        mDefined := true;
+        exit;
+      end;
+    TType.TByte: begin mIVal := readShortInt(st); mDefined := true; exit; end;
+    TType.TUByte: begin mIVal := readByte(st); mDefined := true; exit; end;
+    TType.TShort: begin mIVal := readSmallInt(st); mDefined := true; exit; end;
+    TType.TUShort: begin mIVal := readWord(st); mDefined := true; exit; end;
+    TType.TInt: begin mIVal := readLongInt(st); mDefined := true; exit; end;
+    TType.TUInt: begin mIVal := readLongWord(st); mDefined := true; exit; end;
+    TType.TString:
+      begin
+        raise Exception.Create('cannot read strings from binaries yet');
+        exit;
+      end;
+    TType.TPoint:
+      begin
+        mIVal := readLongInt(st);
+        mIVal2 := readLongInt(st);
+        mDefined := true;
+        exit;
+      end;
+    TType.TSize:
+      begin
+        mIVal := readWord(st);
+        mIVal2 := readWord(st);
+        mDefined := true;
+        exit;
+      end;
+    TType.TList:
+      begin
+        assert(false);
+        exit;
+      end;
+    TType.TTrigData:
+      begin
+        assert(false);
+        exit;
+      end;
+    else raise Exception.Create('ketmar forgot to handle some field type');
+  end;
+  raise Exception.Create(Format('cannot parse field ''%s'' yet', [mName]));
+end;
+
 
-procedure TDynField.parseValue (pr: TTextParser; curheader: TDynRecord);
+procedure TDynField.parseValue (pr: TTextParser);
 
   procedure parseInt (min, max: Integer);
   begin
@@ -992,62 +1250,90 @@ procedure TDynField.parseValue (pr: TTextParser; curheader: TDynRecord);
 
 var
   rec, rc: TDynRecord;
-  def: TDynMapDef;
   es: TDynEBS = nil;
   tfld: TDynField;
   tk: AnsiString;
+  edim: AnsiChar;
 begin
   // if this field should contain struct, convert type and parse struct
   case mEBS of
     TEBS.TNone: begin end;
     TEBS.TRec:
       begin
-        def := mOwner.mOwner;
         // ugly hack. sorry.
-        if (CompareText(mEBSTypeName, 'triggerdata') = 0) then
+        if (mType = TType.TTrigData) then
         begin
-          rec := mOwner;
-          // find trigger definition
-          tfld := rec.field['type'];
-          if (tfld = nil) then raise Exception.Create(Format('triggerdata value for field ''%s'' in record ''%s'' without ''type'' field', [mName, rec.mName]));
-          if (tfld.mEBS <> TEBS.TEnum) then raise Exception.Create(Format('triggerdata value for field ''%s'' in record ''%s'' with bad ''type'' field', [mName, rec.mName]));
-          rc := def.findTrigFor(tfld.mSVal);
-          if (rc = nil) then raise Exception.Create(Format('triggerdata definition for field ''%s'' in record ''%s'' with type ''%s'' not found', [mName, rec.mName, tfld.mSVal]));
-          rc := rc.clone();
-          rc.parseValue(pr, curheader);
-          mRecRef := rc;
+          pr.expectTT(pr.TTBegin);
+          if (pr.tokType = pr.TTEnd) then
+          begin
+            // '{}'
+            mRecRef := nil;
+            pr.expectTT(pr.TTEnd);
+          end
+          else
+          begin
+            rec := mOwner;
+            // find trigger definition
+            tfld := rec.trigTypeField();
+            if (tfld = nil) then raise Exception.Create(Format('triggerdata value for field ''%s'' in record ''%s'' without ''type'' field', [mName, rec.mName]));
+            rc := mOwner.mOwner.findTrigFor(tfld.mSVal); // find in mapdef
+            if (rc = nil) then raise Exception.Create(Format('triggerdata definition for field ''%s'' in record ''%s'' with type ''%s'' not found', [mName, rec.mName, tfld.mSVal]));
+            rc := rc.clone();
+            rc.mHeaderRec := mOwner.mHeaderRec;
+            //writeln(rc.definition);
+            try
+              rc.parseValue(pr, true);
+              mRecRef := rc;
+              rc := nil;
+            finally
+              rc.Free();
+            end;
+          end;
           mDefined := true;
+          pr.eatTT(pr.TTSemi); // hack: allow (but don't require) semicolon after inline records
           exit;
         end;
         // other record types
         if (pr.tokType = pr.TTId) then
         begin
-          rec := def.findRecordByTypeId(mEBSTypeName, pr.tokStr, curheader);
-          if (rec = nil) then raise Exception.Create(Format('record ''%s'' (%s) value for field ''%s'' not found', [pr.tokStr, mEBSTypeName, mName]));
-          pr.expectId();
-          mRecRef := rec;
+          if pr.eatId('null') then
+          begin
+            mRecRef := nil;
+          end
+          else
+          begin
+            rec := mOwner.findRecordByTypeId(mEBSTypeName, pr.tokStr);
+            if (rec = nil) then raise Exception.Create(Format('record ''%s'' (%s) value for field ''%s'' not found', [pr.tokStr, mEBSTypeName, mName]));
+            pr.expectId();
+            mRecRef := rec;
+          end;
           mDefined := true;
           pr.expectTT(pr.TTSemi);
           exit;
         end
         else if (pr.tokType = pr.TTBegin) then
         begin
-          rec := def.findRecType(mEBSTypeName);
+          //rec := mOwner.mOwner.findRecType(mEBSTypeName); // find in mapdef
+          rec := nil;
+          if (mEBSType <> nil) and (mEBSType is TDynRecord) then rec := (mEBSType as TDynRecord);
           if (rec = nil) then raise Exception.Create(Format('record type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
           rc := rec.clone();
-          rc.parseValue(pr, curheader);
+          rc.mHeaderRec := mOwner.mHeaderRec;
+          rc.parseValue(pr);
           mRecRef := rc;
           mDefined := true;
-          mOwner.mOwner.addRecordByType(mEBSTypeName, rc, curheader);
+          mOwner.addRecordByType(mEBSTypeName, rc);
+          pr.eatTT(pr.TTSemi); // hack: allow (but don't require) semicolon after inline records
           exit;
         end;
         pr.expectTT(pr.TTBegin);
       end;
     TEBS.TEnum:
       begin
-        def := mOwner.mOwner;
-        es := def.findEBSType(mEBSTypeName);
-        if (es = nil) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+        //es := mOwner.mOwner.findEBSType(mEBSTypeName); // find in mapdef
+        es := nil;
+        if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
+        if (es = nil) or (not es.mIsEnum) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
         tk := pr.expectId();
         if not es.has[tk] then raise Exception.Create(Format('record enum value ''%s'' of type ''%s'' for field ''%s'' not found', [tk, mEBSTypeName, mName]));
         mIVal := es.field[tk];
@@ -1059,9 +1345,10 @@ begin
       end;
     TEBS.TBitSet:
       begin
-        def := mOwner.mOwner;
-        es := def.findEBSType(mEBSTypeName);
-        if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+        //es := mOwner.mOwner.findEBSType(mEBSTypeName); // find in mapdef
+        es := nil;
+        if (mEBSType <> nil) and (mEBSType is TDynEBS) then es := (mEBSType as TDynEBS);
+        if (es = nil) or es.mIsEnum then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
         mIVal := 0;
         while true do
         begin
@@ -1157,27 +1444,19 @@ begin
     TType.TPoint,
     TType.TSize:
       begin
-        pr.expectDelim('(');
+        if pr.eatDelim('[') then edim := ']' else begin pr.expectDelim('('); edim := ')'; end;
         mIVal := pr.expectInt();
-        if (mType = TType.TPoint) then
-        begin
-          if (mIVal < -32768) or (mIVal > 32767) then raise Exception.Create(Format('invalid %s value for field ''%s''', [getTypeName(mType), mName]));
-        end
-        else
+        if (mType = TType.TSize) then
         begin
           if (mIVal < 0) or (mIVal > 32767) then raise Exception.Create(Format('invalid %s value for field ''%s''', [getTypeName(mType), mName]));
         end;
         mIVal2 := pr.expectInt();
-        if (mType = TType.TPoint) then
-        begin
-          if (mIVal2 < -32768) or (mIVal2 > 32767) then raise Exception.Create(Format('invalid %s value for field ''%s''', [getTypeName(mType), mName]));
-        end
-        else
+        if (mType = TType.TSize) then
         begin
           if (mIVal2 < 0) or (mIVal2 > 32767) then raise Exception.Create(Format('invalid %s value for field ''%s''', [getTypeName(mType), mName]));
         end;
         mDefined := true;
-        pr.expectDelim(')');
+        pr.expectDelim(edim);
         pr.expectTT(pr.TTSemi);
         exit;
       end;
@@ -1197,11 +1476,6 @@ begin
 end;
 
 
-procedure TDynField.parseBinValue (st: TStream);
-begin
-end;
-
-
 // ////////////////////////////////////////////////////////////////////////// //
 constructor TDynRecord.Create (pr: TTextParser);
 begin
@@ -1209,9 +1483,10 @@ begin
   mId := '';
   mName := '';
   mSize := 0;
-  mFields := nil;
+  mFields := TDynFieldList.Create();
   mTrigTypes := nil;
   mHeader := false;
+  mHeaderRec := nil;
   mBinBlock := -1;
   parseDef(pr);
 end;
@@ -1221,17 +1496,20 @@ constructor TDynRecord.Create ();
 begin
   mName := '';
   mSize := 0;
-  mFields := nil;
+  mFields := TDynFieldList.Create();
   mTrigTypes := nil;
   mHeader := false;
+  mHeaderRec := nil;
 end;
 
 
 destructor TDynRecord.Destroy ();
 begin
   mName := '';
+  mFields.Free();
   mFields := nil;
   mTrigTypes := nil;
+  mHeaderRec := nil;
   inherited;
 end;
 
@@ -1239,9 +1517,9 @@ end;
 function TDynRecord.findByName (const aname: AnsiString): Integer; inline;
 begin
   result := 0;
-  while (result < Length(mFields)) do
+  while (result < mFields.count) do
   begin
-    if (CompareText(aname, mFields[result].mName) = 0) then exit;
+    if StrEqu(aname, mFields[result].mName) then exit;
     Inc(result);
   end;
   result := -1;
@@ -1274,13 +1552,14 @@ var
   f: Integer;
 begin
   result := true;
-  for f := 0 to High(mTrigTypes) do if (CompareText(mTrigTypes[f], aname) = 0) then exit;
+  for f := 0 to High(mTrigTypes) do if StrEqu(mTrigTypes[f], aname) then exit;
   result := false;
 end;
 
 
 function TDynRecord.clone (): TDynRecord;
 var
+  fld: TDynField;
   f: Integer;
 begin
   result := TDynRecord.Create();
@@ -1289,16 +1568,125 @@ begin
   result.mPasName := mPasName;
   result.mName := mName;
   result.mSize := mSize;
-  result.mHeader := mHeader;
-  result.mBinBlock := mBinBlock;
-  SetLength(result.mFields, Length(mFields));
-  for f := 0 to High(mFields) do
+  if (mFields.count > 0) then
   begin
-    result.mFields[f] := mFields[f].clone();
-    result.mFields[f].mOwner := result;
+    result.mFields.capacity := mFields.count;
+    for fld in mFields do result.mFields.append(fld.clone(result));
   end;
   SetLength(result.mTrigTypes, Length(mTrigTypes));
   for f := 0 to High(mTrigTypes) do result.mTrigTypes[f] := mTrigTypes[f];
+  result.mHeader := mHeader;
+  result.mBinBlock := mBinBlock;
+  result.mHeaderRec := mHeaderRec;
+end;
+
+
+function TDynRecord.findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
+var
+  fld: TDynField;
+  rec: TDynRecord;
+begin
+  result := nil;
+  if (Length(aid) = 0) then exit;
+  // find record data
+  fld := mHeaderRec.field[atypename];
+  if (fld = nil) then exit;
+  if (fld.mType <> fld.TType.TList) then raise Exception.Create(Format('cannot get record of type ''%s'' due to name conflict with ordinary field', [atypename]));
+  // find by id
+  if (fld.mRVal <> nil) then
+  begin
+    for rec in fld.mRVal do
+    begin
+      if StrEqu(rec.mId, aid) then begin result := rec; exit; end;
+    end;
+  end;
+  // alas
+end;
+
+
+function TDynRecord.findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
+var
+  fld: TDynField;
+  f: Integer;
+begin
+  result := -1;
+  // find record data
+  fld := mHeaderRec.field[atypename];
+  if (fld = nil) then exit;
+  if (fld.mType <> fld.TType.TList) then raise Exception.Create(Format('cannot get record of type ''%s'' due to name conflict with ordinary field', [atypename]));
+  // find by ref
+  if (fld.mRVal <> nil) then
+  begin
+    for f := 0 to fld.mRVal.count-1 do
+    begin
+      if (fld.mRVal[f] = rc) then begin result := f; exit; end;
+    end;
+  end;
+  // alas
+end;
+
+
+procedure TDynRecord.addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+var
+  fld: TDynField;
+begin
+  // find record data
+  fld := mHeaderRec.field[atypename];
+  if (fld = nil) then
+  begin
+    // first record
+    fld := TDynField.Create(atypename, TDynField.TType.TList);
+    fld.mOwner := mHeaderRec;
+    mHeaderRec.mFields.append(fld);
+  end;
+  if (fld.mType <> fld.TType.TList) then raise Exception.Create(Format('cannot append record of type ''%s'' due to name conflict with ordinary field', [atypename]));
+  // append
+  if (fld.mRVal = nil) then fld.mRVal := TDynRecList.Create();
+  fld.mRVal.append(rc);
+end;
+
+
+function TDynRecord.isSimpleEqu (rec: TDynRecord): Boolean;
+var
+  f: Integer;
+begin
+  if (rec = nil) then begin result := false; exit; end; // self.mRecRef can't be `nil` here
+  if (rec = self) then begin result := true; exit; end;
+  if (mFields.count <> rec.mFields.count) then begin result := false; exit; end;
+  result := false;
+  for f := 0 to mFields.count-1 do
+  begin
+    if not mFields[f].isSimpleEqu(rec.mFields[f]) then exit;
+  end;
+  result := true;
+end;
+
+
+function TDynRecord.trigTypeField (): TDynField;
+var
+  fld: TDynField;
+  es: TDynEBS = nil;
+begin
+  for fld in mFields do
+  begin
+    if (fld.mEBS <> TDynField.TEBS.TEnum) then continue;
+    if not (fld.mEBSType is TDynEBS) then continue;
+    es := (fld.mEBSType as TDynEBS);
+    assert(es <> nil);
+    if StrEqu(es.mName, 'TriggerType') then begin result := fld; exit; end;
+  end;
+  result := nil;
+end;
+
+
+// number of records of the given instance
+function TDynRecord.instanceCount (const typename: AnsiString): Integer;
+var
+  fld: TDynField;
+begin
+  result := 0;
+  fld := field[typename];
+  if (fld <> nil) and (fld.mType = fld.TType.TList) then result := fld.mRVal.count;
 end;
 
 
@@ -1328,6 +1716,7 @@ begin
       SetLength(mTrigTypes, 1);
       mTrigTypes[0] := tdn;
     end;
+    mName := 'TriggerData';
   end
   else
   begin
@@ -1363,15 +1752,37 @@ begin
     if hasByName(fld.name) then begin fld.Free(); raise Exception.Create(Format('duplicate field ''%s''', [fld.name])); end;
     // append
     fld.mOwner := self;
-    SetLength(mFields, Length(mFields)+1);
-    mFields[High(mFields)] := fld;
+    mFields.append(fld);
     // done with field
-    //writeln('DEF: ', fld.definition);
   end;
   pr.expectTT(pr.TTEnd);
 end;
 
 
+function TDynRecord.pasdef (): AnsiString;
+var
+  fld: TDynField;
+begin
+  if isTrigData then
+  begin
+    assert(false);
+    result := '';
+  end
+  else
+  begin
+    // record
+    result := '  '+mPasName+' = packed record'#10;
+  end;
+  for fld in mFields do
+  begin
+    if fld.mInternal then continue;
+    if (fld.mBinOfs < 0) then continue;
+    result += '    '+fld.pasdef+#10;
+  end;
+  result += '  end;'#10;
+end;
+
+
 function TDynRecord.definition (): AnsiString;
 var
   f: Integer;
@@ -1398,12 +1809,12 @@ begin
   else
   begin
     // record
-    result := mPasName+' is '+TTextParser.quote(mName);
+    result := mPasName+' is '+quoteStr(mName);
     if (mSize >= 0) then result += Format(' size %d bytes', [mSize]);
     if mHeader then result += ' header';
   end;
   result += ' {'#10;
-  for f := 0 to High(mFields) do
+  for f := 0 to mFields.count-1 do
   begin
     result += '  ';
     result += mFields[f].definition;
@@ -1413,17 +1824,150 @@ begin
 end;
 
 
-procedure TDynRecord.writeBinTo (st: TStream; curheader: TDynRecord; trigbufsz: Integer=-1);
+procedure TDynRecord.parseBinValue (st: TStream; forceData: Boolean=false);
 var
+  sign: string[4];
+  btype: Integer;
+  bsize: Integer;
+  buf: PByte = nil;
+  loaded: array[0..255] of Boolean;
+  rec, rect: TDynRecord;
   fld: TDynField;
-  rec: TDynRecord;
+  f: Integer;
+  mst: TSFSMemoryChunkStream = nil;
+
+  procedure linkNames (rec: TDynRecord);
+  var
+    fld: TDynField;
+    rt: TDynRecord;
+  begin
+    //writeln('*** rec: ', rec.mName, '.', rec.mId, ' (', rec.mFields.count, ')');
+    for fld in rec.mFields do
+    begin
+      if (fld.mType = TDynField.TType.TTrigData) then
+      begin
+        if (fld.mRecRef <> nil) then linkNames(fld.mRecRef);
+        continue;
+      end;
+      if (Length(fld.mRecRefId) = 0) then continue;
+      assert(fld.mEBSType <> nil);
+      rt := findRecordByTypeId(fld.mEBSTypeName, fld.mRecRefId);
+      if (rt = nil) then raise Exception.Create(Format('record of type ''%s'' with id ''%s'' links to inexistant record of type ''%s'' with id ''%d''', [rec.mName, rec.mId, fld.mEBSTypeName, fld.mRecRefId]));
+      //writeln(' ', rec.mName, '.', rec.mId, ':', fld.mName, ' -> ', rt.mName, '.', rt.mId, ' (', fld.mEBSTypeName, '.', fld.mRecRefId, ')');
+      fld.mRecRefId := '';
+      fld.mRecRef := rt;
+      fld.mDefined := true;
+    end;
+    for fld in rec.mFields do
+    begin
+      //writeln('  ', fld.mName);
+      fld.fixDefaultValue(); // just in case
+    end;
+  end;
+
+begin
+  for f := 0 to High(loaded) do loaded[f] := false;
+  mst := TSFSMemoryChunkStream.Create(nil, 0);
+  try
+    if mHeader and not forceData then
+    begin
+      // parse map file as sequence of blocks
+      sign[0] := #4;
+      st.ReadBuffer(sign[1], 4);
+      if (sign <> 'MAP'#1) then raise Exception.Create('invalid binary map signature');
+      // parse blocks
+      while (st.position < st.size) do
+      begin
+        btype := readByte(st);
+        if (btype = 0) then break; // no more blocks
+        readLongWord(st); // reserved
+        bsize := readLongInt(st);
+        //writeln('btype=', btype, '; bsize=', bsize);
+        if (bsize < 0) or (bsize > $1fffffff) then raise Exception.Create(Format('block of type %d has invalid size %d', [btype, bsize]));
+        if loaded[btype] then raise Exception.Create(Format('block of type %d already loaded', [btype]));
+        loaded[btype] := true;
+        // find record type for this block
+        rect := nil;
+        for rec in mOwner.recTypes do if (rec.mBinBlock = btype) then begin rect := rec; break; end;
+        if (rect = nil) then raise Exception.Create(Format('block of type %d has no corresponding record', [btype]));
+        //writeln('found type ''', rec.mName, ''' for block type ', btype);
+        if (rec.mSize = 0) or ((bsize mod rec.mSize) <> 0) then raise Exception.Create(Format('block of type %d has invalid number of records', [btype]));
+        // header?
+        if (rect.mHeader) then
+        begin
+          if (bsize <> mSize) then raise Exception.Create(Format('header block of type %d has invalid number of records', [btype]));
+          GetMem(buf, bsize);
+          st.ReadBuffer(buf^, bsize);
+          mst.setup(buf, mSize);
+          parseBinValue(mst, true); // force parsing data
+        end
+        else
+        begin
+          // create list for this type
+          fld := TDynField.Create(rec.mName, TDynField.TType.TList);
+          fld.mOwner := self;
+          mFields.append(fld);
+          if (bsize > 0) then
+          begin
+            GetMem(buf, bsize);
+            st.ReadBuffer(buf^, bsize);
+            for f := 0 to (bsize div rec.mSize)-1 do
+            begin
+              mst.setup(buf+f*rec.mSize, rec.mSize);
+              rec := rect.clone();
+              rec.mHeaderRec := self;
+              rec.parseBinValue(mst);
+              rec.mId := Format('%s%d', [rec.mName, f]);
+              fld.mRVal.append(rec);
+              //writeln('parsed ''', rec.mId, '''...');
+            end;
+          end;
+        end;
+        FreeMem(buf);
+        buf := nil;
+        //st.position := st.position+bsize;
+      end;
+      // link fields
+      for fld in mFields do
+      begin
+        if (fld.mType <> TDynField.TType.TList) then continue;
+        for rec in fld.mRVal do linkNames(rec);
+      end;
+      exit;
+    end;
+
+    // read fields
+    if StrEqu(mName, 'TriggerData') then mSize := Integer(st.size-st.position);
+    if (mSize < 1) then raise Exception.Create(Format('cannot read record of type ''%s'' with unknown size', [mName]));
+    GetMem(buf, mSize);
+    st.ReadBuffer(buf^, mSize);
+    for fld in mFields do
+    begin
+      if fld.mInternal then continue;
+      if (fld.mBinOfs < 0) then continue;
+      if (fld.mBinOfs >= st.size) then raise Exception.Create(Format('record of type ''%s'' has invalid field ''%s''', [fld.mName]));
+      mst.setup(buf+fld.mBinOfs, mSize-fld.mBinOfs);
+      //writeln('parsing ''', mName, '.', fld.mName, '''...');
+      fld.parseBinValue(mst);
+    end;
+  finally
+    mst.Free();
+    if (buf <> nil) then FreeMem(buf);
+  end;
+end;
+
+
+procedure TDynRecord.writeBinTo (st: TStream; trigbufsz: Integer=-1; onlyFields: Boolean=false);
+var
+  fld: TDynField;
+  rec, rv: TDynRecord;
   buf: PByte = nil;
   ws: TStream = nil;
   blk, blkmax: Integer;
-  f, c: Integer;
+  //f, c: Integer;
   bufsz: Integer = 0;
+  blksz: Integer;
 begin
-  if (curheader = nil) and mHeader then curheader := self;
   if (trigbufsz < 0) then
   begin
     if (mBinBlock < 1) then raise Exception.Create('cannot write binary record without block number');
@@ -1440,23 +1984,22 @@ begin
     ws := TSFSMemoryChunkStream.Create(buf, bufsz);
 
     // write normal fields
-    for f := 0 to High(mFields) do
+    for fld in mFields do
     begin
-      fld := mFields[f];
       // record list?
       if (fld.mType = fld.TType.TList) then continue; // later
       if fld.mInternal then continue;
       if (fld.mBinOfs < 0) then continue;
       if (fld.mBinOfs >= bufsz) then raise Exception.Create('binary value offset is outside of the buffer');
       TSFSMemoryChunkStream(ws).setup(buf+fld.mBinOfs, bufsz-fld.mBinOfs);
-      writeln('writing field <', fld.mName, '>');
-      fld.writeBinTo(ws, curheader);
+      //writeln('writing field <', fld.mName, '>');
+      fld.writeBinTo(ws);
     end;
 
     // write block with normal fields
-    if mHeader then
+    if mHeader and not onlyFields then
     begin
-      writeln('writing header...');
+      //writeln('writing header...');
       // signature and version
       writeIntBE(st, LongWord($4D415001));
       writeInt(st, Byte(mBinBlock)); // type
@@ -1469,17 +2012,16 @@ begin
     FreeMem(buf); buf := nil;
 
     // write other blocks, if any
-    if mHeader then
+    if mHeader and not onlyFields then
     begin
       // calculate blkmax
       blkmax := 0;
-      for f := 0 to High(mFields) do
+      for fld in mFields do
       begin
-        fld := mFields[f];
         // record list?
         if (fld.mType = fld.TType.TList) then
         begin
-          if (Length(fld.mRVal) = 0) then continue;
+          if (fld.mRVal = nil) or (fld.mRVal.count = 0) then continue;
           rec := mOwner.findRecType(fld.mName);
           if (rec = nil) then continue;
           if (rec.mBinBlock <= 0) then continue;
@@ -1491,33 +2033,36 @@ begin
       begin
         if (blk = mBinBlock) then continue;
         ws := nil;
-        for f := 0 to High(mFields) do
+        for fld in mFields do
         begin
-          fld := mFields[f];
           // record list?
           if (fld.mType = fld.TType.TList) then
           begin
-            if (Length(fld.mRVal) = 0) then continue;
+            if (fld.mRVal = nil) or (fld.mRVal.count = 0) then continue;
             rec := mOwner.findRecType(fld.mName);
             if (rec = nil) then continue;
             if (rec.mBinBlock <> blk) then continue;
             if (ws = nil) then ws := TMemoryStream.Create();
-            //rec.writeBinTo(ws);
-            for c := 0 to High(fld.mRVal) do fld.mRVal[c].writeBinTo(ws, curheader);
+            for rv in fld.mRVal do rv.writeBinTo(ws);
           end;
         end;
         // flush block
         if (ws <> nil) then
         begin
+          blksz := Integer(ws.position);
           ws.position := 0;
           writeInt(st, Byte(blk)); // type
           writeInt(st, LongWord(0)); // reserved
-          writeInt(st, LongWord(ws.size)); // size
-          st.CopyFrom(ws, ws.size);
+          writeInt(st, LongWord(blksz)); // size
+          st.CopyFrom(ws, blksz);
           ws.Free();
           ws := nil;
         end;
       end;
+      // write end marker
+      writeInt(st, Byte(0));
+      writeInt(st, LongWord(0));
+      writeInt(st, LongWord(0));
     end;
   finally
     ws.Free();
@@ -1528,8 +2073,8 @@ end;
 
 procedure TDynRecord.writeTo (wr: TTextWriter; putHeader: Boolean=true);
 var
-  f, c: Integer;
   fld: TDynField;
+  rec: TDynRecord;
 begin
   if putHeader then
   begin
@@ -1540,17 +2085,20 @@ begin
   wr.put('{'#10);
   wr.indent();
   try
-    for f := 0 to High(mFields) do
+    for fld in mFields do
     begin
-      fld := mFields[f];
       // record list?
       if (fld.mType = fld.TType.TList) then
       begin
         if not mHeader then raise Exception.Create('record list in non-header record');
-        for c := 0 to High(fld.mRVal) do
+        if (fld.mRVal <> nil) then
         begin
-          wr.putIndent();
-          fld.mRVal[c].writeTo(wr, true);
+          for rec in fld.mRVal do
+          begin
+            if (Length(rec.mId) = 0) then continue;
+            wr.putIndent();
+            rec.writeTo(wr, true);
+          end;
         end;
         continue;
       end;
@@ -1567,52 +2115,55 @@ begin
 end;
 
 
-procedure TDynRecord.parseValue (pr: TTextParser; curheader: TDynRecord);
+procedure TDynRecord.parseValue (pr: TTextParser; beginEaten: Boolean=false);
 var
-  f, c: Integer;
   fld: TDynField;
-  rec, trc: TDynRecord;
-  //success: Boolean;
+  rec, trc, rv: TDynRecord;
 begin
   if (mOwner = nil) then raise Exception.Create(Format('can''t parse record ''%s'' value without owner', [mName]));
 
   // not a header?
-  if (curheader <> self) then
+  if not mHeader then
   begin
     // id?
-    if (pr.tokType = pr.TTId) then mId := pr.expectId();
+    if (not beginEaten) and (pr.tokType = pr.TTId) then mId := pr.expectId();
+  end
+  else
+  begin
+    assert(mHeaderRec = self);
   end;
 
-  writeln('parsing record <', mName, '>');
-  pr.expectTT(pr.TTBegin);
+  //writeln('parsing record <', mName, '>');
+  if not beginEaten then pr.expectTT(pr.TTBegin);
   while (pr.tokType <> pr.TTEnd) do
   begin
     if (pr.tokType <> pr.TTId) then raise Exception.Create('identifier expected');
-    //writeln('<', pr.tokStr, ':', asheader, '>');
+    //writeln('<', mName, '.', pr.tokStr, '>');
 
     // records
-    if (curheader = self) then
+    if mHeader then
     begin
       // add records with this type (if any)
       trc := mOwner.findRecType(pr.tokStr);
       if (trc <> nil) then
       begin
         rec := trc.clone();
+        rec.mHeaderRec := mHeaderRec;
         try
           pr.skipToken();
-          rec.parseValue(pr, curheader);
+          rec.parseValue(pr);
           if (Length(rec.mId) > 0) then
           begin
             fld := field[pr.tokStr];
-            if (fld <> nil) then
+            if (fld <> nil) and (fld.mRVal <> nil) then
             begin
-              for c := 0 to High(fld.mRVal) do
+              for rv in fld.mRVal do
               begin
-                if (Length(fld.mRVal[c].mId) > 0) and (CompareText(fld.mRVal[c].mId, rec.mId) = 0) then raise Exception.Create(Format('duplicate thing ''%s'' in record ''%s''', [fld.mName, mName]));
+                if (Length(rv.mId) > 0) and StrEqu(rv.mId, rec.mId) then raise Exception.Create(Format('duplicate thing ''%s'' in record ''%s''', [fld.mName, mName]));
               end;
             end;
           end;
-          mOwner.addRecordByType(rec.mName, rec, curheader);
+          addRecordByType(rec.mName, rec);
           rec := nil;
         finally
           rec.Free();
@@ -1628,7 +2179,7 @@ begin
       if fld.defined then raise Exception.Create(Format('duplicate field ''%s'' in record ''%s''', [fld.mName, mName]));
       if fld.internal then raise Exception.Create(Format('internal field ''%s'' in record ''%s''', [fld.mName, mName]));
       pr.skipToken();
-      fld.parseValue(pr, curheader);
+      fld.parseValue(pr);
       continue;
     end;
 
@@ -1637,13 +2188,8 @@ begin
   end;
   pr.expectTT(pr.TTEnd);
   // fix field defaults
-  for f := 0 to High(mFields) do mFields[f].fixDefaultValue();
-  writeln('done parsing record <', mName, '>');
-end;
-
-
-procedure TDynRecord.parseBinValue (st: TStream);
-begin
+  for fld in mFields do fld.fixDefaultValue();
+  //writeln('done parsing record <', mName, '>');
 end;
 
 
@@ -1678,7 +2224,7 @@ begin
   result := 0;
   while (result < Length(mIds)) do
   begin
-    if (CompareText(aname, mIds[result]) = 0) then exit;
+    if StrEqu(aname, mIds[result]) then exit;
     Inc(result);
   end;
   result := -1;
@@ -1731,6 +2277,31 @@ begin
 end;
 
 
+function TDynEBS.pasdef (): AnsiString;
+var
+  f: Integer;
+begin
+  result := '// '+mName+#10'const'#10;
+  // fields
+  for f := 0 to High(mIds) do
+  begin
+    result += formatstrf('  %s = %d;'#10, [mIds[f], mVals[f]]);
+  end;
+end;
+
+
+function TDynEBS.nameByValue (v: Integer): AnsiString;
+var
+  f: Integer;
+begin
+  for f := 0 to High(mVals) do
+  begin
+    if (mVals[f] = v) then begin result := mIds[f]; exit; end;
+  end;
+  result := '';
+end;
+
+
 procedure TDynEBS.parseDef (pr: TTextParser);
 var
   idname: AnsiString;
@@ -1751,9 +2322,9 @@ begin
     idname := pr.expectId();
     for f := 0 to High(mIds) do
     begin
-      if (CompareText(mIds[f], idname) = 0) then raise Exception.Create(Format('duplicate field ''%s'' in enum/bitset ''%s''', [idname, mName]));
+      if StrEqu(mIds[f], idname) then raise Exception.Create(Format('duplicate field ''%s'' in enum/bitset ''%s''', [idname, mName]));
     end;
-    if (CompareText(mMaxName, idname) = 0) then raise Exception.Create(Format('duplicate field ''%s'' in enum/bitset ''%s''', [idname, mName]));
+    if StrEqu(mMaxName, idname) then raise Exception.Create(Format('duplicate field ''%s'' in enum/bitset ''%s''', [idname, mName]));
     skipAdd := false;
     hasV := false;
     v := cv;
@@ -1810,20 +2381,24 @@ end;
 // ////////////////////////////////////////////////////////////////////////// //
 constructor TDynMapDef.Create (pr: TTextParser);
 begin
-  recTypes := nil;
-  trigTypes := nil;
-  ebsTypes := nil;
+  recTypes := TDynRecList.Create();
+  trigTypes := TDynRecList.Create();
+  ebsTypes := TDynEBSList.Create();
   parseDef(pr);
 end;
 
 
 destructor TDynMapDef.Destroy ();
 var
-  f: Integer;
+  rec: TDynRecord;
+  ebs: TDynEBS;
 begin
-  for f := 0 to High(recTypes) do recTypes[f].Free();
-  for f := 0 to High(trigTypes) do trigTypes[f].Free();
-  for f := 0 to High(ebsTypes) do ebsTypes[f].Free();
+  for rec in recTypes do rec.Free();
+  for rec in trigTypes do rec.Free();
+  for ebs in ebsTypes do ebs.Free();
+  recTypes.Free();
+  trigTypes.Free();
+  ebsTypes.Free();
   recTypes := nil;
   trigTypes := nil;
   ebsTypes := nil;
@@ -1833,18 +2408,18 @@ end;
 
 function TDynMapDef.getHeaderRecType (): TDynRecord; inline;
 begin
-  if (Length(recTypes) = 0) then raise Exception.Create('no header in empty mapdef');
+  if (recTypes.count = 0) then raise Exception.Create('no header in empty mapdef');
   result := recTypes[0];
 end;
 
 
 function TDynMapDef.findRecType (const aname: AnsiString): TDynRecord;
 var
-  f: Integer;
+  rec: TDynRecord;
 begin
-  for f := 0 to High(recTypes) do
+  for rec in recTypes do
   begin
-    if (CompareText(recTypes[f].name, aname) = 0) then begin result := recTypes[f]; exit; end;
+    if StrEqu(rec.name, aname) then begin result := rec; exit; end;
   end;
   result := nil;
 end;
@@ -1852,11 +2427,11 @@ end;
 
 function TDynMapDef.findTrigFor (const aname: AnsiString): TDynRecord;
 var
-  f: Integer;
+  rec: TDynRecord;
 begin
-  for f := 0 to High(trigTypes) do
+  for rec in trigTypes do
   begin
-    if (trigTypes[f].isForTrig[aname]) then begin result := trigTypes[f]; exit; end;
+    if (rec.isForTrig[aname]) then begin result := rec; exit; end;
   end;
   result := nil;
 end;
@@ -1864,108 +2439,57 @@ end;
 
 function TDynMapDef.findEBSType (const aname: AnsiString): TDynEBS;
 var
-  f: Integer;
+  ebs: TDynEBS;
 begin
-  for f := 0 to High(ebsTypes) do
+  for ebs in ebsTypes do
   begin
-    if (CompareText(ebsTypes[f].name, aname) = 0) then begin result := ebsTypes[f]; exit; end;
+    if StrEqu(ebs.name, aname) then begin result := ebs; exit; end;
   end;
   result := nil;
 end;
 
 
-function TDynMapDef.findRecordByTypeId (const atypename, aid: AnsiString; curheader: TDynRecord): TDynRecord;
+procedure TDynMapDef.parseDef (pr: TTextParser);
 var
-  rec: TDynRecord;
-  fld: TDynField;
+  rec, hdr: TDynRecord;
+  eb: TDynEBS;
   f: Integer;
-begin
-  result := nil;
-  // find record type
-  if (curheader = nil) then exit;
-  //writeln('searching for type <', atypename, '>');
-  rec := findRecType(atypename);
-  if (rec = nil) then exit;
-  // find record data
-  //writeln('searching for data of type <', atypename, '>');
-  fld := curheader.field[atypename];
-  if (fld = nil) then exit;
-  if (fld.mType <> fld.TType.TList) then exit;
-  // find by id
-  //writeln('searching for data of type <', atypename, '> with id <', aid, '> (', Length(fld.mRVal), ')');
-  for f := 0 to High(fld.mRVal) do
+
+  // setup header links and type links
+  procedure linkRecord (rec: TDynRecord);
+  var
+    fld: TDynField;
   begin
-    if (CompareText(fld.mRVal[f].mId, aid) = 0) then
+    rec.mHeaderRec := recTypes[0];
+    for fld in rec.mFields do
     begin
-      //writeln('  FOUND!');
-      result := fld.mRVal[f];
-      exit;
+      if (fld.mType = fld.TType.TTrigData) then continue;
+      case fld.mEBS of
+        TDynField.TEBS.TNone: begin end;
+        TDynField.TEBS.TRec:
+          begin
+            fld.mEBSType := findRecType(fld.mEBSTypeName);
+            if (fld.mEBSType = nil) then raise Exception.Create(Format('field ''%s'' of type ''%s'' has no correcponding record definition', [fld.mName, fld.mEBSTypeName]));
+          end;
+        TDynField.TEBS.TEnum,
+        TDynField.TEBS.TBitSet:
+          begin
+            fld.mEBSType := findEBSType(fld.mEBSTypeName);
+            if (fld.mEBSType = nil) then raise Exception.Create(Format('field ''%s'' of type ''%s'' has no correcponding enum/bitset', [fld.mName, fld.mEBSTypeName]));
+            if ((fld.mEBS = TDynField.TEBS.TEnum) <> (fld.mEBSType as TDynEBS).mIsEnum) then raise Exception.Create(Format('field ''%s'' of type ''%s'' enum/bitset type conflict', [fld.mName, fld.mEBSTypeName]));
+          end;
+      end;
     end;
   end;
-  // alas
-end;
-
-
-procedure TDynMapDef.addRecordByType (const atypename: AnsiString; rc: TDynRecord; curheader: TDynRecord);
-var
-  rec: TDynRecord;
-  fld: TDynField;
-begin
-  assert(curheader <> nil);
-  // find record type
-  rec := findRecType(atypename);
-  assert(rec <> nil);
-  // find record data
-  //writeln('searching for data of type <', atypename, '>');
-  fld := curheader.field[atypename];
-  if (fld = nil) then
-  begin
-    // first record
-    fld := TDynField.Create(atypename, TDynField.TType.TList);
-    fld.mOwner := curheader;
-    SetLength(curheader.mFields, Length(curheader.mFields)+1);
-    curheader.mFields[High(curheader.mFields)] := fld;
-  end;
-  if (fld.mType <> fld.TType.TList) then exit;
-  // add
-  SetLength(fld.mRVal, Length(fld.mRVal)+1);
-  fld.mRVal[High(fld.mRVal)] := rc;
-end;
 
-
-function TDynMapDef.findRecordNumByType (const atypename: AnsiString; rc: TDynRecord; curheader: TDynRecord): Integer;
-var
-  rec: TDynRecord;
-  fld: TDynField;
-  f: Integer;
-begin
-  result := -1;
-  if (curheader = nil) then exit;
-  // find record type
-  rec := findRecType(atypename);
-  if (rec = nil) then exit;
-  // find record data
-  fld := curheader.field[atypename];
-  if (fld = nil) then exit;
-  if (fld.mType <> fld.TType.TList) then exit;
-  // find by ref
-  for f := 0 to High(fld.mRVal) do
+  // setup default values
+  procedure fixRecordDefaults (rec: TDynRecord);
+  var
+    fld: TDynField;
   begin
-    if (fld.mRVal[f] = rc) then
-    begin
-      result := f;
-      exit;
-    end;
+    for fld in rec.mFields do if fld.mHasDefault then fld.parseDefaultValue();
   end;
-  // alas
-end;
-
 
-procedure TDynMapDef.parseDef (pr: TTextParser);
-var
-  dr, hdr: TDynRecord;
-  eb: TDynEBS;
-  f: Integer;
 begin
   hdr := nil;
   while true do
@@ -1982,51 +2506,57 @@ begin
         raise Exception.Create(Format('duplicate enum/bitset ''%s''', [eb.name]));
       end;
       eb.mOwner := self;
-      SetLength(ebsTypes, Length(ebsTypes)+1);
-      ebsTypes[High(ebsTypes)] := eb;
+      ebsTypes.append(eb);
       //writeln(eb.definition); writeln;
       continue;
     end;
 
     if (pr.tokStr = 'TriggerData') then
     begin
-      dr := TDynRecord.Create(pr);
-      for f := 0 to High(dr.mTrigTypes) do
+      rec := TDynRecord.Create(pr);
+      for f := 0 to High(rec.mTrigTypes) do
       begin
-        if (findTrigFor(dr.mTrigTypes[f]) <> nil) then
+        if (findTrigFor(rec.mTrigTypes[f]) <> nil) then
         begin
-          dr.Free();
-          raise Exception.Create(Format('duplicate trigdata ''%s''', [dr.mTrigTypes[f]]));
+          rec.Free();
+          raise Exception.Create(Format('duplicate trigdata ''%s''', [rec.mTrigTypes[f]]));
         end;
       end;
-      dr.mOwner := self;
-      SetLength(trigTypes, Length(trigTypes)+1);
-      trigTypes[High(trigTypes)] := dr;
+      rec.mOwner := self;
+      trigTypes.append(rec);
       //writeln(dr.definition); writeln;
       continue;
     end;
 
-    dr := TDynRecord.Create(pr);
+    rec := TDynRecord.Create(pr);
     //writeln(dr.definition); writeln;
-    if (findRecType(dr.name) <> nil) then begin dr.Free(); raise Exception.Create(Format('duplicate record ''%s''', [dr.name])); end;
-    if (hdr <> nil) and (CompareText(dr.name, hdr.name) = 0) then begin dr.Free(); raise Exception.Create(Format('duplicate record ''%s''', [dr.name])); end;
-    dr.mOwner := self;
-    if dr.mHeader then
+    if (findRecType(rec.name) <> nil) then begin rec.Free(); raise Exception.Create(Format('duplicate record ''%s''', [rec.name])); end;
+    if (hdr <> nil) and StrEqu(rec.name, hdr.name) then begin rec.Free(); raise Exception.Create(Format('duplicate record ''%s''', [rec.name])); end;
+    rec.mOwner := self;
+    if rec.mHeader then
     begin
-      if (hdr <> nil) then begin dr.Free(); raise Exception.Create(Format('duplicate header record ''%s'' (previous is ''%s'')', [dr.name, hdr.name])); end;
-      hdr := dr;
+      if (hdr <> nil) then begin rec.Free(); raise Exception.Create(Format('duplicate header record ''%s'' (previous is ''%s'')', [rec.name, hdr.name])); end;
+      hdr := rec;
     end
     else
     begin
-      SetLength(recTypes, Length(recTypes)+1);
-      recTypes[High(recTypes)] := dr;
+      recTypes.append(rec);
     end;
   end;
 
+  // put header record to top
   if (hdr = nil) then raise Exception.Create('header definition not found in mapdef');
-  SetLength(recTypes, Length(recTypes)+1);
-  for f := High(recTypes) downto 1 do recTypes[f] := recTypes[f-1];
+  recTypes.append(nil);
+  for f := recTypes.count-1 downto 1 do recTypes[f] := recTypes[f-1];
   recTypes[0] := hdr;
+
+  // setup header links and type links
+  for rec in recTypes do linkRecord(rec);
+  for rec in trigTypes do linkRecord(rec);
+
+  // setup default values
+  for rec in recTypes do fixRecordDefaults(rec);
+  for rec in trigTypes do fixRecordDefaults(rec);
 end;
 
 
@@ -2039,7 +2569,8 @@ begin
   try
     pr.expectId(headerType.name);
     res := headerType.clone();
-    res.parseValue(pr, res);
+    res.mHeaderRec := res;
+    res.parseValue(pr);
     result := res;
     res := nil;
   except on E: Exception do
@@ -2052,8 +2583,69 @@ end;
 
 
 function TDynMapDef.parseBinMap (st: TStream): TDynRecord;
+var
+  res: TDynRecord = nil;
 begin
   result := nil;
+  try
+    res := headerType.clone();
+    res.mHeaderRec := res;
+    res.parseBinValue(st);
+    result := res;
+    res := nil;
+  except on E: Exception do
+    begin
+      res.Free();
+      raise;
+    end;
+  end;
+end;
+
+
+function TDynMapDef.pasdef (): AnsiString;
+var
+  ebs: TDynEBS;
+  rec: TDynRecord;
+  fld: TDynField;
+  needComma: Boolean;
+  tn: AnsiString;
+begin
+  result := '';
+  result += '// ////////////////////////////////////////////////////////////////////////// //'#10;
+  result += '// enums and bitsets'#10;
+  for ebs in ebsTypes do result += #10+ebs.pasdef();
+  result += #10#10'// ////////////////////////////////////////////////////////////////////////// //'#10;
+  result += '// records'#10'type'#10;
+  for rec in recTypes do
+  begin
+    if (rec.mSize < 1) then continue;
+    result += rec.pasdef();
+    result += #10;
+  end;
+  result += #10#10'// ////////////////////////////////////////////////////////////////////////// //'#10;
+  result += '// triggerdata'#10'type'#10;
+  result += '  TTriggerData = record'#10;
+  result += '    case Byte of'#10;
+  result += '      0: (Default: Byte128);'#10;
+  for rec in trigTypes do
+  begin
+    result += '      ';
+    needComma := false;
+    for tn in rec.mTrigTypes do
+    begin
+      if needComma then result += ', ' else needComma := true;
+      result += tn;
+    end;
+    result += ': ('#10;
+    for fld in rec.mFields do
+    begin
+      if fld.mInternal then continue;
+      if (fld.mBinOfs < 0) then continue;
+      result += '        '+fld.pasdef+#10;
+    end;
+    result += '      );'#10;
+  end;
+  result += '  end;'#10;
 end;