1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
unit EditorReader;
{(*}
(*------------------------------------------------------------------------------
Delphi Code formatter source code
The Original Code is EditorReader.pas, released January 2001.
The Initial Developer of the Original Code is Anthony Steele.
Portions created by Anthony Steele are Copyright (C) 2001 Anthony Steele.
All Rights Reserved.
Contributor(s):
Anthony Steele.
Walter Prins
The contents of this file are subject to the Mozilla Public License Version 1.1
(the "License"). you may not use this file except in compliance with the License.
You may obtain a copy of the License at http://www.mozilla.org/NPL/
Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied.
See the License for the specific language governing rights and limitations
under the License.
Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 or later (the "GPL")
See http://www.gnu.org/licenses/gpl.html
------------------------------------------------------------------------------*)
{*)}
{$I JcfGlobal.inc}
interface
{ reader class for use in IDE pluggin - reads from editor interface }
uses
{ delphi design time }ToolsAPI,
{ local }CodeReader;
type
TEditorReader = class(TCodeReader)
private
fciUnit: IOTASourceEditor;
protected
procedure ReadFromSource; override;
public
constructor Create; override;
procedure SetEditorUnit(const pciUnit: IOTASourceEditor);
end;
implementation
constructor TEditorReader.Create;
begin
inherited;
fciUnit := nil;
end;
procedure TEditorReader.SetEditorUnit(const pciUnit: IOTASourceEditor);
begin
fciUnit := pciUnit;
end;
procedure TEditorReader.ReadFromSource;
const
// 10 kb at a time should do it
BUF_SIZE = 10240;
//BUF_SIZE = 120; // small for testing
var
lciEditorReader: IOTAEditReader;
lsBuf: string;
lpBuf: pchar;
liActualSize, liPos: integer;
lbDone: boolean;
//liLoopCount: integer;
begin
{ get a reader from the unit }
Assert(fciUnit <> nil);
lciEditorReader := fciUnit.CreateReader;
Assert(lciEditorReader <> nil);
fsSource := '';
// read it all. Unfortunately the API dictates that we will work in chunks
liPos := 0;
//liLoopCount := 0;
lbDone := False;
while not lbDone do
begin
// clear the buffer
SetLength(lsBuf, BUF_SIZE);
lpBuf := pchar(lsBuf);
FillChar(lpBuf^, BUF_SIZE, 0);
// get some text into the buffer
liActualSize := lciEditorReader.GetText(liPos, lpBuf, BUF_SIZE);
// store it
{WP: Do not add the entire lsBuf to fsSource, as in cases where the entire source is less
than 10Kb in total, there will be junk in the last part of the buffer.
If this is copied, it shows up as extraneous tokens in the token list
after the end of the unit proper.
This then causes an assertion failure in procedure DoConvertUnit in unit Converter.pas,
When these extra tokens are found that were not consumed by BuildParseTree
The way is to ensure that you only append as many characters as you've actually read (liActualSize bytes)
from the buffer into the fSource. }
fsSource := fsSource + Copy(lsBuf, 1, liActualSize);
//WP: Changed from just adding lsBuf
// more stuff to read after this?
liPos := liPos + liActualSize;
lbDone := (liActualSize < BUF_SIZE);
//inc(liLoopCount);
end;
{ release the reader - must happen before the writer is used }
lciEditorReader := nil;
// debug ShowMessage(fsSource);
//ShowMessage('read in ' + IntToStr(liLoopCount));
fiSourceLength := Length(fsSource);
fiReadIndex := 1;
fiBufferLength := 1;
fbHasRead := True;
end;
end.
|
