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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284 | package body scanner.IO is
use Ada.Wide_Wide_Text_IO;
-- Gets input and stuffs it into 'buf'. number of characters read, or
-- YY_NULL is returned in 'result'.
procedure YY_Input
(Buf : out Unbounded_Character_Array;
Result : out Integer;
Max_Size : integer)
is
C : Wide_Wide_character;
I : Integer := 1;
Loc : Integer := Buf'First;
begin
if Is_Open (User_Input_File) then
while I <= Max_Size loop
if End_Of_Line (User_Input_File) then
-- Ada ate our newline, put it back on the end.
Buf (Loc) := Ada.Characters.Wide_Wide_Latin_1.LF;
Skip_Line (User_Input_File, 1);
else
-- UCI CODES CHANGED:
-- The following codes are modified. Previous codes is commented out.
-- The purpose of doing this is to make it possible to set Temp_Line
-- in Ayacc-extension specific codes. Definitely, we can read the character
-- into the Temp_Line and then set the buf. But Temp_Line will only
-- be used in Ayacc-extension specific codes which makes this approach impossible.
Get (User_Input_File, C);
Buf (Loc) := C;
-- get(user_input_file, buf(loc));
end if;
Loc := Loc + 1;
I := I + 1;
end loop;
else
while I <= Max_Size loop
if end_of_line then
-- Ada ate our newline, put it back on the end.
Buf (Loc) := Ada.Characters.Wide_Wide_Latin_1.LF;
Skip_Line (1);
else
-- The following codes are modified. Previous codes is commented out.
-- The purpose of doing this is to make it possible to set Temp_Line
-- in Ayacc-extension specific codes. Definitely, we can read the character
-- into the Temp_Line and then set the buf. But Temp_Line will only
-- be used in Ayacc-extension specific codes which makes this approach impossible.
get(c);
buf(loc) := c;
-- get(buf(loc));
end if;
loc := loc + 1;
i := i + 1;
end loop;
end if; -- for input file being standard input
result := i - 1;
exception
when END_ERROR => result := i - 1;
-- when we hit EOF we need to set yy_eof_has_been_seen
yy_eof_has_been_seen := true;
end YY_INPUT;
-- yy_get_next_buffer - try to read in new buffer
--
-- returns a code representing an action
-- EOB_ACT_LAST_MATCH -
-- EOB_ACT_RESTART_SCAN - restart the scanner
-- EOB_ACT_END_OF_FILE - end of file
function yy_get_next_buffer return eob_action_type is
dest : integer := 0;
source : integer := yytext_ptr - 1; -- copy prev. char, too
number_to_move : integer;
ret_val : eob_action_type;
num_to_read : integer;
begin
if ( yy_c_buf_p > yy_n_chars + 1 ) then
raise NULL_IN_INPUT;
end if;
-- try to read more data
-- first move last chars to start of buffer
number_to_move := yy_c_buf_p - yytext_ptr;
for i in 0..number_to_move - 1 loop
yy_ch_buf.data (dest) := yy_ch_buf.data (source);
dest := dest + 1;
source := source + 1;
end loop;
if ( yy_eof_has_been_seen ) then
-- don't do the read, it's not guaranteed to return an EOF,
-- just force an EOF
yy_n_chars := 0;
else
num_to_read := YY_BUF_SIZE - number_to_move - 1;
if ( num_to_read > YY_READ_BUF_SIZE ) then
num_to_read := YY_READ_BUF_SIZE;
end if;
-- read in more data
YY_INPUT( yy_ch_buf.data (number_to_move..yy_ch_buf.data'last), yy_n_chars, num_to_read );
end if;
if ( yy_n_chars = 0 ) then
if ( number_to_move = 1 ) then
ret_val := EOB_ACT_END_OF_FILE;
else
ret_val := EOB_ACT_LAST_MATCH;
end if;
yy_eof_has_been_seen := true;
else
ret_val := EOB_ACT_RESTART_SCAN;
end if;
yy_n_chars := yy_n_chars + number_to_move;
yy_ch_buf.data (yy_n_chars) := YY_END_OF_BUFFER_CHAR;
yy_ch_buf.data (yy_n_chars + 1) := YY_END_OF_BUFFER_CHAR;
-- yytext begins at the second character in
-- yy_ch_buf; the first character is the one which
-- preceded it before reading in the latest buffer;
-- it needs to be kept around in case it's a
-- newline, so yy_get_previous_state() will have
-- with '^' rules active
yytext_ptr := 1;
return ret_val;
end yy_get_next_buffer;
procedure YYUnput (C : Wide_Wide_Character; YY_BP: in out Integer) is
number_to_move : Integer;
dest : integer;
source : integer;
tmp_yy_cp : integer;
begin
tmp_yy_cp := yy_c_buf_p;
if ( tmp_yy_cp < 2 ) then
-- need to shift things up to make room
number_to_move := yy_n_chars + 2; -- +2 for EOB chars
dest := YY_BUF_SIZE + 2;
source := number_to_move;
while ( source > 0 ) loop
dest := dest - 1;
source := source - 1;
yy_ch_buf.data (dest) := yy_ch_buf.data (source);
end loop;
tmp_yy_cp := tmp_yy_cp + dest - source;
yy_bp := yy_bp + dest - source;
yy_n_chars := YY_BUF_SIZE;
if ( tmp_yy_cp < 2 ) then
raise PUSHBACK_OVERFLOW;
end if;
end if;
if tmp_yy_cp > yy_bp
and then yy_ch_buf.data (tmp_yy_cp-1) = Ada.Characters.Wide_Wide_Latin_1.LF
then
yy_ch_buf.data (tmp_yy_cp-2) := Ada.Characters.Wide_Wide_Latin_1.LF;
end if;
tmp_yy_cp := tmp_yy_cp - 1;
yy_ch_buf.data (tmp_yy_cp) := c;
-- Note: this code is the text of YY_DO_BEFORE_ACTION, only
-- here we get different yy_cp and yy_bp's
yytext_ptr := yy_bp;
yy_c_buf_p := tmp_yy_cp;
end yyunput;
procedure Unput (C : Wide_Wide_Character) is
begin
YYUnput (C, yy_bp);
end Unput;
function Input return Wide_Wide_Character is
C : Wide_Wide_Character;
YY_CP : Integer := YY_C_Buf_P;
begin
if YY_CH_Buf.Data (YY_C_Buf_P) = YY_END_OF_BUFFER_CHAR then
-- need more input
yytext_ptr := yy_c_buf_p;
yy_c_buf_p := yy_c_buf_p + 1;
case yy_get_next_buffer is
-- this code, unfortunately, is somewhat redundant with
-- that above
when EOB_ACT_END_OF_FILE =>
if yywrap then
yy_c_buf_p := yytext_ptr;
return Ada.Characters.Wide_Wide_Latin_1.NUL;
end if;
yy_ch_buf.data (0) := Ada.Characters.Wide_Wide_Latin_1.LF;
yy_n_chars := 1;
yy_ch_buf.data (yy_n_chars) := YY_END_OF_BUFFER_CHAR;
yy_ch_buf.data (yy_n_chars + 1) := YY_END_OF_BUFFER_CHAR;
yy_eof_has_been_seen := false;
yy_c_buf_p := 1;
yytext_ptr := yy_c_buf_p;
return Input;
when EOB_ACT_RESTART_SCAN =>
yy_c_buf_p := yytext_ptr;
when EOB_ACT_LAST_MATCH =>
raise UNEXPECTED_LAST_MATCH;
when others => null;
end case;
end if;
c := yy_ch_buf.data (yy_c_buf_p);
yy_c_buf_p := yy_c_buf_p + 1;
return C;
end Input;
procedure Output (C : Wide_Wide_Character) is
begin
if Is_Open (User_Output_File) then
Put (User_Output_File, C);
else
Put (C);
end if;
end Output;
-- Default yywrap function - always treat EOF as an EOF
function YYWrap return Boolean is
begin
return True;
end YYWrap;
procedure Open_Input (FName : String) is
begin
YY_Init := True;
Open (User_Input_File, In_File, FName, "wcem=8");
end Open_Input;
procedure Create_Output (FName : String := "") is
begin
if fname /= "" then
Create (User_Output_File, Out_File, FName);
end if;
end Create_Output;
procedure Close_Input is
begin
if Is_Open (User_Input_File) then
Close (User_Input_File);
end if;
end Close_Input;
procedure Close_Output is
begin
if Is_Open (User_Output_File) then
Close (User_Output_File);
end if;
end Close_Output;
end scanner.IO;
|