1 : //==============================================================================
2 : // File <$/test/cpp/unit/idlc/lex/TestLex.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_wchar.h"
25 :
26 : #include <stdio.h>
27 : #include <ctype.h>
28 :
29 : #include "src/cpp/prod/tool/String.h"
30 : #include "src/cpp/prod/tool/WString.h"
31 :
32 : #include "src/cpp/dev/idlc/all_symbols.h"
33 : #include "src/cpp/dev/idlc/yyutils.h"
34 : #include "src/cpp/dev/idlc/idl_type.h"
35 : #include "src/cpp/dev/idlc/idl_bison.h"
36 : #include "src/cpp/dev/idlc/value.h"
37 : #include "src/cpp/dev/idlc/int_value.h"
38 : #include "src/cpp/dev/idlc/float_value.h"
39 : #include "src/cpp/dev/idlc/char_value.h"
40 : #include "src/cpp/dev/idlc/wchar_value.h"
41 : #include "src/cpp/dev/idlc/const_exp.h"
42 : #include "src/cpp/dev/idlc/sym_tab.h"
43 :
44 : YYSTYPE yylval ;
45 :
46 47 : void PrintNiceInt64(uint64_t v, char* buffer)
47 : {
48 : uint32_t v32h, v32l ;
49 :
50 47 : v32h = v >> 32 ;
51 47 : v32l = v & 0xFFFFFFFFL ;
52 :
53 47 : if (v32h != 0)
54 : {
55 : sprintf(
56 : buffer,
57 : "value64=<0x%08x%08x>",
58 28 : v32h, v32l) ;
59 :
60 28 : return ;
61 : }
62 :
63 : uint16_t v16h, v16l ;
64 : v16h = v >> 16 ;
65 19 : v16l = v & 0xFFFFL ;
66 :
67 19 : if (v16h != 0)
68 : {
69 : sprintf(
70 : buffer,
71 : "value32=<0x%08x>",
72 2 : v32l) ;
73 :
74 : return ;
75 : }
76 :
77 : uint8_t v8h, v8l ;
78 : v8h = v >> 8 ;
79 17 : v8l = v & 0xFFL ;
80 :
81 17 : if (v8h != 0)
82 : {
83 : sprintf(
84 : buffer,
85 : "value16=<0x%04x>",
86 3 : v16l) ;
87 :
88 : return ;
89 : }
90 :
91 : sprintf(
92 : buffer,
93 : "value8=<0x%02x>",
94 14 : v8l) ;
95 :
96 : return ;
97 : }
98 :
99 130 : bool IsWCharPrintable(wchar_t c)
100 : {
101 130 : if ( (c == 0xFFFE) || (c == 0xFFFF) )
102 : {
103 : return false ;
104 : }
105 :
106 129 : if (c > 0xFF)
107 : {
108 : return false ;
109 : }
110 :
111 : char c2 = c & 0xFF ;
112 124 : if (isprint(c2))
113 : {
114 : return true ;
115 : }
116 :
117 : return false ;
118 : }
119 :
120 20 : bool IsStringPrintable(const char* str)
121 : {
122 20 : int len = strlen(str) ;
123 : int i = 0 ;
124 :
125 242 : for (i = 0 ; i < len ; i++)
126 : {
127 225 : if (isprint(str[i]) == false)
128 : {
129 : return false ;
130 : }
131 : }
132 :
133 : return true ;
134 : }
135 :
136 9 : bool IsWStringPrintable(const wchar_t* str)
137 : {
138 9 : int len = wcslen(str) ;
139 : int i = 0 ;
140 :
141 85 : for (i = 0 ; i < len ; i++)
142 : {
143 78 : if (IsWCharPrintable(str[i]) == false)
144 : {
145 : return false ;
146 : }
147 : }
148 :
149 : return true ;
150 : }
151 :
152 221 : void PrintNiceToken(FILE * where, int token, char* text)
153 : {
154 : const char * str = NULL ;
155 :
156 221 : switch (token)
157 : {
158 1 : case TOK_ABSTRACT : { str = "TOK_ABSTRACT" ; break ; }
159 1 : case TOK_ANY : { str = "TOK_ANY" ; break ; }
160 2 : case TOK_ATTRIBUTE : { str = "TOK_ATTRIBUTE" ; break ; }
161 1 : case TOK_BOOLEAN : { str = "TOK_BOOLEAN" ; break ; }
162 1 : case TOK_CASE : { str = "TOK_CASE" ; break ; }
163 12 : case TOK_CHAR : { str = "TOK_CHAR" ; break ; }
164 1 : case TOK_COMPONENT : { str = "TOK_COMPONENT" ; break ; }
165 16 : case TOK_CONST : { str = "TOK_CONST" ; break ; }
166 1 : case TOK_CONSUMES : { str = "TOK_CONSUMES" ; break ; }
167 1 : case TOK_CONTEXT : { str = "TOK_CONTEXT" ; break ; }
168 1 : case TOK_CUSTOM : { str = "TOK_CUSTOM" ; break ; }
169 1 : case TOK_DEFAULT : { str = "TOK_DEFAULT" ; break ; }
170 2 : case TOK_DOUBLE : { str = "TOK_DOUBLE" ; break ; }
171 1 : case TOK_EMITS : { str = "TOK_EMITS" ; break ; }
172 1 : case TOK_ENUM : { str = "TOK_ENUM" ; break ; }
173 1 : case TOK_EVENTTYPE : { str = "TOK_EVENTTYPE" ; break ; }
174 1 : case TOK_EXCEPTION : { str = "TOK_EXCEPTION" ; break ; }
175 1 : case TOK_FACTORY : { str = "TOK_FACTORY" ; break ; }
176 1 : case TOK_FINDER : { str = "TOK_FINDER" ; break ; }
177 1 : case TOK_FALSE : { str = "TOK_FALSE" ; break ; }
178 1 : case TOK_FIXED : { str = "TOK_FIXED" ; break ; }
179 2 : case TOK_FLOAT : { str = "TOK_FLOAT" ; break ; }
180 1 : case TOK_GETRAISES : { str = "TOK_GETRAISES" ; break ; }
181 1 : case TOK_HOME : { str = "TOK_HOME" ; break ; }
182 1 : case TOK_IMPORT : { str = "TOK_IMPORT" ; break ; }
183 1 : case TOK_IN : { str = "TOK_IN" ; break ; }
184 1 : case TOK_INOUT : { str = "TOK_INOUT" ; break ; }
185 3 : case TOK_INTERFACE : { str = "TOK_INTERFACE" ; break ; }
186 1 : case TOK_LOCAL : { str = "TOK_LOCAL" ; break ; }
187 2 : case TOK_LONG : { str = "TOK_LONG" ; break ; }
188 3 : case TOK_MODULE : { str = "TOK_MODULE" ; break ; }
189 1 : case TOK_MULTIPLE : { str = "TOK_MULTIPLE" ; break ; }
190 1 : case TOK_NATIVE : { str = "TOK_NATIVE" ; break ; }
191 1 : case TOK_OBJECT : { str = "TOK_OBJECT" ; break ; }
192 1 : case TOK_OCTET : { str = "TOK_OCTET" ; break ; }
193 1 : case TOK_ONEWAY : { str = "TOK_ONEWAY" ; break ; }
194 1 : case TOK_OUT : { str = "TOK_OUT" ; break ; }
195 1 : case TOK_PRIMARYKEY : { str = "TOK_PRIMARYKEY" ; break ; }
196 1 : case TOK_PRIVATE : { str = "TOK_PRIVATE" ; break ; }
197 1 : case TOK_PROVIDES : { str = "TOK_PROVIDES" ; break ; }
198 1 : case TOK_PUBLIC : { str = "TOK_PUBLIC" ; break ; }
199 1 : case TOK_PUBLISHES : { str = "TOK_PUBLISHES" ; break ; }
200 1 : case TOK_RAISES : { str = "TOK_RAISES" ; break ; }
201 1 : case TOK_READONLY : { str = "TOK_READONLY" ; break ; }
202 1 : case TOK_SEQUENCE : { str = "TOK_SEQUENCE" ; break ; }
203 1 : case TOK_SETRAISES : { str = "TOK_SETRAISES" ; break ; }
204 1 : case TOK_SHORT : { str = "TOK_SHORT" ; break ; }
205 3 : case TOK_STRING : { str = "TOK_STRING" ; break ; }
206 1 : case TOK_STRUCT : { str = "TOK_STRUCT" ; break ; }
207 1 : case TOK_SUPPORTS : { str = "TOK_SUPPORTS" ; break ; }
208 1 : case TOK_SWITCH : { str = "TOK_SWITCH" ; break ; }
209 1 : case TOK_TRUE : { str = "TOK_TRUE" ; break ; }
210 1 : case TOK_TRUNCATABLE : { str = "TOK_TRUNCATABLE" ; break ; }
211 1 : case TOK_TYPEDEF : { str = "TOK_TYPEDEF" ; break ; }
212 1 : case TOK_TYPEID : { str = "TOK_TYPEID" ; break ; }
213 1 : case TOK_TYPEPREFIX : { str = "TOK_TYPEPREFIX" ; break ; }
214 1 : case TOK_UNION : { str = "TOK_UNION" ; break ; }
215 1 : case TOK_UNSIGNED : { str = "TOK_UNSIGNED" ; break ; }
216 0 : case TOK_USES : { str = "TOK_USES" ; break ; }
217 1 : case TOK_VALUEBASE : { str = "TOK_VALUEBASE" ; break ; }
218 1 : case TOK_VALUETYPE : { str = "TOK_VALUETYPE" ; break ; }
219 1 : case TOK_VOID : { str = "TOK_VOID" ; break ; }
220 1 : case TOK_WCHAR : { str = "TOK_WCHAR" ; break ; }
221 3 : case TOK_WSTRING : { str = "TOK_WSTRING" ; break ; }
222 22 : case TOK_SEMICOLON : { str = "TOK_SEMICOLON" ; break ; }
223 3 : case TOK_LEFT_CURLY_BRAKET : { str = "TOK_LEFT_CURLY_BRAKET" ; break ; }
224 3 : case TOK_RIGHT_CURLY_BRAKET : { str = "TOK_RIGHT_CURLY_BRAKET" ; break ; }
225 1 : case TOK_COLON : { str = "TOK_COLON" ; break ; }
226 2 : case TOK_COMMA : { str = "TOK_COMMA" ; break ; }
227 16 : case TOK_EQUALS : { str = "TOK_EQUALS" ; break ; }
228 1 : case TOK_PLUS : { str = "TOK_PLUS" ; break ; }
229 1 : case TOK_MINUS : { str = "TOK_MINUS" ; break ; }
230 1 : case TOK_LEFT_PARENTHESIS : { str = "TOK_LEFT_PARENTHESIS" ; break ; }
231 1 : case TOK_RIGHT_PARENTHESIS : { str = "TOK_RIGHT_PARENTHESIS" ; break ; }
232 1 : case TOK_LESS_THAN : { str = "TOK_LESS_THAN" ; break ; }
233 1 : case TOK_GREATER_THAN : { str = "TOK_GREATER_THAN" ; break ; }
234 2 : case TOK_LEFT_SQUARE_BRAKET : { str = "TOK_LEFT_SQUARE_BRAKET" ; break ; }
235 2 : case TOK_RIGHT_SQUARE_BRAKET : { str = "TOK_RIGHT_SQUARE_BRAKET" ; break ; }
236 1 : case TOK_VERTICAL_LINE : { str = "TOK_VERTICAL_LINE" ; break ; }
237 2 : case TOK_CIRCUMFLEX : { str = "TOK_CIRCUMFLEX" ; break ; }
238 1 : case TOK_AMPERSAND : { str = "TOK_AMPERSAND" ; break ; }
239 1 : case TOK_ASTERISK : { str = "TOK_ASTERISK" ; break ; }
240 1 : case TOK_SOLIDUS : { str = "TOK_SOLIDUS" ; break ; }
241 1 : case TOK_PERCENT : { str = "TOK_PERCENT" ; break ; }
242 2 : case TOK_TILDE : { str = "TOK_TILDE" ; break ; }
243 36 : case TOK_IDENTIFIER : { str = "TOK_IDENTIFIER" ; break ; }
244 0 : case integer_literal : { str = "integer_literal" ; break ; }
245 0 : case string_literal_unit : { str = "string_literal_unit" ; break ; }
246 0 : case wide_string_literal_unit : { str = "wide_string_literal_unit" ; break ; }
247 0 : case character_literal : { str = "character_literal" ; break ; }
248 0 : case wide_character_literal : { str = "wide_character_literal" ; break ; }
249 0 : case fixed_pt_literal : { str = "fixed_pt_literal" ; break ; }
250 0 : case floating_pt_literal : { str = "floating_pt_literal" ; break ; }
251 1 : case TOK_DOUBLE_SEMICOLON : { str = "TOK_DOUBLE_SEMICOLON" ; break ; }
252 1 : case TOK_SHIFT_LEFT : { str = "TOK_SHIFT_LEFT" ; break ; }
253 1 : case TOK_SHIFT_RIGHT : { str = "TOK_SHIFT_RIGHT" ; break ; }
254 : case TOK_MANAGES : { str = "TOK_MANAGES" ; break ; }
255 : default :
256 : {
257 : // Nothing
258 : }
259 : }
260 :
261 : if (str != NULL)
262 : {
263 206 : fprintf(where, "token=%s, text=<%s>\n", str, text) ;
264 : }
265 : else
266 : {
267 15 : fprintf(where, "token=%d, text=<%s>\n", token, text) ;
268 : }
269 15 : }
270 :
271 15 : int main(int argc, char *argv[])
272 : {
273 15 : const char *fileName = argv[1] ;
274 : int tok ;
275 :
276 15 : g_symTabPtr = new SymbolTable() ;
277 :
278 : StringList includesDirs ;
279 15 : LexInit(fileName, includesDirs, false) ;
280 :
281 221 : do
282 : {
283 414 : tok = yylex() ;
284 :
285 414 : if (tok == integer_literal)
286 : {
287 47 : IDLIntType type(idl_unsigned_long_long) ;
288 47 : IDLConstExp *exp = yylval.ConstExpPtr ;
289 47 : IDLIntValue *value = (IDLIntValue*) exp->evaluate( & type) ;
290 : char niceValue[255] ;
291 :
292 47 : uint64_t v = value->GetU64() ;
293 :
294 47 : PrintNiceInt64(v, niceValue) ;
295 :
296 : fprintf(
297 : stdout,
298 : "token=integer_literal, text=<%s>, %s\n",
299 : yytext,
300 47 : niceValue) ;
301 0 : continue ;
302 : }
303 :
304 367 : if (tok == floating_pt_literal)
305 : {
306 3 : IDLFloatType type(idl_double) ;
307 3 : IDLConstExp *exp = yylval.ConstExpPtr ;
308 3 : IDLFloatValue *value = (IDLFloatValue*) exp->evaluate( & type) ;
309 :
310 3 : double v = value->GetF64() ;
311 3 : fprintf(stdout, "token=floating_pt_literal, text=<%s>, value=<%f>\n", yytext, v) ;
312 0 : continue ;
313 : }
314 :
315 364 : if (tok == character_literal)
316 : {
317 62 : IDLCharType type ;
318 62 : IDLConstExp *exp = yylval.ConstExpPtr ;
319 62 : IDLCharValue *value = (IDLCharValue*) exp->evaluate( & type) ;
320 :
321 62 : unsigned char c = value->GetChar() ;
322 :
323 62 : if (isprint(c))
324 : {
325 : fprintf(stdout, "token=character_literal, value=<%c>, code=<0x%02x>=<%03o>\n",
326 35 : c, c, c) ;
327 : }
328 : else
329 : {
330 : fprintf(stdout, "token=character_literal, (not printable), code=<0x%02x>=<%03o>\n",
331 27 : c, c) ;
332 : }
333 :
334 0 : continue ;
335 : }
336 :
337 302 : if (tok == wide_character_literal)
338 : {
339 52 : IDLWCharType type ;
340 52 : IDLConstExp *exp = yylval.ConstExpPtr ;
341 52 : IDLWCharValue *value = (IDLWCharValue*) exp->evaluate( & type) ;
342 :
343 52 : wchar_t c = value->GetWChar() ;
344 :
345 : // Warning : isprint(wchar_t) builds, and core dump
346 :
347 52 : if (IsWCharPrintable(c))
348 : {
349 : fprintf(stdout, "token=wide_character_literal, value=<%c>, code=<0x%04x>\n",
350 17 : c, c) ;
351 : }
352 : else
353 : {
354 : fprintf(stdout, "token=wide_character_literal, (not printable), code=<0x%04x>\n",
355 35 : c) ;
356 : }
357 :
358 0 : continue ;
359 : }
360 :
361 250 : if (tok == string_literal_unit)
362 : {
363 20 : String *v = yylval.StringPtr ;
364 20 : const char * str = *v;
365 20 : int len = v->length() ;
366 :
367 20 : if (IsStringPrintable(str))
368 : {
369 17 : fprintf(stdout, "token=string_literal_unit, len=<%d>, value=<%s>\n", len, str) ;
370 : }
371 : else
372 : {
373 3 : fprintf(stdout, "token=string_literal_unit, len=<%d> (not printable)\n", len) ;
374 : }
375 : continue ;
376 : }
377 :
378 230 : if (tok == wide_string_literal_unit)
379 : {
380 9 : WString *v = yylval.WStringPtr ;
381 9 : const wchar_t * str = *v;
382 9 : int len = v->length() ;
383 :
384 9 : if (IsWStringPrintable(str))
385 : {
386 : fprintf(stdout, "token=wide_string_literal_unit, len=<%d>, value=<%ls>\n",
387 7 : len, str) ;
388 : }
389 : else
390 : {
391 : fprintf(stdout, "token=wide_string_literal_unit, len=<%d> (not printable)\n",
392 2 : len) ;
393 : }
394 : continue ;
395 : }
396 :
397 221 : PrintNiceToken(stdout, tok, yytext) ;
398 :
399 : } while (tok != 0) ;
400 :
401 15 : LexExit() ;
402 :
403 15 : delete g_symTabPtr ;
404 :
405 : return 0 ;
406 15 : }
407 15 :
|
