releases/0.32a/Unit2_functions.pas

UNIT Unit2_functions;
INTERFACE
USES Classes, Dialogs, SysUtils, StrUtils, Math,
      Unit3_data;

TYPE
  TExportSet=SET OF (DO_dat,DO_raw,DO_convert,DO_toone);

FUNCTION BoolToStr(bool:Boolean):String;
FUNCTION HexToLong(hex:String):LongWord;
FUNCTION Decode_Int(buffer:Tdata):LongWord;
FUNCTION Encode_Int(input:LongWord):Tdata;
FUNCTION Decode_Float(buffer:Tdata):Single;
FUNCTION Encode_Float(input:Single):Tdata;
FUNCTION DataToBin(data:Tdata):String;
FUNCTION BinToInt(bin:String):Byte;

FUNCTION ExportFile(fileid:LongWord; filename:String; settings:TExportSet; path:String):Integer;

FUNCTION StringSmaller(string1,string2:String):Boolean;

FUNCTION FormatNumber(value:LongWord; width:Byte; leadingzeros:Char):String;
FUNCTION FormatFileSize(size:LongWord):String;
FUNCTION CreateHexString(data:Tdata; HexOnly:Boolean):String;
FUNCTION DecodeHexString(hex:String):Tdata;
FUNCTION GetWinFileName(name:String):String;
FUNCTION GetExtractPath:String;

FUNCTION Explode(_string:String; delimiter:Char):TStringArray;


IMPLEMENTATION
USES Unit4_Exporters, Unit15_Classes;

TYPE
  TValueSwitcher=Record
    CASE IsFloat: Boolean OF
      True: (ValueFloat:Single);
      False: (ValueInt:LongWord);
  END;

FUNCTION BoolToStr(bool:Boolean):String;
  BEGIN
    IF bool THEN
      Result:='true'
    ELSE
      Result:='false';
  END;

FUNCTION HexToLong(hex:String):LongWord;
  FUNCTION NormalizeHexString(VAR hex:String):Boolean;
    VAR
      i:Byte;
    BEGIN
      IF hex[1]='$' THEN BEGIN
        FOR i:=1 TO Length(hex)-1 DO BEGIN
          hex[i]:=hex[i+1];
        END;
        SetLength(hex, Length(hex)-1);
      END;
      IF (hex[1]='0') AND (UpCase(hex[2])='X') THEN BEGIN
        FOR i:=1 TO Length(hex)-2 DO BEGIN
          hex[i]:=hex[i+2];
        END;
        SetLength(hex, Length(hex)-2);
      END;
      IF Length(hex)=0 THEN
        Result:=False
      ELSE
        Result:=True;
    END;
  VAR
    i:Byte;
  BEGIN
    IF NormalizeHexString(hex) THEN BEGIN
      hex:=UpperCase(hex);
      Result:=0;
      FOR i:=1 TO Length(hex) DO BEGIN
        Result:=Result SHL 4;
        CASE hex[i] OF
          '0'..'9': Result:=Result+Ord(hex[i])-48;
          'A'..'F': Result:=Result+Ord(hex[i])-55;
        ELSE
          Result:=0;
          Exit;
        END;
      END;
    END ELSE BEGIN
      Result:=0;
    END;
  END;

FUNCTION Decode_Int(buffer:Tdata):LongWord;
  BEGIN
    Result:=buffer[0]+buffer[1]*256+buffer[2]*256*256+buffer[3]*256*256*256;
  END;
FUNCTION Encode_Int(input:LongWord):Tdata;
  BEGIN
    SetLength(Result,4);
    Result[0]:=input MOD 256;
    input:=input DIV 256;
    Result[1]:=input MOD 256;
    input:=input DIV 256;
    Result[2]:=input MOD 256;
    input:=input DIV 256;
    Result[3]:=input MOD 256;
  END;
FUNCTION Decode_Float(buffer:Tdata):Single;
  VAR _valueswitcher:TValueSwitcher;
  BEGIN
    _valueswitcher.ValueInt:=Decode_Int(buffer);
    Result:=_valueswitcher.ValueFloat;
    IF IsNAN(Result) THEN Result:=0.0;
  END;
FUNCTION Encode_Float(input:Single):Tdata;
  VAR _valueswitcher:TValueSwitcher;
  BEGIN
    _valueswitcher.ValueFloat:=input;
    Result:=Encode_Int(_valueswitcher.ValueInt);
  END;

FUNCTION DataToBin(data:Tdata):String;
  VAR
    i,j:Byte;
    singlebyte:Byte;
    bytepart:String;
  BEGIN
    SetLength(bytepart,8);
    Result:='';
    FOR i:=0 TO High(data) DO BEGIN
      singlebyte:=data[i];
      FOR j:=7 DOWNTO 0 DO BEGIN
        bytepart[j+1]:=Char((singlebyte AND $01)+48);
        singlebyte:=singlebyte SHR 1;
      END;
      Result:=Result+bytepart+' ';
    END;
  END;
FUNCTION BinToInt(bin:String):Byte;
  VAR
    Add: Integer;
    i: Byte;
  BEGIN
    Result:=0;
    IF Length(bin)<>8 THEN Exit;
    Add:=1;
    FOR i:=8 DOWNTO 1 DO BEGIN
      IF NOT (bin[i] IN ['0','1']) THEN Exit;
      IF bin[i] = '1' THEN Inc(Result,Add);
      Add:=Add SHL 1;
    END;
  END;


FUNCTION FormatNumber(value:LongWord; width:Byte; leadingzeros:Char):String;
  BEGIN
    Result:=AnsiReplaceStr(Format('%'+IntToStr(width)+'u',[value]),' ',leadingzeros);
  END;

FUNCTION FormatFileSize(size:LongWord):String;
  BEGIN
    IF size>=1000*1024*1024 THEN BEGIN
      Result:=FloatToStrF(size/1024/1024/1024,ffFixed,5,1)+' GB';
    END ELSE BEGIN
      IF size>=1000*1024 THEN BEGIN
        Result:=FloatToStrF(size/1024/1024,ffFixed,5,1)+' MB';
      END ELSE BEGIN
        IF size>=1000 THEN BEGIN
          Result:=FloatToStrF(size/1024,ffFixed,5,1)+' KB';
        END ELSE BEGIN
          Result:=IntToStr(size)+' B';
        END;
      END;
    END;
  END;

FUNCTION CreateHexString(data:Tdata; HexOnly:Boolean):String;
  VAR
    string_build,ascii_version:String;
    i:LongWord;
  BEGIN
    string_build:='';
    ascii_version:='';
    FOR i:=0 TO High(data) DO BEGIN
      IF NOT HexOnly THEN
        IF (i MOD 16)=0 THEN
          string_build:=string_build+'0x'+IntToHex(i,6)+'  ';
      string_build:=string_build+IntToHex(data[i],2);
      IF NOT HexOnly THEN BEGIN
        IF data[i]>=32 THEN ascii_version:=ascii_version+Chr(data[i])
        ELSE ascii_version:=ascii_version+'.';
        IF ((i+1) MOD 2)=0 THEN string_build:=string_build+#32;
        IF ((i+1) MOD 16)=0 THEN BEGIN
          string_build:=string_build+#32+ascii_version+CrLf;
          ascii_version:='';
        END;
      END;
    END;
    Result:=string_build;
  END;

FUNCTION DecodeHexString(hex:String):Tdata;
  VAR
    i:LongWord;
  BEGIN
    SetLength(Result, Length(hex) DIV 2);
    FOR i:=0 TO Length(Result) DO BEGIN
      Result[i]:=0;
      CASE UpCase(hex[1+i*2]) OF
        '0'..'9': Result[i]:=(Ord(UpCase(hex[1+i*2]))-48)*16;
        'A'..'F': Result[i]:=(Ord(UpCase(hex[1+i*2]))-55)*16;
      END;
      CASE UpCase(hex[1+i*2+1]) OF
        '0'..'9': Result[i]:=Result[i]+(Ord(UpCase(hex[1+i*2+1]))-48);
        'A'..'F': Result[i]:=Result[i]+(Ord(UpCase(hex[1+i*2+1]))-55);
      END;
    END;
  END;


FUNCTION StringSmaller(string1,string2:String):Boolean;
  VAR
    i:Integer;
    len:Integer;
  BEGIN
    len:=Min(Length(string1),Length(string2));
    FOR i:=1 TO len DO
      IF Ord(string1[i])<>Ord(string2[i]) THEN BEGIN
        Result:=Ord(string1[i])<Ord(string2[i]);
        Exit;
      END;
    Result:=Length(string1)<Length(string2);
  END;


FUNCTION ExportFile(fileid:LongWord; filename:String; settings:TExportSet; path:String):Integer;
  VAR
    i:Byte;
    extension:String;
    rawlist:TRawList;
  BEGIN
    Result:=export_noerror;
    extension:=RightStr(filename,4);
    IF DO_toone IN settings THEN BEGIN
      ExportDatFile(fileid,path+'\'+GetWinFileName(filename));
    END ELSE BEGIN
      IF DO_dat IN settings THEN ExportDatFile(fileid,path+'\'+GetWinFileName(filename));
      IF DO_raw IN settings THEN BEGIN
        rawlist:=OniDataConnection.GetRawList(fileid);
        IF Length(rawlist)>0 THEN BEGIN
          FOR i:=0 TO High(rawlist) DO BEGIN
            ExportRawFile(fileid,rawlist[i].src_offset,path+'\'+GetWinFileName(filename));
          END;
        END;
      END;
    END;
  END;

FUNCTION Explode(_string:String; delimiter:Char):TStringArray;
  VAR
    start,len:Word;
  BEGIN
    SetLength(Result, 0);
    start:=1;
    WHILE PosEx(delimiter,_string,start)>0 DO BEGIN
      len:=PosEx(delimiter,_string,start)-start;
      SetLength(Result, Length(Result)+1);
      Result[High(Result)]:=MidStr(_string,start,len);
      start:=start+len+1;
    END;
    SetLength(Result, Length(Result)+1);
    Result[High(Result)]:=MidStr(_string,start,Length(_string)-start+1);
  END;

FUNCTION GetWinFileName(name:String):String;
  BEGIN
    Result:=name;
    Result:=AnsiReplaceStr(Result,'\','__');
    Result:=AnsiReplaceStr(Result,'/','__');
    Result:=AnsiReplaceStr(Result,'>','__');
    Result:=AnsiReplaceStr(Result,'<','__');
  END;

FUNCTION GetExtractPath:String;
  BEGIN
    Result:=ExtractFilePath(OniDataConnection.FileName)+'\extracted_'+ExtractFileName(OniDataConnection.Filename);
  END;


END.
Revision:	35
Committed:	Sat Aug 26 19:20:49 2006 UTC (19 years, 2 months ago) by alloc
Content type:	text/x-pascal
File size:	8231 byte(s)
Log Message:
#	Content
1	UNIT Unit2_functions;
2	INTERFACE
3	USES Classes, Dialogs, SysUtils, StrUtils, Math,
4	Unit3_data;
5
6	TYPE
7	TExportSet=SET OF (DO_dat,DO_raw,DO_convert,DO_toone);
8
9	FUNCTION BoolToStr(bool:Boolean):String;
10	FUNCTION HexToLong(hex:String):LongWord;
11	FUNCTION Decode_Int(buffer:Tdata):LongWord;
12	FUNCTION Encode_Int(input:LongWord):Tdata;
13	FUNCTION Decode_Float(buffer:Tdata):Single;
14	FUNCTION Encode_Float(input:Single):Tdata;
15	FUNCTION DataToBin(data:Tdata):String;
16	FUNCTION BinToInt(bin:String):Byte;
17
18	FUNCTION ExportFile(fileid:LongWord; filename:String; settings:TExportSet; path:String):Integer;
19
20	FUNCTION StringSmaller(string1,string2:String):Boolean;
21
22	FUNCTION FormatNumber(value:LongWord; width:Byte; leadingzeros:Char):String;
23	FUNCTION FormatFileSize(size:LongWord):String;
24	FUNCTION CreateHexString(data:Tdata; HexOnly:Boolean):String;
25	FUNCTION DecodeHexString(hex:String):Tdata;
26	FUNCTION GetWinFileName(name:String):String;
27	FUNCTION GetExtractPath:String;
28
29	FUNCTION Explode(_string:String; delimiter:Char):TStringArray;
30
31
32	IMPLEMENTATION
33	USES Unit4_Exporters, Unit15_Classes;
34
35	TYPE
36	TValueSwitcher=Record
37	CASE IsFloat: Boolean OF
38	True: (ValueFloat:Single);
39	False: (ValueInt:LongWord);
40	END;
41
42	FUNCTION BoolToStr(bool:Boolean):String;
43	BEGIN
44	IF bool THEN
45	Result:='true'
46	ELSE
47	Result:='false';
48	END;
49
50	FUNCTION HexToLong(hex:String):LongWord;
51	FUNCTION NormalizeHexString(VAR hex:String):Boolean;
52	VAR
53	i:Byte;
54	BEGIN
55	IF hex[1]='$' THEN BEGIN
56	FOR i:=1 TO Length(hex)-1 DO BEGIN
57	hex[i]:=hex[i+1];
58	END;
59	SetLength(hex, Length(hex)-1);
60	END;
61	IF (hex[1]='0') AND (UpCase(hex[2])='X') THEN BEGIN
62	FOR i:=1 TO Length(hex)-2 DO BEGIN
63	hex[i]:=hex[i+2];
64	END;
65	SetLength(hex, Length(hex)-2);
66	END;
67	IF Length(hex)=0 THEN
68	Result:=False
69	ELSE
70	Result:=True;
71	END;
72	VAR
73	i:Byte;
74	BEGIN
75	IF NormalizeHexString(hex) THEN BEGIN
76	hex:=UpperCase(hex);
77	Result:=0;
78	FOR i:=1 TO Length(hex) DO BEGIN
79	Result:=Result SHL 4;
80	CASE hex[i] OF
81	'0'..'9': Result:=Result+Ord(hex[i])-48;
82	'A'..'F': Result:=Result+Ord(hex[i])-55;
83	ELSE
84	Result:=0;
85	Exit;
86	END;
87	END;
88	END ELSE BEGIN
89	Result:=0;
90	END;
91	END;
92
93	FUNCTION Decode_Int(buffer:Tdata):LongWord;
94	BEGIN
95	Result:=buffer[0]+buffer[1]256+buffer[2]256256+buffer[3]256256256;
96	END;
97	FUNCTION Encode_Int(input:LongWord):Tdata;
98	BEGIN
99	SetLength(Result,4);
100	Result[0]:=input MOD 256;
101	input:=input DIV 256;
102	Result[1]:=input MOD 256;
103	input:=input DIV 256;
104	Result[2]:=input MOD 256;
105	input:=input DIV 256;
106	Result[3]:=input MOD 256;
107	END;
108	FUNCTION Decode_Float(buffer:Tdata):Single;
109	VAR _valueswitcher:TValueSwitcher;
110	BEGIN
111	_valueswitcher.ValueInt:=Decode_Int(buffer);
112	Result:=_valueswitcher.ValueFloat;
113	IF IsNAN(Result) THEN Result:=0.0;
114	END;
115	FUNCTION Encode_Float(input:Single):Tdata;
116	VAR _valueswitcher:TValueSwitcher;
117	BEGIN
118	_valueswitcher.ValueFloat:=input;
119	Result:=Encode_Int(_valueswitcher.ValueInt);
120	END;
121
122	FUNCTION DataToBin(data:Tdata):String;
123	VAR
124	i,j:Byte;
125	singlebyte:Byte;
126	bytepart:String;
127	BEGIN
128	SetLength(bytepart,8);
129	Result:='';
130	FOR i:=0 TO High(data) DO BEGIN
131	singlebyte:=data[i];
132	FOR j:=7 DOWNTO 0 DO BEGIN
133	bytepart[j+1]:=Char((singlebyte AND $01)+48);
134	singlebyte:=singlebyte SHR 1;
135	END;
136	Result:=Result+bytepart+' ';
137	END;
138	END;
139	FUNCTION BinToInt(bin:String):Byte;
140	VAR
141	Add: Integer;
142	i: Byte;
143	BEGIN
144	Result:=0;
145	IF Length(bin)<>8 THEN Exit;
146	Add:=1;
147	FOR i:=8 DOWNTO 1 DO BEGIN
148	IF NOT (bin[i] IN ['0','1']) THEN Exit;
149	IF bin[i] = '1' THEN Inc(Result,Add);
150	Add:=Add SHL 1;
151	END;
152	END;
153
154
155
156	FUNCTION FormatNumber(value:LongWord; width:Byte; leadingzeros:Char):String;
157	BEGIN
158	Result:=AnsiReplaceStr(Format('%'+IntToStr(width)+'u',[value]),' ',leadingzeros);
159	END;
160
161	FUNCTION FormatFileSize(size:LongWord):String;
162	BEGIN
163	IF size>=100010241024 THEN BEGIN
164	Result:=FloatToStrF(size/1024/1024/1024,ffFixed,5,1)+' GB';
165	END ELSE BEGIN
166	IF size>=1000*1024 THEN BEGIN
167	Result:=FloatToStrF(size/1024/1024,ffFixed,5,1)+' MB';
168	END ELSE BEGIN
169	IF size>=1000 THEN BEGIN
170	Result:=FloatToStrF(size/1024,ffFixed,5,1)+' KB';
171	END ELSE BEGIN
172	Result:=IntToStr(size)+' B';
173	END;
174	END;
175	END;
176	END;
177
178	FUNCTION CreateHexString(data:Tdata; HexOnly:Boolean):String;
179	VAR
180	string_build,ascii_version:String;
181	i:LongWord;
182	BEGIN
183	string_build:='';
184	ascii_version:='';
185	FOR i:=0 TO High(data) DO BEGIN
186	IF NOT HexOnly THEN
187	IF (i MOD 16)=0 THEN
188	string_build:=string_build+'0x'+IntToHex(i,6)+' ';
189	string_build:=string_build+IntToHex(data[i],2);
190	IF NOT HexOnly THEN BEGIN
191	IF data[i]>=32 THEN ascii_version:=ascii_version+Chr(data[i])
192	ELSE ascii_version:=ascii_version+'.';
193	IF ((i+1) MOD 2)=0 THEN string_build:=string_build+#32;
194	IF ((i+1) MOD 16)=0 THEN BEGIN
195	string_build:=string_build+#32+ascii_version+CrLf;
196	ascii_version:='';
197	END;
198	END;
199	END;
200	Result:=string_build;
201	END;
202
203	FUNCTION DecodeHexString(hex:String):Tdata;
204	VAR
205	i:LongWord;
206	BEGIN
207	SetLength(Result, Length(hex) DIV 2);
208	FOR i:=0 TO Length(Result) DO BEGIN
209	Result[i]:=0;
210	CASE UpCase(hex[1+i*2]) OF
211	'0'..'9': Result[i]:=(Ord(UpCase(hex[1+i2]))-48)16;
212	'A'..'F': Result[i]:=(Ord(UpCase(hex[1+i2]))-55)16;
213	END;
214	CASE UpCase(hex[1+i*2+1]) OF
215	'0'..'9': Result[i]:=Result[i]+(Ord(UpCase(hex[1+i*2+1]))-48);
216	'A'..'F': Result[i]:=Result[i]+(Ord(UpCase(hex[1+i*2+1]))-55);
217	END;
218	END;
219	END;
220
221
222
223	FUNCTION StringSmaller(string1,string2:String):Boolean;
224	VAR
225	i:Integer;
226	len:Integer;
227	BEGIN
228	len:=Min(Length(string1),Length(string2));
229	FOR i:=1 TO len DO
230	IF Ord(string1[i])<>Ord(string2[i]) THEN BEGIN
231	Result:=Ord(string1[i])<Ord(string2[i]);
232	Exit;
233	END;
234	Result:=Length(string1)<Length(string2);
235	END;
236
237
238
239
240	FUNCTION ExportFile(fileid:LongWord; filename:String; settings:TExportSet; path:String):Integer;
241	VAR
242	i:Byte;
243	extension:String;
244	rawlist:TRawList;
245	BEGIN
246	Result:=export_noerror;
247	extension:=RightStr(filename,4);
248	IF DO_toone IN settings THEN BEGIN
249	ExportDatFile(fileid,path+'\'+GetWinFileName(filename));
250	END ELSE BEGIN
251	IF DO_dat IN settings THEN ExportDatFile(fileid,path+'\'+GetWinFileName(filename));
252	IF DO_raw IN settings THEN BEGIN
253	rawlist:=OniDataConnection.GetRawList(fileid);
254	IF Length(rawlist)>0 THEN BEGIN
255	FOR i:=0 TO High(rawlist) DO BEGIN
256	ExportRawFile(fileid,rawlist[i].src_offset,path+'\'+GetWinFileName(filename));
257	END;
258	END;
259	END;
260	END;
261	END;
262
263	FUNCTION Explode(_string:String; delimiter:Char):TStringArray;
264	VAR
265	start,len:Word;
266	BEGIN
267	SetLength(Result, 0);
268	start:=1;
269	WHILE PosEx(delimiter,_string,start)>0 DO BEGIN
270	len:=PosEx(delimiter,_string,start)-start;
271	SetLength(Result, Length(Result)+1);
272	Result[High(Result)]:=MidStr(_string,start,len);
273	start:=start+len+1;
274	END;
275	SetLength(Result, Length(Result)+1);
276	Result[High(Result)]:=MidStr(_string,start,Length(_string)-start+1);
277	END;
278
279	FUNCTION GetWinFileName(name:String):String;
280	BEGIN
281	Result:=name;
282	Result:=AnsiReplaceStr(Result,'\','__');
283	Result:=AnsiReplaceStr(Result,'/','__');
284	Result:=AnsiReplaceStr(Result,'>','__');
285	Result:=AnsiReplaceStr(Result,'<','__');
286	END;
287
288	FUNCTION GetExtractPath:String;
289	BEGIN
290	Result:=ExtractFilePath(OniDataConnection.FileName)+'\extracted_'+ExtractFileName(OniDataConnection.Filename);
291	END;
292
293
294	END.