summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: e57a9cd)
raw | patch | inline | side by side (parent: e57a9cd)
| author | Ketmar Dark <ketmar@ketmar.no-ip.org> | |
| Sat, 26 Aug 2017 05:10:16 +0000 (08:10 +0300) | ||
| committer | Ketmar Dark <ketmar@ketmar.no-ip.org> | |
| Sat, 26 Aug 2017 05:12:37 +0000 (08:12 +0300) |
| src/shared/xdynrec.pas | patch | blob | history | |
| src/shared/xstreams.pas | patch | blob | history |
diff --git a/src/shared/xdynrec.pas b/src/shared/xdynrec.pas
index 0774c1356388d2f16354d0f36208a72c5b623f10..0773ab01bcab7866a0d682481f2a5dc60f9ead8f 100644 (file)
--- a/src/shared/xdynrec.pas
+++ b/src/shared/xdynrec.pas
interface
uses
- xparser, Classes;
+ Classes,
+ xparser, xstreams;
// ////////////////////////////////////////////////////////////////////////// //
mSVal: AnsiString; // string; for byte and char arrays
mRVal: TDynRecordArray; // for list
mRecRef: TDynRecord; // for record
- mRecRefOwned: Boolean; // was mRecRef created from inline definition?
+ //mRecRefOwned: Boolean; // was mRecRef created from inline definition?
mMaxDim: Integer; // for byte and char arrays; <0: not an array
mBinOfs: Integer; // offset in binary; <0 - none
mRecOfs: Integer; // offset in record; <0 - none
// default values
mDefSVal: AnsiString;
mEBS: TEBS;
- mEBSName: AnsiString; // name of enum, bitset or record
+ mEBSTypeName: AnsiString; // name of enum, bitset or record
mBitSetUnique: Boolean; // bitset can contain only one value
mNegBool: Boolean;
function clone (): TDynField;
procedure parseValue (pr: TTextParser);
+ procedure parseBinValue (st: TStream);
procedure writeTo (wr: TTextWriter);
+ procedure writeBinTo (st: TStream);
// won't work for lists
function isSimpleEqu (fld: TDynField): Boolean;
property hasDefault: Boolean read mHasDefault;
property defsval: AnsiString read mDefSVal write mDefSVal;
property ebs: TEBS read mEBS write mEBS;
- property ebsname: AnsiString read mEBSName write mEBSName; // enum/bitset name
+ property ebstypename: AnsiString read mEBSTypeName write mEBSTypeName; // enum/bitset name
property x: Integer read mIVal;
property w: Integer read mIVal;
function clone (): TDynRecord;
procedure parseValue (pr: TTextParser; asheader: Boolean=false);
+ procedure parseBinValue (st: TStream);
procedure writeTo (wr: TTextWriter; putHeader: Boolean=true);
+ procedure writeBinTo (st: TStream; trigbufsz: Integer=-1);
public
property id: AnsiString read mId; // for map parser
curheader: TDynRecord; // for parser
private
- function findRecordById (const atypename, aid: AnsiString): TDynRecord;
+ procedure addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+ function findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
+ function findRecordNumByType (const atypename: AnsiString; rc: TDynRecord): Integer;
public
records: array of TDynRecord; // [0] is always header
function getHeader (): TDynRecord; inline;
public
- constructor Create (pr: TTextParser);
+ constructor Create (pr: TTextParser); // parses data definition
destructor Destroy (); override;
function findRec (const aname: AnsiString): TDynRecord;
function parseMap (pr: TTextParser): TDynRecord;
+ function parseBinMap (st: TStream): TDynRecord;
+
public
property header: TDynRecord read getHeader;
end;
implementation
uses
- SysUtils;
+ SysUtils,
+ utils;
// ////////////////////////////////////////////////////////////////////////// //
begin
mRVal := nil;
mRecRef := nil;
- mRecRefOwned := false;
+ //mRecRefOwned := false;
cleanup();
mName := aname;
mType := atype;
mIVal2 := 0;
mSVal := '';
mRVal := nil;
- if mRecRefOwned then mRecRef.Free();
+ //if mRecRefOwned then mRecRef.Free();
mRecRef := nil;
- mRecRefOwned := false;
+ //mRecRefOwned := false;
mMaxDim := -1;
mBinOfs := -1;
mRecOfs := -1;
mInternal := true;
mDefSVal := '';
mEBS := TEBS.TNone;
- mEBSName := '';
+ mEBSTypeName := '';
mBitSetUnique := false;
mNegBool := false;
mDefId := '';
result.mSVal := mSVal;
SetLength(result.mRVal, Length(mRVal));
for f := 0 to High(mRVal) do result.mRVal[f] := mRVal[f].clone();
+ result.mRecRef := mRecRef;
+ {
result.mRecRefOwned := mRecRefOwned;
if mRecRefOwned then
begin
begin
result.mRecRef := mRecRef;
end;
+ }
result.mMaxDim := mMaxDim;
result.mBinOfs := mBinOfs;
result.mRecOfs := mRecOfs;
result.mInternal := mInternal;
result.mDefSVal := mDefSVal;
result.mEBS := mEBS;
- result.mEBSName := mEBSName;
+ result.mEBSTypeName := mEBSTypeName;
result.mBitSetUnique := mBitSetUnique;
result.mNegBool := mNegBool;
result.mDefId := mDefId;
if (mRecOfs >= 0) then result += Format(' offset %d', [mRecOfs]);
case mEBS of
TEBS.TNone: begin end;
- TEBS.TRec: result += ' '+mEBSName;
- TEBS.TEnum: result += ' enum '+mEBSName;
- TEBS.TBitSet: begin result += ' bitset '; if mBitSetUnique then result += 'unique '; result += mEBSName; 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 mHasDefault then
begin
self.mHasDefault := (hasdefStr or hasdefId or hasdefInt);
self.mPasName := fldpasname;
self.mEBS := lebs;
- self.mEBSName := fldrecname;
+ self.mEBSTypeName := fldrecname;
self.mBitSetUnique := unique;
self.mMaxDim := lmaxdim;
self.mBinOfs := fldofs;
end;
+procedure TDynField.writeBinTo (st: TStream);
+var
+ s: AnsiString;
+ f: Integer;
+ maxv: Integer;
+ buf: PByte;
+ ws: TStream = nil;
+begin
+ case mEBS of
+ 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
+ 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
+ FillChar(buf^, mMaxDim, 0);
+ if (mRecRef <> nil) then
+ begin
+ ws := TSFSMemoryChunkStream.Create(buf, mMaxDim);
+ mRecRef.writeBinTo(ws, mMaxDim); // as trigdata
+ end;
+ st.WriteBuffer(buf^, mMaxDim);
+ finally
+ ws.Free();
+ if (buf <> nil) then FreeMem(buf);
+ 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;
+ case mType of
+ TType.TByte: maxv := 127;
+ TType.TUByte: maxv := 254;
+ TType.TShort: maxv := 32767;
+ TType.TUShort: maxv := 65534;
+ TType.TInt: maxv := $7fffffff;
+ TType.TUInt: maxv := $7fffffff;
+ 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);
+ 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]));
+ 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));
+ else raise Exception.Create(Format('record reference type ''%s'' in field ''%s'' cannot be written', [mEBSTypeName, mName]));
+ end;
+ exit;
+ end;
+ TEBS.TEnum: begin end;
+ TEBS.TBitSet: begin end;
+ else raise Exception.Create('ketmar forgot to handle some EBS type');
+ end;
+
+ case mType of
+ TType.TBool:
+ begin
+ if (mIVal <> 0) then writeInt(st, Byte(1)) else writeInt(st, Byte(0));
+ exit;
+ end;
+ TType.TChar:
+ begin
+ if (mMaxDim = 0) then raise Exception.Create(Format('invalid string size definition for field ''%s''', [mName]));
+ if (mMaxDim < 0) then
+ begin
+ if (Length(mSVal) <> 1) then raise Exception.Create(Format('invalid string size definition for field ''%s''', [mName]));
+ writeInt(st, Byte(mSVal[1]));
+ end
+ 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));
+ if (Length(s) > 0) then st.WriteBuffer(PChar(s)^, Length(s));
+ for f := Length(s) to mMaxDim do writeInt(st, Byte(0));
+ end;
+ exit;
+ end;
+ 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;
+ exit;
+ end;
+ TType.TShort,
+ TType.TUShort:
+ begin
+ 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]));
+ writeInt(st, LongWord(mIVal));
+ exit;
+ end;
+ TType.TString:
+ begin
+ raise Exception.Create(Format('cannot write string field ''%s''', [mName]));
+ end;
+ TType.TPoint,
+ TType.TSize:
+ begin
+ 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;
+ 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;
+end;
+
+
procedure TDynField.writeTo (wr: TTextWriter);
var
def: TDynMapDef;
begin
wr.put('null;'#10);
end
- else if mRecRefOwned then
+ else if (Length(mRecRef.mId) = 0) then
begin
mRecRef.writeTo(wr, false); // only data, no header
end
TEBS.TEnum:
begin
def := mOwner.mOwner;
- es := def.findEBS(mEBSName);
- if (es = nil) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSName, mName]));
+ es := def.findEBS(mEBSTypeName);
+ if (es = nil) 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
exit;
end;
end;
- raise Exception.Create(Format('value %d in record enum type ''%s'' for field ''%s'' not found', [mIVal, mEBSName, mName]));
+ raise Exception.Create(Format('value %d in record enum type ''%s'' for field ''%s'' not found', [mIVal, mEBSTypeName, mName]));
end;
TEBS.TBitSet:
begin
def := mOwner.mOwner;
- es := def.findEBS(mEBSName);
- if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSName, mName]));
+ es := def.findEBS(mEBSTypeName);
+ if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
// none?
if (mIVal = 0) then
begin
exit;
end;
end;
- raise Exception.Create(Format('value %d in record bitset type ''%s'' for field ''%s'' not found', [0, mEBSName, mName]));
+ raise Exception.Create(Format('value %d in record bitset type ''%s'' for field ''%s'' not found', [0, mEBSTypeName, mName]));
end;
// not none
mask := 1;
break;
end;
end;
- if not found then raise Exception.Create(Format('value %d in record bitset type ''%s'' for field ''%s'' not found', [mask, mEBSName, mName]));
+ if not found then raise Exception.Create(Format('value %d in record bitset type ''%s'' for field ''%s'' not found', [mask, mEBSTypeName, mName]));
end;
mask := mask shl 1;
end;
begin
def := mOwner.mOwner;
// ugly hack. sorry.
- if (CompareText(mEBSName, 'triggerdata') = 0) then
+ if (CompareText(mEBSTypeName, 'triggerdata') = 0) then
begin
rec := mOwner;
// find trigger definition
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);
- if mRecRefOwned then mRecRef.Free();
- mRecRefOwned := true;
+ //if mRecRefOwned then mRecRef.Free();
+ //mRecRefOwned := true;
mRecRef := rc;
mDefined := true;
exit;
// other record types
if (pr.tokType = pr.TTId) then
begin
- rec := def.findRecordById(mEBSName, pr.tokStr);
- if (rec = nil) then raise Exception.Create(Format('record ''%s'' (%s) value for field ''%s'' not found', [pr.tokStr, mEBSName, mName]));
+ rec := def.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();
- if mRecRefOwned then mRecRef.Free();
- mRecRefOwned := false;
+ //if mRecRefOwned then mRecRef.Free();
+ //mRecRefOwned := false;
mRecRef := rec;
mDefined := true;
pr.expectTT(pr.TTSemi);
end
else if (pr.tokType = pr.TTBegin) then
begin
- rec := def.findRec(mEBSName);
- if (rec = nil) then raise Exception.Create(Format('record type ''%s'' for field ''%s'' not found', [mEBSName, mName]));
+ rec := def.findRec(mEBSTypeName);
+ if (rec = nil) then raise Exception.Create(Format('record type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
rc := rec.clone();
rc.parseValue(pr);
- if mRecRefOwned then mRecRef.Free();
- mRecRefOwned := true;
+ //if mRecRefOwned then mRecRef.Free();
+ //mRecRefOwned := true;
mRecRef := rc;
mDefined := true;
+ mOwner.mOwner.addRecordByType(mEBSTypeName, rc);
exit;
end;
pr.expectTT(pr.TTBegin);
TEBS.TEnum:
begin
def := mOwner.mOwner;
- es := def.findEBS(mEBSName);
- if (es = nil) then raise Exception.Create(Format('record enum type ''%s'' for field ''%s'' not found', [mEBSName, mName]));
+ es := def.findEBS(mEBSTypeName);
+ if (es = nil) 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, mEBSName, mName]));
+ 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];
mSVal := tk;
//writeln('ENUM ', mEBSName, '; element <', mSVal, '> with value ', mIVal);
TEBS.TBitSet:
begin
def := mOwner.mOwner;
- es := def.findEBS(mEBSName);
- if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSName, mName]));
+ es := def.findEBS(mEBSTypeName);
+ if (es = nil) then raise Exception.Create(Format('record bitset type ''%s'' for field ''%s'' not found', [mEBSTypeName, mName]));
mIVal := 0;
while true do
begin
tk := pr.expectId();
- if not es.has[tk] then raise Exception.Create(Format('record bitset value ''%s'' of type ''%s'' for field ''%s'' not found', [tk, mEBSName, mName]));
+ if not es.has[tk] then raise Exception.Create(Format('record bitset value ''%s'' of type ''%s'' for field ''%s'' not found', [tk, mEBSTypeName, mName]));
mIVal := mIVal or es.field[tk];
mSVal := tk;
if (pr.tokType <> pr.TTDelim) or ((pr.tokChar <> '|') and (pr.tokChar <> '+')) then break;
- if mBitSetUnique then raise Exception.Create(Format('record bitset of type ''%s'' for field ''%s'' expects only one value', [tk, mEBSName, mName]));
+ if mBitSetUnique then raise Exception.Create(Format('record bitset of type ''%s'' for field ''%s'' expects only one value', [tk, mEBSTypeName, mName]));
//pr.expectDelim('|');
pr.skipToken(); // plus or pipe
end;
end;
+procedure TDynField.parseBinValue (st: TStream);
+begin
+end;
+
+
// ////////////////////////////////////////////////////////////////////////// //
constructor TDynRecord.Create (pr: TTextParser);
begin
result.mName := mName;
result.mSize := mSize;
result.mHeader := mHeader;
+ result.mBinBlock := mBinBlock;
SetLength(result.mFields, Length(mFields));
for f := 0 to High(mFields) do
begin
end;
+procedure TDynRecord.writeBinTo (st: TStream; trigbufsz: Integer=-1);
+var
+ fld: TDynField;
+ rec: TDynRecord;
+ buf: PByte = nil;
+ ws: TStream = nil;
+ blk, blkmax: Integer;
+ f, c: Integer;
+ oldh: TDynRecord;
+ bufsz: Integer = 0;
+begin
+ if (trigbufsz < 0) then
+ begin
+ if (mBinBlock < 1) then raise Exception.Create('cannot write binary record without block number');
+ if (mSize < 1) then raise Exception.Create('cannot write binary record without size');
+ bufsz := mSize;
+ end
+ else
+ begin
+ bufsz := trigbufsz;
+ end;
+ oldh := mOwner.curheader;
+ if mHeader then
+ begin
+ if (mOwner.curheader <> nil) then raise Exception.Create('`writeBinTo()` cannot be called recursively');
+ mOwner.curheader := self;
+ end;
+ try
+ GetMem(buf, bufsz);
+ FillChar(buf^, bufsz, 0);
+ ws := TSFSMemoryChunkStream.Create(buf, bufsz);
+
+ // write normal fields
+ for f := 0 to High(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);
+ end;
+
+ // write block with normal fields
+ if mHeader then
+ begin
+ writeln('writing header...');
+ // signature and version
+ writeIntBE(st, LongWord($4D415001));
+ writeInt(st, Byte(mBinBlock)); // type
+ writeInt(st, LongWord(0)); // reserved
+ writeInt(st, LongWord(bufsz)); // size
+ end;
+ st.WriteBuffer(buf^, bufsz);
+
+ ws.Free(); ws := nil;
+ FreeMem(buf); buf := nil;
+
+ // write other blocks, if any
+ if mHeader then
+ begin
+ // calculate blkmax
+ blkmax := 0;
+ for f := 0 to High(mFields) do
+ begin
+ fld := mFields[f];
+ // record list?
+ if (fld.mType = fld.TType.TList) then
+ begin
+ if (Length(fld.mRVal) = 0) then continue;
+ rec := mOwner.findRec(fld.mName);
+ if (rec = nil) then continue;
+ if (rec.mBinBlock <= 0) then continue;
+ if (blkmax < rec.mBinBlock) then blkmax := rec.mBinBlock;
+ end;
+ end;
+ // write blocks
+ for blk := 1 to blkmax do
+ begin
+ if (blk = mBinBlock) then continue;
+ ws := nil;
+ for f := 0 to High(mFields) do
+ begin
+ fld := mFields[f];
+ // record list?
+ if (fld.mType = fld.TType.TList) then
+ begin
+ if (Length(fld.mRVal) = 0) then continue;
+ rec := mOwner.findRec(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);
+ end;
+ end;
+ // flush block
+ if (ws <> nil) then
+ begin
+ ws.position := 0;
+ writeInt(st, Byte(blk)); // type
+ writeInt(st, LongWord(0)); // reserved
+ writeInt(st, LongWord(ws.size)); // size
+ st.CopyFrom(ws, ws.size);
+ ws.Free();
+ ws := nil;
+ end;
+ end;
+ end;
+ finally
+ mOwner.curheader := oldh;
+ ws.Free();
+ if (buf <> nil) then FreeMem(buf);
+ end;
+end;
+
+
procedure TDynRecord.writeTo (wr: TTextWriter; putHeader: Boolean=true);
var
f, c: Integer;
var
f, c: Integer;
fld: TDynField;
- rec: TDynRecord;
- success: Boolean;
+ rec, trc: TDynRecord;
+ //success: Boolean;
begin
if (mOwner = nil) then raise Exception.Create(Format('can''t parse record ''%s'' value without owner', [mName]));
if (asheader) then
begin
assert(self = mOwner.curheader);
+ // add records with this type (if any)
+ trc := mOwner.findRec(pr.tokStr);
+ if (trc <> nil) then
+ begin
+ rec := trc.clone();
+ try
+ pr.skipToken();
+ rec.parseValue(pr);
+ if (Length(rec.mId) > 0) then
+ begin
+ fld := field[pr.tokStr];
+ if (fld <> nil) then
+ begin
+ for c := 0 to High(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]));
+ end;
+ end;
+ end;
+ mOwner.addRecordByType(rec.mName, rec);
+ rec := nil;
+ finally
+ rec.Free();
+ end;
+ continue;
+ end;
+ {
success := false;
for f := 0 to High(mOwner.records) do
begin
end;
end;
if success then continue;
+ }
end;
// fields
end;
+procedure TDynRecord.parseBinValue (st: TStream);
+begin
+end;
+
+
// ////////////////////////////////////////////////////////////////////////// //
constructor TDynEBS.Create (pr: TTextParser);
begin
end;
-function TDynMapDef.findRecordById (const atypename, aid: AnsiString): TDynRecord;
+function TDynMapDef.findRecordByTypeId (const atypename, aid: AnsiString): TDynRecord;
var
rec: TDynRecord;
fld: TDynField;
end;
+procedure TDynMapDef.addRecordByType (const atypename: AnsiString; rc: TDynRecord);
+var
+ rec: TDynRecord;
+ fld: TDynField;
+begin
+ assert(curheader <> nil);
+ // find record type
+ rec := findRec(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): Integer;
+var
+ rec: TDynRecord;
+ fld: TDynField;
+ f: Integer;
+begin
+ result := -1;
+ if (curheader = nil) then exit;
+ // find record type
+ rec := findRec(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
+ begin
+ if (fld.mRVal[f] = rc) then
+ begin
+ result := f;
+ exit;
+ end;
+ end;
+ // alas
+end;
+
+
procedure TDynMapDef.parseDef (pr: TTextParser);
var
dr, hdr: TDynRecord;
end;
+function TDynMapDef.parseBinMap (st: TStream): TDynRecord;
+begin
+ result := nil;
+end;
+
+
end.
index 81a104cc9e33be77409318c25766fcdc5b0382b3..346ee9edaa9a81e6b086a74923351ea2365b6bdd 100644 (file)
--- a/src/shared/xstreams.pas
+++ b/src/shared/xstreams.pas
function seek (const offset: Int64; origin: TSeekOrigin): Int64; override;
end;
+ // fixed memory chunk
+ TSFSMemoryChunkStream = class(TCustomMemoryStream)
+ private
+ fFreeMem: Boolean;
+ fMemBuf: PByte;
+ fMemSize: Integer;
+ fCurPos: Integer;
+
+ public
+ // if `pMem` is `nil`, stream will allocate it
+ constructor Create (pMem: Pointer; pSize: Integer; aFreeMem: Boolean=false);
+ destructor Destroy (); override;
+
+ procedure setup (pMem: Pointer; pSize: Integer; aFreeMem: Boolean=false);
+
+ function Seek (const offset: Int64; origin: TSeekOrigin): Int64; override;
+ function Read (var buffer; count: LongInt): LongInt; override;
+ function Write (const buffer; count: LongInt): LongInt; override;
+
+ property chunkSize: Integer read fMemSize;
+ property chunkData: PByte read fMemBuf;
+ end;
+
implementation
end;
+// ////////////////////////////////////////////////////////////////////////// //
+constructor TSFSMemoryChunkStream.Create (pMem: Pointer; pSize: Integer; aFreeMem: Boolean=false);
+begin
+ fMemBuf := nil;
+ fFreeMem := false;
+ fMemSize := 0;
+ fCurPos := 0;
+ setup(pMem, pSize, aFreeMem);
+end;
+
+
+procedure TSFSMemoryChunkStream.setup (pMem: Pointer; pSize: Integer; aFreeMem: Boolean=false);
+begin
+ if fFreeMem then FreeMem(fMemBuf);
+ fMemBuf := nil;
+ fFreeMem := false;
+ fMemSize := 0;
+ fCurPos := 0;
+ if (pSize < 0) then raise XStreamError.Create('invalid chunk size');
+ if (pMem = nil) then
+ begin
+ if (pSize > 0) then
+ begin
+ GetMem(pMem, pSize);
+ if (pMem = nil) then raise XStreamError.Create('out of memory for chunk');
+ aFreeMem := true;
+ end
+ else
+ begin
+ aFreeMem := false;
+ end;
+ end;
+ fFreeMem := aFreeMem;
+ fMemBuf := PByte(pMem);
+ fMemSize := pSize;
+end;
+
+
+destructor TSFSMemoryChunkStream.Destroy ();
+begin
+ if fFreeMem then FreeMem(fMemBuf);
+ inherited;
+end;
+
+
+function TSFSMemoryChunkStream.Seek (const offset: Int64; origin: TSeekOrigin): Int64;
+begin
+ case origin of
+ soBeginning: result := offset;
+ soCurrent: result := offset+fCurPos;
+ soEnd: result := fMemSize+offset;
+ else raise XStreamError.Create('invalid Seek() call');
+ end;
+ if (result < 0) then raise XStreamError.Create('invalid Seek() call');
+ if (result > fMemSize) then result := fMemSize;
+ fCurPos := result;
+end;
+
+
+function TSFSMemoryChunkStream.Read (var buffer; count: LongInt): LongInt;
+var
+ left: Integer;
+begin
+ if (count < 0) then raise XStreamError.Create('negative read');
+ left := fMemSize-fCurPos;
+ if (left < 0) then raise XStreamError.Create('internal error in TSFSMemoryChunkStream (read)');
+ if (count > left) then count := left;
+ if (count > 0) then Move((fMemBuf+fCurPos)^, buffer, count);
+ Inc(fCurPos, count);
+ result := count;
+end;
+
+
+function TSFSMemoryChunkStream.Write (const buffer; count: LongInt): LongInt;
+var
+ left: Integer;
+begin
+ if (count < 0) then raise XStreamError.Create('negative write');
+ left := fMemSize-fCurPos;
+ if (left < 0) then raise XStreamError.Create('internal error in TSFSMemoryChunkStream (write)');
+ if (count > left) then count := left;
+ //writeln('mcs: writing ', count, ' bytes at ofs ', fCurPos, ' (total size is ', fMemSize, ')');
+ if (count > 0) then Move(buffer, (fMemBuf+fCurPos)^, count);
+ Inc(fCurPos, count);
+ result := count;
+end;
+
+
end.