1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/yyutils.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 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_stdc.h"
25 : #include "src/cpp/prod/port/port_unistd.h"
26 :
27 : #include <sys/stat.h>
28 :
29 : #include "src/cpp/prod/tool/Assert.h"
30 :
31 : #include "src/cpp/dev/idlc/yyutils.h"
32 : #include "src/cpp/dev/idlc/idl_type.h"
33 : #include "src/cpp/dev/idlc/idl_bison.h"
34 : #include "src/cpp/dev/idlc/int_value.h"
35 : #include "src/cpp/dev/idlc/simple_declarator.h"
36 : #include "src/cpp/dev/idlc/array_declarator.h"
37 : #include "src/cpp/dev/idlc/define.h"
38 :
39 : int g_nbIDLError = 0 ;
40 : int g_nbIDLWarning = 0 ;
41 : SymbolTable * g_symTabPtr = NULL ;
42 : DefineTable * g_defineTable = NULL ;
43 : bool g_echo = false ;
44 :
45 : int IDLLineNumber ;
46 63 : String IDLFileName ;
47 63 : StringList g_includeDirs ;
48 :
49 : std::ostream & errLog = std::cout ;
50 :
51 145 : int yywrap(void)
52 : {
53 : return 1 ;
54 : }
55 :
56 69 : int yyerror(const char* msg)
57 : {
58 69 : g_nbIDLError ++ ;
59 :
60 69 : errLog << IDLFileName << ":" << IDLLineNumber ;
61 69 : errLog << " :error: " << msg << std::endl ;
62 :
63 69 : errLog << "The source parsed was: <" << yytext << ">" << std::endl ; ;
64 : errLog << std::flush ;
65 :
66 : return 0 ;
67 : }
68 :
69 156 : void IDLCompileError(const char* msg)
70 : {
71 156 : g_nbIDLError ++ ;
72 :
73 156 : errLog << IDLFileName << ":" << IDLLineNumber ;
74 156 : errLog << " :error: " << msg << std::endl ;
75 : errLog << std::flush ;
76 : }
77 :
78 0 : void IDLFatalCompileError(const char* msg)
79 : {
80 0 : IDLCompileError(msg) ;
81 0 : exit(1) ;
82 : }
83 :
84 : void LexInit(
85 : const char* fileName,
86 : const StringList& includeDirs,
87 63 : bool echoStdout)
88 : {
89 63 : FixGCCBug() ;
90 :
91 63 : g_nbIDLError = 0 ;
92 63 : g_nbIDLWarning = 0 ;
93 : g_includeDirs = includeDirs ;
94 63 : g_echo = echoStdout ;
95 :
96 63 : g_defineTable = new DefineTable() ;
97 :
98 63 : yyin = fopen(fileName, "r") ;
99 63 : if (yyin == NULL)
100 : {
101 0 : perror("Can open input file") ;
102 0 : IDLFatalCompileError("No input file") ;
103 : }
104 :
105 63 : IDLFileName = fileName ;
106 63 : IDLLineNumber = 1 ;
107 :
108 : return ;
109 : }
110 :
111 63 : void LexExit(void)
112 : {
113 63 : fclose (yyin) ;
114 :
115 63 : IDLFileName = "" ;
116 63 : IDLLineNumber = 0 ;
117 :
118 63 : delete g_defineTable ;
119 63 : g_defineTable = NULL ;
120 : return ;
121 : }
122 :
123 82 : FILE* FindFile(const char* filename, String& fullname)
124 : {
125 : FILE *result = NULL ;
126 82 : String tryname ;
127 : String *item = NULL ;
128 82 : String name ;
129 :
130 : struct stat buf ;
131 :
132 : StringListIt it(g_includeDirs) ;
133 :
134 187 : while (it.GetNext())
135 : {
136 : item = it.GetItem() ;
137 : ASSERT(item != NULL) ;
138 187 : tryname = *item ;
139 187 : tryname += "/" ;
140 187 : tryname += filename ;
141 :
142 374 : if (stat(tryname, & buf) == 0)
143 : {
144 : // OK, the file exist.
145 82 : result = fopen(tryname, "r") ;
146 82 : if (result == NULL)
147 : {
148 0 : perror(tryname) ;
149 0 : IDLFatalCompileError("Can not read include file") ;
150 : }
151 : else
152 : {
153 82 : fullname = tryname ;
154 : return result ;
155 : }
156 : }
157 : }
158 :
159 0 : IDLFatalCompileError("Can not find include file") ;
160 0 : return NULL ;
161 : }
162 :
163 : struct keyword
164 : {
165 : const char* _name ;
166 : int _token ;
167 : } ;
168 :
169 : static const struct keyword keyword_tab[] =
170 : {
171 : { "abstract", TOK_ABSTRACT },
172 : { "any", TOK_ANY },
173 : { "attribute", TOK_ATTRIBUTE },
174 : { "boolean", TOK_BOOLEAN },
175 : { "case", TOK_CASE },
176 : { "char", TOK_CHAR },
177 : { "component", TOK_COMPONENT },
178 : { "const", TOK_CONST },
179 : { "consumes", TOK_CONSUMES },
180 : { "context", TOK_CONTEXT },
181 : { "custom", TOK_CUSTOM },
182 : { "default", TOK_DEFAULT },
183 : { "double", TOK_DOUBLE },
184 : { "emits", TOK_EMITS },
185 : { "enum", TOK_ENUM },
186 : { "eventtype", TOK_EVENTTYPE },
187 : { "exception", TOK_EXCEPTION },
188 : { "factory", TOK_FACTORY },
189 : { "finder", TOK_FINDER },
190 : { "FALSE", TOK_FALSE },
191 : { "fixed", TOK_FIXED },
192 : { "float", TOK_FLOAT },
193 : { "getraises", TOK_GETRAISES },
194 : { "home", TOK_HOME },
195 : { "import", TOK_IMPORT },
196 : { "in", TOK_IN },
197 : { "inout", TOK_INOUT },
198 : { "interface", TOK_INTERFACE },
199 : { "local", TOK_LOCAL },
200 : { "long", TOK_LONG },
201 : { "module", TOK_MODULE },
202 : { "multiple", TOK_MULTIPLE },
203 : { "native", TOK_NATIVE },
204 : { "Object", TOK_OBJECT },
205 : { "octet", TOK_OCTET },
206 : { "oneway", TOK_ONEWAY },
207 : { "out", TOK_OUT },
208 : { "primarykey", TOK_PRIMARYKEY },
209 : { "private", TOK_PRIVATE },
210 : { "provides", TOK_PROVIDES },
211 : { "public", TOK_PUBLIC },
212 : { "publishes", TOK_PUBLISHES },
213 : { "raises", TOK_RAISES },
214 : { "readonly", TOK_READONLY },
215 : { "sequence", TOK_SEQUENCE },
216 : { "setraises", TOK_SETRAISES },
217 : { "short", TOK_SHORT },
218 : { "string", TOK_STRING },
219 : { "struct", TOK_STRUCT },
220 : { "supports", TOK_SUPPORTS },
221 : { "switch", TOK_SWITCH },
222 : { "TRUE", TOK_TRUE },
223 : { "truncatable", TOK_TRUNCATABLE },
224 : { "typedef", TOK_TYPEDEF },
225 : { "typeid", TOK_TYPEID },
226 : { "typeprefix", TOK_TYPEPREFIX },
227 : { "unsigned", TOK_UNSIGNED },
228 : { "union", TOK_UNION },
229 : { "ValueBase", TOK_VALUEBASE },
230 : { "valuetype", TOK_VALUETYPE },
231 : { "void", TOK_VOID },
232 : { "wchar", TOK_WCHAR },
233 : { "wstring", TOK_WSTRING },
234 :
235 : { NULL , 0 }
236 : } ;
237 :
238 :
239 35824 : int TokenType(const char* text)
240 : {
241 : const struct keyword *current = & keyword_tab[0] ;
242 :
243 1847805 : while (current->_name != NULL)
244 : {
245 1825076 : if (strcmp(text, current->_name) == 0)
246 : {
247 13095 : return (current->_token) ;
248 : }
249 :
250 1811981 : current ++ ;
251 : }
252 :
253 : return (TOK_IDENTIFIER) ;
254 : }
255 :
256 45458 : bool CollideKeyword(const char* text)
257 : {
258 : const struct keyword *current = & keyword_tab[0] ;
259 :
260 1454656 : while (current->_name != NULL)
261 : {
262 1431927 : if (strcasecmp(text, current->_name) == 0)
263 : {
264 : return (true) ;
265 : }
266 :
267 : current ++ ;
268 : }
269 :
270 : return (false) ;
271 63 : }
272 63 :
273 0 :
|
