1 /*
2 * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 /*
26 * COMPONENT_NAME: idl.parser
27 *
28 * ORIGINS: 27
29 *
30 * Licensed Materials - Property of IBM
31 * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
32 * RMI-IIOP v1.0
33 *
34 */
35
36 package com.sun.tools.corba.se.idl;
37
38 // NOTES:
39 // -D56351<daz> Update Prefix pragma directive to CORBA 2.3 (see spec.).
40 // -D57110<daz> Update ID pragma directive to CORBA 2.3 (see spec.).
41 // -D46094<daz> Prohibit exceptions from appearing wihtin structs, unions, exceptions.
42 // -D46094<daz> Prohibit attributes from appearing as operation parameter types,
43 // operation return types, attribute types.
44 // -D59166<daz> Prohibit identifiers form colliding with IDL keywords.
45 // -F60858.1<daz> Add keyword collision warning.
46 // -F60942<daz> Prohibit operations from appearing as operation parameter types.
47 // -D62023<daz> Add deprecated keyword warning; cast char to byte for JDK 1.2 compatability.
48
49 import java.io.IOException;
50
51 /**
52 *
53 **/
54 class ParseException extends Exception
55 {
56 /**
57 * Constructor: print the supplied message to Standard.err
58 * and create a new ParseException
59 * @return a new ParseException.
60 **/
61 ParseException (String message)
62 {
63 super (message);
64 System.err.println (message);
65 detected = true;
66 } // ctor
67
68 /**
69 * Constructor: print the supplied message to Standard.err, if it
70 * is not a warning, and create a new ParseException.
71 * @return a new ParseException.
72 **/
73 ParseException (String message, boolean onlyAWarning)
74 {
75 super (message);
76 System.err.println (message);
77 if (!onlyAWarning)
78 detected = true;
79 }
80
81 static ParseException abstractValueBox (Scanner scanner)
82 {
83 return arg0 ("abstractValueBox", scanner);
84 }
85
86 static ParseException alreadyDeclared (Scanner scanner, String type)
87 {
88 return arg1 ("alreadyDeclared", scanner, type);
89 }
90
91 static ParseException declNotInSameFile( Scanner scanner, String type,
92 String firstFile )
93 {
94 return arg2 ("declNotInSameFile", scanner, type, firstFile) ;
95 }
96
97 static ParseException alreadyDefaulted (Scanner scanner)
98 {
99 return arg0 ("alreadydefaulted", scanner);
100 }
101
102 static ParseException alreadyDerived (Scanner scanner, String derived, String iface)
103 {
104 return arg2 ("alreadyDerived", scanner, derived, iface);
105 }
106
107 static ParseException alreadyRaised (Scanner scanner, String exception)
108 {
109 return arg1 ("alreadyRaised", scanner, exception);
110 }
111
112 // <d60942>
113 static ParseException attributeNotType (Scanner scanner, String attr)
114 {
115 return arg1 ("attributeNotType", scanner, attr);
116 }
117
118 static ParseException badAbstract (Scanner scanner, String name)
119 {
120 return arg1 ("badAbstract", scanner, name);
121 }
122
123 static ParseException badCustom (Scanner scanner)
124 {
125 return arg0 ("badCustom", scanner);
126 }
127
128 // <d57110>
129 static ParseException badRepIDAlreadyAssigned (Scanner scanner, String entry)
130 {
131 return arg1 ("badRepIDAlreadyAssigned", scanner, entry);
132 }
133
134 // <d57110>
135 static ParseException badRepIDForm (Scanner scanner, String entry)
136 {
137 return arg1 ("badRepIDForm", scanner, entry);
138 }
139
140 // <d56351>
141 static ParseException badRepIDPrefix (Scanner scanner, String entry, String expected, String got)
142 {
143 return arg3 ("badRepIDPrefix", scanner, entry, expected, got);
144 }
145
146 static ParseException badState (Scanner scanner, String entry)
147 {
148 return arg1 ("badState", scanner, entry);
149 }
150
151 static ParseException branchLabel (Scanner scanner, String label)
152 {
153 return arg1 ("branchLabel", scanner, label);
154 }
155
156 static ParseException branchName (Scanner scanner, String name)
157 {
158 return arg1 ("branchName", scanner, name);
159 }
160
161 static ParseException duplicateInit (Scanner scanner)
162 {
163 return arg0 ("duplicateInit", scanner);
164 }
165
166 static ParseException duplicateState (Scanner scanner, String name)
167 {
168 return arg1 ("duplicateState", scanner, name);
169 }
170
171 static ParseException elseNoIf (Scanner scanner)
172 {
173 return arg0 ("elseNoIf", scanner);
174 }
175
176 static ParseException endNoIf (Scanner scanner)
177 {
178 return arg0 ("endNoIf", scanner);
179 }
180
181 static ParseException evaluationError (Scanner scanner, String problem)
182 {
183 return arg1 ("evaluation", scanner, problem);
184 }
185
186 static ParseException forwardEntry (Scanner scanner, String name)
187 {
188 return arg1 ("forwardEntry", scanner, name);
189 }
190
191 // <f46082.40> Cannot forward value boxes.
192 static ParseException forwardedValueBox (Scanner scanner, String name)
193 {
194 return arg1 ("forwardedValueBox", scanner, name);
195 }
196
197 static ParseException generic (Scanner scanner, String message)
198 {
199 return arg1 ("generic", scanner, message);
200 }
201
202 static ParseException illegalArray (Scanner scanner, String name)
203 {
204 return arg1 ("illegalArray", scanner, name);
205 }
206
207 static ParseException illegalException (Scanner scanner, String name)
208 {
209 return arg1 ("illegalException", scanner, name);
210 }
211
212 static ParseException invalidConst (Scanner scanner, String mustBe, String is)
213 {
214 return arg2 ("invalidConst1", scanner, mustBe, is);
215 }
216
217 static ParseException invalidConst (Scanner scanner, String type)
218 {
219 return arg1 ("invalidConst2", scanner, type);
220 }
221
222 // <d59166> Non-escaped identifiers that collide with keywords are illegal.
223 static ParseException keywordCollision (Scanner scanner, String id)
224 {
225 return arg1 ("keywordCollision", scanner, id);
226 }
227
228 // <d62023> Warning for keywords that will be removed in a future version of IDL.
229 static ParseException deprecatedKeywordWarning (Scanner scanner, String id)
230 {
231 return arg1Warning ("deprecatedKeywordWarning", scanner, id);
232 }
233
234 // <f60858.1> Warning for above error.
235 static ParseException keywordCollisionWarning (Scanner scanner, String id)
236 {
237 return arg1Warning ("keywordCollisionWarning", scanner, id);
238 }
239
240 static ParseException methodClash (Scanner scanner, String interf, String method)
241 {
242 return arg2 ("methodClash", scanner, interf, method);
243 }
244
245 static ParseException moduleNotType (Scanner scanner, String module)
246 {
247 return arg1 ("moduleNotType", scanner, module);
248 }
249
250 // <d59067>
251 static ParseException nestedValueBox (Scanner scanner)
252 {
253 return arg0 ("nestedValueBox", scanner);
254 }
255
256 static ParseException noDefault (Scanner scanner)
257 {
258 return arg0 ("noDefault", scanner);
259 }
260
261 static ParseException nonAbstractParent (Scanner scanner, String baseClass, String parentClass)
262 {
263 return arg2 ("nonAbstractParent", scanner, baseClass, parentClass);
264 }
265
266 static ParseException nonAbstractParent2 (Scanner scanner, String baseClass, String parentClass)
267 {
268 return arg2 ("nonAbstractParent2", scanner, baseClass, parentClass);
269 }
270
271 static ParseException nonAbstractParent3 (Scanner scanner, String baseClass, String parentClass)
272 {
273 return arg2 ("nonAbstractParent3", scanner, baseClass, parentClass);
274 }
275
276 static ParseException notANumber (Scanner scanner, String notNumber)
277 {
278 return arg1 ("notANumber", scanner, notNumber);
279 }
280
281 static ParseException nothing (String filename)
282 {
283 return new ParseException (Util.getMessage ("ParseException.nothing", filename));
284 }
285
286 static ParseException notPositiveInt (Scanner scanner, String notPosInt)
287 {
288 return arg1 ("notPosInt", scanner, notPosInt);
289 }
290
291 static ParseException oneway (Scanner scanner, String method)
292 {
293 return arg1 ("oneway", scanner, method);
294 }
295
296 // <d60942>
297 static ParseException operationNotType (Scanner scanner, String op)
298 {
299 return arg1 ("operationNotType", scanner, op);
300 }
301
302 static ParseException outOfRange (Scanner scanner, String value, String type)
303 {
304 return arg2 ("outOfRange", scanner, value, type);
305 }
306
307 static ParseException recursive (Scanner scanner, String type, String name)
308 {
309 return arg2 ("recursive", scanner, type, name);
310 }
311
312 static ParseException selfInherit (Scanner scanner, String name)
313 {
314 return arg1 ("selfInherit", scanner, name);
315 }
316
317 static ParseException stringTooLong (Scanner scanner, String str, String max)
318 {
319 return arg2 ("stringTooLong", scanner, str, max);
320 }
321
322 static ParseException syntaxError (Scanner scanner, int expected, int got)
323 {
324 return arg2 ("syntax1", scanner, Token.toString (expected), Token.toString (got));
325 }
326
327 static ParseException syntaxError (Scanner scanner, String expected, String got)
328 {
329 return arg2 ("syntax1", scanner, expected, got);
330 }
331
332 static ParseException syntaxError (Scanner scanner, int[] expected, int got)
333 {
334 return syntaxError (scanner, expected, Token.toString (got));
335 }
336
337 static ParseException syntaxError (Scanner scanner, int[] expected, String got)
338 {
339 String tokenList = "";
340 for (int i = 0; i < expected.length; ++i)
341 tokenList += " `" + Token.toString (expected[i]) + "'";
342 return arg2 ("syntax2", scanner, tokenList, got);
343 }
344
345 static ParseException unclosedComment (String filename)
346 {
347 return new ParseException (Util.getMessage ("ParseException.unclosed", filename));
348 }
349
350 static ParseException undeclaredType (Scanner scanner, String undeclaredType)
351 {
352 return arg1 ("undeclaredType", scanner, undeclaredType);
353 }
354
355 static ParseException warning (Scanner scanner, String message)
356 {
357 scannerInfo (scanner);
358 String[] parameters = { filename, Integer.toString (lineNumber), message, line, pointer };
359 return new ParseException (Util.getMessage ("ParseException.warning", parameters), true);
360 }
361
362 static ParseException wrongType (Scanner scanner, String name, String mustBe, String is)
363 {
364 scannerInfo (scanner);
365 String[] parameters = {filename, Integer.toString (lineNumber), name, is, mustBe, line, pointer};
366 return new ParseException (Util.getMessage ("ParseException.wrongType", parameters));
367 }
368
369 static ParseException wrongExprType (Scanner scanner, String mustBe, String is)
370 {
371 scannerInfo (scanner);
372 String[] parameters = {filename, Integer.toString (lineNumber),
373 is, mustBe, line, pointer};
374 return new ParseException (Util.getMessage ("ParseException.constExprType",
375 parameters));
376 }
377
378 static ParseException illegalForwardInheritance( Scanner scanner, String declName,
379 String baseName )
380 {
381 scannerInfo( scanner ) ;
382 String[] parameters = { filename, Integer.toString(lineNumber),
383 declName, baseName, line, pointer } ;
384 return new ParseException (Util.getMessage(
385 "ParseException.forwardInheritance", parameters ) ) ;
386 }
387
388 static ParseException illegalIncompleteTypeReference( Scanner scanner,
389 String declName )
390 {
391 scannerInfo( scanner ) ;
392 String[] parameters = { filename, Integer.toString(lineNumber),
393 declName, line, pointer } ;
394 return new ParseException (Util.getMessage(
395 "ParseException.illegalIncompleteTypeReference", parameters ) ) ;
396 }
397
398 private static void scannerInfo (Scanner scanner)
399 {
400 filename = scanner.filename ();
401 line = scanner.lastTokenLine ();
402 lineNumber = scanner.lastTokenLineNumber ();
403 int pos = scanner.lastTokenLinePosition ();
404 pointer = "^";
405 if (pos > 1)
406 {
407 byte[] bytes = new byte[ pos - 1 ];
408 for (int i = 0; i < pos - 1; ++i)
409 bytes[i] = (byte)' '; // <d62023>
410 pointer = new String (bytes) + pointer;
411 }
412 }
413
414 private static ParseException arg0 (String msgId, Scanner scanner)
415 {
416 scannerInfo (scanner);
417 String[] parameters = {filename, Integer.toString (lineNumber), line, pointer};
418 return new ParseException (Util.getMessage ("ParseException." + msgId, parameters));
419 }
420
421 private static ParseException arg1 (String msgId, Scanner scanner, String arg1)
422 {
423 scannerInfo (scanner);
424 String[] parameters = {filename, Integer.toString (lineNumber), arg1, line, pointer};
425 return new ParseException (Util.getMessage ("ParseException." + msgId, parameters));
426 }
427
428 // <f60858.1>
429 private static ParseException arg1Warning (String msgId, Scanner scanner, String arg1)
430 {
431 scannerInfo (scanner);
432 String[] parameters = {filename, Integer.toString (lineNumber), arg1, line, pointer};
433 return new ParseException (Util.getMessage ("ParseException." + msgId, parameters), true);
434 }
435
436 private static ParseException arg2 (String msgId, Scanner scanner, String arg1, String arg2)
437 {
438 scannerInfo (scanner);
439 String[] parameters = {filename, Integer.toString (lineNumber), arg1, arg2, line, pointer};
440 return new ParseException (Util.getMessage ("ParseException." + msgId, parameters));
441 }
442
443 private static ParseException arg3 (String msgId, Scanner scanner, String arg1, String arg2, String arg3)
444 {
445 scannerInfo (scanner);
446 String[] parameters = {filename, Integer.toString (lineNumber), arg1, arg2, arg3, line, pointer};
447 return new ParseException (Util.getMessage ("ParseException." + msgId, parameters));
448 }
449
450 private static String filename = "";
451 private static String line = "";
452 private static int lineNumber = 0;
453 private static String pointer = "^";
454
455 static boolean detected = false;
456 } // class ParseException