diff --git a/src/shared/xdynrec.pas b/src/shared/xdynrec.pas
index c6897578d7d6334e3f9f71f964e64753013b6338..8ebac36188754ef6349bbb7bbc5147a1a0ccfe7a 100644 (file)
--- a/src/shared/xdynrec.pas
+++ b/src/shared/xdynrec.pas
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*)
{$INCLUDE a_modes.inc}
+{.$DEFINE XDYNREC_USE_FIELDHASH} // actually, it is SLOWER with this
unit xdynrec;
interface
uses
Classes,
- xparser, xstreams, utils;
+ xparser, xstreams, utils, hashtable;
// ////////////////////////////////////////////////////////////////////////// //
// TTrigData: array of mMaxDim bytes, but internally a record (mRecRef)
// arrays of chars are pascal shortstrings (with counter in the first byte)
- TDynFieldArray = array of TDynField;
- TDynRecordArray = array of TDynRecord;
-
private
type
TEBS = (TNone, TRec, TEnum, TBitSet);
mIVal2: Integer; // for point and size
mSVal: AnsiString; // string; for byte and char arrays
mRVal: TDynRecList; // for list
+ mRHash: THashStrInt; // id -> index in mRVal
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;
mInternal: Boolean;
mNegBool: Boolean;
mBitSetUnique: Boolean; // bitset can contain only one value
+ mAsMonsterId: Boolean; // special hack for triggers: monster record number+1 in binary (so 0 means "none")
// default value
mDefUnparsed: AnsiString;
mDefSVal: AnsiString; // default string value
// for binary parser
mRecRefId: AnsiString;
+ // for userdata
+ mTagInt: Integer;
+ mTagPtr: Pointer;
+
private
procedure cleanup ();
procedure fixDefaultValue (); // this will NOT clone `mDefRecRef`
function isDefaultValue (): Boolean;
+ function getListCount (): Integer; inline;
+ function getListItem (idx: Integer): TDynRecord; inline; overload;
+ function getListItem (const aname: AnsiString): TDynRecord; inline; overload;
+
+ function getRecRefIndex (): Integer;
+
+ procedure setIVal (v: Integer); inline;
+
+ protected
+ // returns `true` for duplicate record id
+ function addListItem (rec: TDynRecord): Boolean; inline;
+
+ public
+ type
+ TListEnumerator = record
+ private
+ mList: TDynRecList;
+ mCurIdx: Integer;
+ public
+ constructor Create (alist: TDynRecList);
+ function MoveNext (): Boolean; inline;
+ function getCurrent (): TDynRecord; inline;
+ property Current: TDynRecord read getCurrent;
+ end;
+
public
constructor Create (const aname: AnsiString; atype: TType);
constructor Create (pr: TTextParser);
class function getTypeName (t: TType): AnsiString;
function definition (): AnsiString;
+ function pasdef (): AnsiString;
function clone (newOwner: TDynRecord=nil): TDynField;
procedure setValue (const s: AnsiString);
+ function GetEnumerator (): TListEnumerator;
+
public
property pasname: AnsiString read mPasName;
property name: AnsiString read mName;
property baseType: TType read mType;
+ property negbool: Boolean read mNegBool;
property defined: Boolean read mDefined write mDefined;
property internal: Boolean read mInternal write mInternal;
- property ival: Integer read mIVal;
+ property hasTPrefix: Boolean read mAsT;
+ property separatePasFields: Boolean read mSepPosSize;
+ property binOfs: Integer read mBinOfs;
+ property ival: Integer read mIVal write setIVal;
+ property ival2: Integer read mIVal2;
property sval: AnsiString read mSVal;
- //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 hasDefault: Boolean read mHasDefault;
property defsval: AnsiString read mDefSVal;
property ebs: TEBS read mEBS;
property ebstype: TObject read mEBSType;
property ebstypename: AnsiString read mEBSTypeName; // enum/bitset name
-
- property x: Integer read mIVal;
- property w: Integer read mIVal;
- property y: Integer read mIVal2;
- property h: Integer read mIVal2;
+ property recref: TDynRecord read mRecRef write mRecRef; //FIXME: writing is a hack!
+ property recrefIndex: Integer read getRecRefIndex; // search for this record in header; -1: not found
+ // for lists
+ property count: Integer read getListCount;
+ property item[idx: Integer]: TDynRecord read getListItem;
+ property items[const aname: AnsiString]: TDynRecord read getListItem; default; // alas, FPC 3+ lost property overloading feature
+ // userdata
+ property tagInt: Integer read mTagInt write mTagInt;
+ property tagPtr: Pointer read mTagPtr write mTagPtr;
end;
mName: AnsiString;
mSize: Integer;
mFields: TDynFieldList;
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ mFieldsHash: THashStrInt; // id -> index in mRVal
+ {$ENDIF}
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
+ // for userdata
+ mTagInt: Integer;
+ mTagPtr: Pointer;
+
private
procedure parseDef (pr: TTextParser); // parse definition
function findByName (const aname: AnsiString): Integer; inline;
function hasByName (const aname: AnsiString): Boolean; inline;
function getFieldByName (const aname: AnsiString): TDynField; inline;
+ function getFieldAt (idx: Integer): TDynField; inline;
+ function getCount (): Integer; inline;
function getIsTrigData (): Boolean; inline;
function getIsForTrig (const aname: AnsiString): Boolean; inline;
+ function getForTrigCount (): Integer; inline;
+ function getForTrigAt (idx: Integer): AnsiString; inline;
+
protected
function findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
function findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
- procedure addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+ function addRecordByType (const atypename: AnsiString; rc: TDynRecord): Boolean; // `true`: duplicate record id
+
+ procedure addField (fld: TDynField); inline;
+ function addFieldChecked (fld: TDynField): Boolean; inline; // `true`: duplicate name
public
constructor Create ();
destructor Destroy (); override;
function definition (): AnsiString;
+ function pasdef (): AnsiString;
function clone (): TDynRecord;
procedure parseBinValue (st: TStream; forceData: Boolean=false);
procedure writeTo (wr: TTextWriter; putHeader: Boolean=true);
- procedure writeBinTo (st: TStream; 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: TDynFieldList read mFields;
+ //property fields: TDynFieldList read mFields;
property has[const aname: AnsiString]: Boolean read hasByName;
- property field[const aname: AnsiString]: TDynField read getFieldByName;
+ property count: Integer read getCount;
+ property field[const aname: AnsiString]: TDynField read getFieldByName; default;
+ property fieldAt[idx: Integer]: TDynField read getFieldAt;
property isTrigData: Boolean read getIsTrigData;
property isForTrig[const aname: AnsiString]: Boolean read getIsForTrig;
+ property forTrigCount: Integer read getForTrigCount;
+ property forTrigAt[idx: Integer]: AnsiString read getForTrigAt;
+ property headerRec: TDynRecord read mHeaderRec;
+ property isHeader: Boolean read mHeader;
+ // userdata
+ property tagInt: Integer read mTagInt write mTagInt;
+ property tagPtr: Pointer read mTagPtr write mTagPtr;
end;
-
TDynEBS = class
private
mOwner: TDynMapDef;
destructor Destroy (); override;
function definition (): AnsiString;
+ function pasdef (): AnsiString;
// return empty string if not found
function nameByValue (v: Integer): AnsiString;
function getHeaderRecType (): TDynRecord; inline;
+ function getTrigTypeCount (): Integer; inline;
+ function getTrigTypeAt (idx: Integer): TDynRecord; inline;
+
public
constructor Create (pr: TTextParser); // parses data definition
destructor Destroy (); override;
function findTrigFor (const aname: AnsiString): TDynRecord;
function findEBSType (const aname: AnsiString): TDynEBS;
+ function pasdef (): AnsiString;
+ function pasdefconst (): AnsiString;
+
// creates new header record
function parseMap (pr: TTextParser): TDynRecord;
public
property headerType: TDynRecord read getHeaderRecType;
+ property trigTypeCount: Integer read getTrigTypeCount;
+ property trigType[idx: Integer]: TDynRecord read getTrigTypeAt;
end;
+{$IF DEFINED(D2D_DYNREC_PROFILER)}
+procedure xdynDumpProfiles ();
+{$ENDIF}
+
+
implementation
uses
- SysUtils;
+ SysUtils, e_log
+ {$IF DEFINED(D2D_DYNREC_PROFILER)},xprofiler{$ENDIF};
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+function StrEqu (const a, b: AnsiString): Boolean; inline; begin result := (a = b); end;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+constructor TDynField.TListEnumerator.Create (alist: TDynRecList);
+begin
+ mList := alist;
+ mCurIdx := -1;
+end;
+
+
+function TDynField.TListEnumerator.MoveNext (): Boolean; inline;
+begin
+ Inc(mCurIdx);
+ result := (mList <> nil) and (mCurIdx < mList.count);
+end;
+
+
+function TDynField.TListEnumerator.getCurrent (): TDynRecord; inline;
+begin
+ result := mList[mCurIdx];
+end;
+
+
+function TDynField.GetEnumerator (): TListEnumerator;
+begin
+ result := TListEnumerator.Create(mRVal);
+end;
// ////////////////////////////////////////////////////////////////////////// //
begin
mRVal := nil;
mRecRef := nil;
+ mRHash := nil;
cleanup();
mName := aname;
mType := atype;
- if (mType = TType.TList) then mRVal := TDynRecList.Create();
+ if (mType = TType.TList) then
+ begin
+ mRVal := TDynRecList.Create();
+ mRHash := hashNewStrInt();
+ end;
end;
mSVal := '';
mRVal.Free();
mRVal := nil;
+ mRHash.Free();
+ mRHash := nil;
mRecRef := nil;
mMaxDim := -1;
mBinOfs := -1;
- mRecOfs := -1;
mSepPosSize := false;
mAsT := false;
mHasDefault := false;
mEBSTypeName := '';
mEBSType := nil;
mBitSetUnique := false;
+ mAsMonsterId := false;
mNegBool := false;
mRecRefId := '';
- if (mType = TType.TList) then mRVal := TDynRecList.Create();
+ mTagInt := 0;
+ mTagPtr := nil;
end;
result.mSVal := mSVal;
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;
+ if (result.mRVal = nil) then result.mRVal := TDynRecList.Create(mRVal.count);
+ if (result.mRHash = nil) then result.mRHash := hashNewStrInt();
+ for rec in mRVal do result.addListItem(rec.clone());
end;
result.mRecRef := mRecRef;
result.mMaxDim := mMaxDim;
result.mBinOfs := mBinOfs;
- result.mRecOfs := mRecOfs;
result.mSepPosSize := mSepPosSize;
result.mAsT := mAsT;
result.mDefined := mDefined;
result.mInternal := mInternal;
result.mNegBool := mNegBool;
result.mBitSetUnique := mBitSetUnique;
+ result.mAsMonsterId := mAsMonsterId;
result.mDefUnparsed := mDefUnparsed;
result.mDefSVal := mDefSVal;
result.mDefIVal := mDefIVal;
result.mEBSTypeName := mEBSTypeName;
result.mEBSType := mEBSType;
result.mRecRefId := mRecRefId;
+ result.mTagInt := mTagInt;
+ result.mTagPtr := mTagPtr;
+end;
+
+
+procedure TDynField.setIVal (v: Integer); inline;
+begin
+ //FIXME: check type
+ mIVal := v;
+ mDefined := true;
end;
end;
+function TDynField.getListCount (): Integer; inline;
+begin
+ if (mRVal <> nil) then result := mRVal.count else result := 0;
+end;
+
+
+function TDynField.getListItem (idx: Integer): TDynRecord; inline; overload;
+begin
+ if (mRVal <> nil) and (idx >= 0) and (idx < mRVal.count) then result := mRVal[idx] else result := nil;
+end;
+
+
+function TDynField.getListItem (const aname: AnsiString): TDynRecord; inline; overload;
+var
+ idx: Integer;
+begin
+ if (mRVal <> nil) and mRHash.get(aname, idx) then result := mRVal[idx] else result := nil;
+end;
+
+
+function TDynField.addListItem (rec: TDynRecord): Boolean; inline;
+begin
+ result := false;
+ if (mRVal <> nil) then
+ begin
+ mRVal.append(rec);
+ if (Length(rec.mId) > 0) then result := mRHash.put(rec.mId, mRVal.count-1);
+ end;
+end;
+
+
class function TDynField.getTypeName (t: TType): AnsiString;
begin
case t of
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]);
+ if (mBinOfs >= 0) then result += Format(' offset %d', [mBinOfs]);
case mEBS of
TEBS.TNone: begin end;
TEBS.TRec: result += ' '+mEBSTypeName;
TEBS.TEnum: result += ' enum '+mEBSTypeName;
TEBS.TBitSet: begin result += ' bitset '; if mBitSetUnique then result += 'unique '; result += mEBSTypeName; end;
end;
+ if mAsMonsterId then result += ' as monsterid';
if mHasDefault and (Length(mDefUnparsed) > 0) then result += ' default '+mDefUnparsed;
if mSepPosSize then
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;
lmaxdim: Integer;
lebs: TDynField.TEBS;
unique: Boolean;
+ asmonid: Boolean;
begin
fldpasname := '';
fldname := '';
hasdefInt := false;
hasdefId := false;
unique := false;
+ asmonid := false;
lmaxdim := -1;
lebs := TDynField.TEBS.TNone;
else if pr.eatId('wh') then aswh := true
else if pr.eatId('txy') then begin asxy := true; ast := true; end
else if pr.eatId('twh') then begin aswh := true; ast := true; end
+ else if pr.eatId('monsterid') then begin asmonid := true; end
else raise Exception.Create(Format('invalid field ''%s'' as what?', [fldname]));
continue;
end;
self.mEBS := lebs;
self.mEBSTypeName := fldrecname;
self.mBitSetUnique := unique;
+ self.mAsMonsterId := asmonid;
self.mMaxDim := lmaxdim;
self.mBinOfs := fldofs;
- self.mRecOfs := fldofs;
self.mSepPosSize := (asxy or aswh);
self.mAsT := ast;
self.mOmitDef := omitdef;
end;
+function TDynField.getRecRefIndex (): Integer;
+begin
+ if (mRecRef = nil) then begin result := -1; exit; end;
+ result := mOwner.findRecordNumByType(mEBSTypeName, mRecRef);
+end;
+
+
procedure TDynField.writeBinTo (st: TStream);
var
s: AnsiString;
exit;
end;
// record reference
- 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;
case mType of
TType.TByte: maxv := 127;
TType.TUByte: maxv := 254;
else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
end;
// find record number
- 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]));
+ 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 mAsMonsterId then Inc(f);
+ if (f > maxv) then raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' has too big index', [mEBSTypeName, mName]));
+ end
+ else
+ begin
+ if mAsMonsterId then f := 0 else 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;
raise Exception.Create(Format('cannot parse field ''%s'' yet', [mName]));
end;
+
procedure TDynField.parseBinValue (st: TStream);
var
rec, rc: TDynRecord;
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 mAsMonsterId then Dec(f);
if (f < 0) then mRecRefId := '' else mRecRefId := Format('%s%d', [mEBSTypeName, f]);
end;
mDefined := true;
es: TDynEBS = nil;
tfld: TDynField;
tk: AnsiString;
+ edim: AnsiChar;
begin
// if this field should contain struct, convert type and parse struct
case mEBS of
rc.parseValue(pr);
mRecRef := rc;
mDefined := true;
- mOwner.addRecordByType(mEBSTypeName, rc);
+ if mOwner.addRecordByType(mEBSTypeName, rc) then
+ begin
+ //raise Exception.Create(Format('record type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
+ e_LogWritefln('duplicate record with id ''%s'' for field ''%s'' in record ''%s''', [rc.mId, mName, mOwner.mName]);
+ end;
pr.eatTT(pr.TTSemi); // hack: allow (but don't require) semicolon after inline records
exit;
end;
TType.TPoint,
TType.TSize:
begin
- pr.expectDelim('(');
+ if pr.eatDelim('[') then edim := ']' else begin pr.expectDelim('('); edim := ')'; end;
mIVal := pr.expectInt();
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;
mName := '';
mSize := 0;
mFields := TDynFieldList.Create();
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ mFieldsHash := hashNewStrInt();
+ {$ENDIF}
mTrigTypes := nil;
mHeader := false;
mHeaderRec := nil;
mBinBlock := -1;
+ mTagInt := 0;
+ mTagPtr := nil;
parseDef(pr);
end;
mName := '';
mSize := 0;
mFields := TDynFieldList.Create();
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ mFieldsHash := hashNewStrInt();
+ {$ENDIF}
mTrigTypes := nil;
mHeader := false;
mHeaderRec := nil;
+ mTagInt := 0;
+ mTagPtr := nil;
end;
mName := '';
mFields.Free();
mFields := nil;
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ mFieldsHash.Free();
+ mFieldsHash := nil;
+ {$ENDIF}
mTrigTypes := nil;
mHeaderRec := nil;
+ mTagInt := 0;
+ mTagPtr := nil;
inherited;
end;
+procedure TDynRecord.addField (fld: TDynField); inline;
+begin
+ if (fld = nil) then raise Exception.Create('cannot append nil field to record');
+ mFields.append(fld);
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ if (Length(fld.mName) > 0) then mFieldsHash.put(fld.mName, mFields.count-1);
+ {$ENDIF}
+end;
+
+
+function TDynRecord.addFieldChecked (fld: TDynField): Boolean; inline; // `true`: duplicate name
+begin
+ result := false;
+ if (fld = nil) then raise Exception.Create('cannot append nil field to record');
+ {$IF not DEFINED(XDYNREC_USE_FIELDHASH)}
+ if (Length(fld.mName) > 0) then result := hasByName(fld.mName);
+ {$ENDIF}
+ mFields.append(fld);
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ if (Length(fld.mName) > 0) then result := mFieldsHash.put(fld.mName, mFields.count-1);
+ {$ENDIF}
+end;
+
+
function TDynRecord.findByName (const aname: AnsiString): Integer; inline;
begin
+ {$IF DEFINED(XDYNREC_USE_FIELDHASH)}
+ if not mFieldsHash.get(aname, result) then result := -1;
+ {$ELSE}
result := 0;
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;
+ {$ENDIF}
end;
end;
+function TDynRecord.getFieldAt (idx: Integer): TDynField; inline;
+begin
+ if (idx >= 0) and (idx < mFields.count) then result := mFields[idx] else result := nil;
+end;
+
+
+function TDynRecord.getCount (): Integer; inline;
+begin
+ result := mFields.count;
+end;
+
+
function TDynRecord.getIsTrigData (): Boolean; inline;
begin
result := (Length(mTrigTypes) > 0);
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.getForTrigCount (): Integer; inline;
+begin
+ result := Length(mTrigTypes);
+end;
+
+
+function TDynRecord.getForTrigAt (idx: Integer): AnsiString; inline;
+begin
+ if (idx >= 0) and (idx < Length(mTrigTypes)) then result := mTrigTypes[idx] else result := '';
+end;
+
+
function TDynRecord.clone (): TDynRecord;
var
fld: TDynField;
if (mFields.count > 0) then
begin
result.mFields.capacity := mFields.count;
- for fld in mFields do result.mFields.append(fld.clone(result));
+ for fld in mFields do result.addField(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;
+ result.mTagInt := mTagInt;
+ result.mTagPtr := mTagPtr;
end;
function TDynRecord.findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
var
fld: TDynField;
- rec: TDynRecord;
+ idx: Integer;
begin
result := nil;
if (Length(aid) = 0) then exit;
// find by id
if (fld.mRVal <> nil) then
begin
- for rec in fld.mRVal do
- begin
- if (CompareText(rec.mId, aid) = 0) then begin result := rec; exit; end;
- end;
+ if fld.mRHash.get(aid, idx) then begin result := fld.mRVal[idx]; exit; end;
end;
// alas
end;
function TDynRecord.findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
var
fld: TDynField;
- f: Integer;
+ idx: Integer;
begin
result := -1;
// find record data
// find by ref
if (fld.mRVal <> nil) then
begin
- for f := 0 to fld.mRVal.count-1 do
+ for idx := 0 to fld.mRVal.count-1 do
begin
- if (fld.mRVal[f] = rc) then begin result := f; exit; end;
+ if (fld.mRVal[idx] = rc) then begin result := idx; exit; end;
end;
end;
// alas
end;
-procedure TDynRecord.addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+function TDynRecord.addRecordByType (const atypename: AnsiString; rc: TDynRecord): Boolean;
var
fld: TDynField;
begin
// first record
fld := TDynField.Create(atypename, TDynField.TType.TList);
fld.mOwner := mHeaderRec;
- mHeaderRec.mFields.append(fld);
+ mHeaderRec.addField(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);
+ if (fld.mRVal = nil) then
+ begin
+ fld.mRVal := TDynRecList.Create();
+ fld.mRHash := hashNewStrInt();
+ end;
+ result := fld.addListItem(rc);
end;
if not (fld.mEBSType is TDynEBS) then continue;
es := (fld.mEBSType as TDynEBS);
assert(es <> nil);
- if (CompareText(es.mName, 'TriggerType') = 0) then begin result := fld; exit; end;
+ 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;
+
+
procedure TDynRecord.parseDef (pr: TTextParser);
var
fld: TDynField;
while (pr.tokType <> pr.TTEnd) do
begin
fld := TDynField.Create(pr);
- if hasByName(fld.name) then begin fld.Free(); raise Exception.Create(Format('duplicate field ''%s''', [fld.name])); end;
+ //if hasByName(fld.name) then begin fld.Free(); raise Exception.Create(Format('duplicate field ''%s''', [fld.name])); end;
// append
fld.mOwner := self;
- mFields.append(fld);
+ if addFieldChecked(fld) then
+ begin
+ fld.Free();
+ raise Exception.Create(Format('duplicate field ''%s''', [fld.name]));
+ end;
// done with field
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;
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]));
+ if (rt = nil) then
+ begin
+ 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);
+ //raise Exception.Create(Format('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]));
+ end;
//writeln(' ', rec.mName, '.', rec.mId, ':', fld.mName, ' -> ', rt.mName, '.', rt.mId, ' (', fld.mEBSTypeName, '.', fld.mRecRefId, ')');
fld.mRecRefId := '';
fld.mRecRef := rt;
if (btype = 0) then break; // no more blocks
readLongWord(st); // reserved
bsize := readLongInt(st);
- writeln('btype=', btype, '; bsize=', bsize);
+ {$IF DEFINED(D2D_XDYN_DEBUG)}writeln('btype=', btype, '; bsize=', bsize);{$ENDIF}
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;
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);
+ //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
// create list for this type
fld := TDynField.Create(rec.mName, TDynField.TType.TList);
fld.mOwner := self;
- mFields.append(fld);
+ addField(fld);
if (bsize > 0) then
begin
GetMem(buf, bsize);
rec.mHeaderRec := self;
rec.parseBinValue(mst);
rec.mId := Format('%s%d', [rec.mName, f]);
- fld.mRVal.append(rec);
+ fld.addListItem(rec);
//writeln('parsed ''', rec.mId, '''...');
end;
end;
end;
// read fields
- if (CompareText(mName, 'TriggerData') = 0) then mSize := Integer(st.size-st.position);
+ 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);
end;
-procedure TDynRecord.writeBinTo (st: TStream; trigbufsz: Integer=-1);
+procedure TDynRecord.writeBinTo (st: TStream; trigbufsz: Integer=-1; onlyFields: Boolean=false);
var
fld: TDynField;
rec, rv: TDynRecord;
end;
// write block with normal fields
- if mHeader then
+ if mHeader and not onlyFields then
begin
//writeln('writing header...');
// signature and version
FreeMem(buf); buf := nil;
// write other blocks, if any
- if mHeader then
+ if mHeader and not onlyFields then
begin
// calculate blkmax
blkmax := 0;
end;
+{$IF DEFINED(D2D_DYNREC_PROFILER)}
+var
+ profCloneRec: UInt64 = 0;
+ profFindRecType: UInt64 = 0;
+ profFieldSearching: UInt64 = 0;
+ profListDupChecking: UInt64 = 0;
+ profAddRecByType: UInt64 = 0;
+ profFieldValParsing: UInt64 = 0;
+ profFixDefaults: UInt64 = 0;
+ profRecValParse: UInt64 = 0;
+
+procedure xdynDumpProfiles ();
+begin
+ writeln('=== XDYNREC PROFILES ===');
+ writeln('record cloning: ', profCloneRec div 1000, '.', profCloneRec mod 1000, ' milliseconds');
+ writeln('findRecType : ', profFindRecType div 1000, '.', profFindRecType mod 1000, ' milliseconds');
+ writeln('field[] : ', profFieldSearching div 1000, '.', profFieldSearching mod 1000, ' milliseconds');
+ writeln('list dup check: ', profListDupChecking div 1000, '.', profListDupChecking mod 1000, ' milliseconds');
+ writeln('addRecByType : ', profAddRecByType div 1000, '.', profAddRecByType mod 1000, ' milliseconds');
+ writeln('field valparse: ', profFieldValParsing div 1000, '.', profFieldValParsing mod 1000, ' milliseconds');
+ writeln('fix defaults : ', profFixDefaults div 1000, '.', profFixDefaults mod 1000, ' milliseconds');
+ writeln('recvalparse : ', profRecValParse div 1000, '.', profRecValParse mod 1000, ' milliseconds');
+end;
+{$ENDIF}
+
+
procedure TDynRecord.parseValue (pr: TTextParser; beginEaten: Boolean=false);
var
fld: TDynField;
- rec, trc, rv: TDynRecord;
+ rec: TDynRecord = nil;
+ trc{, rv}: TDynRecord;
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}
+ stt, stall: UInt64;
+ {$ENDIF}
begin
if (mOwner = nil) then raise Exception.Create(Format('can''t parse record ''%s'' value without owner', [mName]));
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stall := curTimeMicro();{$ENDIF}
+
// not a header?
if not mHeader then
begin
if mHeader then
begin
// add records with this type (if any)
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
trc := mOwner.findRecType(pr.tokStr);
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profFindRecType := curTimeMicro()-stt;{$ENDIF}
if (trc <> nil) then
begin
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
rec := trc.clone();
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profCloneRec := curTimeMicro()-stt;{$ENDIF}
rec.mHeaderRec := mHeaderRec;
try
pr.skipToken();
rec.parseValue(pr);
+ (*
if (Length(rec.mId) > 0) then
begin
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
fld := field[pr.tokStr];
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profFieldSearching := curTimeMicro()-stt;{$ENDIF}
+ (*
if (fld <> nil) and (fld.mRVal <> nil) then
begin
- for rv in fld.mRVal do
- begin
- if (Length(rv.mId) > 0) and (CompareText(rv.mId, rec.mId) = 0) then raise Exception.Create(Format('duplicate thing ''%s'' in record ''%s''', [fld.mName, mName]));
- end;
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
+ //idtmp := trc.mName+':'+rec.mId;
+ //if ids.put(idtmp, 1) then raise Exception.Create(Format('duplicate thing ''%s'' in record ''%s''', [fld.mName, mName]));
+ if fld.mRHash.has(rec.mId) then raise Exception.Create(Format('duplicate thing ''%s'' in record ''%s''', [fld.mName, mName]));
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profListDupChecking := curTimeMicro()-stt;{$ENDIF}
end;
end;
+ *)
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
addRecordByType(rec.mName, rec);
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profAddRecByType := curTimeMicro()-stt;{$ENDIF}
rec := nil;
finally
rec.Free();
end;
// fields
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
fld := field[pr.tokStr];
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profFieldSearching := curTimeMicro()-stt;{$ENDIF}
if (fld <> nil) then
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();
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
fld.parseValue(pr);
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profFieldValParsing := curTimeMicro()-stt;{$ENDIF}
continue;
end;
end;
pr.expectTT(pr.TTEnd);
// fix field defaults
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}stt := curTimeMicro();{$ENDIF}
for fld in mFields do fld.fixDefaultValue();
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profFixDefaults := curTimeMicro()-stt;{$ENDIF}
//writeln('done parsing record <', mName, '>');
+ //{$IF DEFINED(D2D_DYNREC_PROFILER)}writeln('stall: ', curTimeMicro()-stall);{$ENDIF}
+ {$IF DEFINED(D2D_DYNREC_PROFILER)}profRecValParse := curTimeMicro()-stall;{$ENDIF}
end;
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;
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;
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;
begin
for rec in recTypes do
begin
- if (CompareText(rec.name, aname) = 0) then begin result := rec; exit; end;
+ if StrEqu(rec.name, aname) then begin result := rec; exit; end;
end;
result := nil;
end;
begin
for ebs in ebsTypes do
begin
- if (CompareText(ebs.name, aname) = 0) then begin result := ebs; exit; end;
+ if StrEqu(ebs.name, aname) then begin result := ebs; exit; end;
end;
result := nil;
end;
rec := TDynRecord.Create(pr);
//writeln(dr.definition); writeln;
if (findRecType(rec.name) <> nil) then begin rec.Free(); raise Exception.Create(Format('duplicate record ''%s''', [rec.name])); end;
- if (hdr <> nil) and (CompareText(rec.name, hdr.name) = 0) 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
res.parseValue(pr);
result := res;
res := nil;
- except on E: Exception do
- begin
- res.Free();
- raise;
- end;
+ finally
+ res.Free();
end;
end;
res.parseBinValue(st);
result := res;
res := nil;
- except on E: Exception do
+ finally
+ res.Free();
+ 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
- res.Free();
- raise;
+ if fld.mInternal then continue;
+ if (fld.mBinOfs < 0) then continue;
+ result += ' '+fld.pasdef+#10;
end;
+ result += ' );'#10;
end;
+ result += ' end;'#10;
end;
+function TDynMapDef.pasdefconst (): AnsiString;
+var
+ ebs: TDynEBS;
+begin
+ result := '';
+ result += '// ////////////////////////////////////////////////////////////////////////// //'#10;
+ result += '// enums and bitsets'#10;
+ for ebs in ebsTypes do result += #10+ebs.pasdef();
+end;
+
+
+function TDynMapDef.getTrigTypeCount (): Integer; inline; begin result := trigTypes.count; end;
+function TDynMapDef.getTrigTypeAt (idx: Integer): TDynRecord; inline; begin if (idx >= 0) and (idx < trigTypes.count) then result := trigTypes[idx] else result := nil; end;
+
+
end.