/*
* Copyright (c) 1999, 2000, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* COMPONENT_NAME: idl.parser
*
* ORIGINS: 27
*
* Licensed Materials - Property of IBM
* 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
* RMI-IIOP v1.0
*
*/
package com.sun.tools.corba.se.idl;
// NOTES:
// -D57110<daz> Allow ID pragma directive to be applied to modules and update
// feature in accordance to CORBA 2.3.
// -D59165<daz> Enable escaped identifiers when processing pragmas.
// -f60858.1<daz> Support -corba option, level = 2.2: Accept identifiers that
// collide with keywords, in letter but not case, and issue a warning.
// -d62023 <daz> support -noWarn option; suppress inappropriate warnings when
// parsing IBM-specific pragmas (#meta <interface_name> abstract).
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Stack;
import java.util.Vector;
import com.sun.tools.corba.se.idl.RepositoryID;
import com.sun.tools.corba.se.idl.constExpr.*;
/**
* This class should be extended if new pragmas are desired. If the
* preprocessor encounters a pragma name which it doesn't recognize
* (anything other than ID, prefix, or version), it calls the method
* otherPragmas. This is the only method which need be overridden.
* The Preprocessor base class has a number of utility-like methods
* which can be used by the overridden otherPragmas method.
**/
public class Preprocessor
{
/**
* Public zero-argument constructor.
**/
Preprocessor ()
{
} // ctor
/**
*
**/
void init (Parser p)
{
parser = p;
symbols = p.symbols;
macros = p.macros;
} // init
/**
*
**/
protected Object clone ()
{
return new Preprocessor ();
} // clone
/**
*
**/
Token process (Token t) throws IOException, ParseException
{
token = t;
scanner = parser.scanner;
// <f46082.40> Deactivate escaped identifier processing in Scanner while
// preprocessing.
//scanner.underscoreOK = true;
scanner.escapedOK = false;
try
{
switch (token.type)
{
case Token.Include:
include ();
break;
case Token.If:
ifClause ();
break;
case Token.Ifdef:
ifdef (false);
break;
case Token.Ifndef:
ifdef (true);
break;
case Token.Else:
if (alreadyProcessedABranch.empty ())
throw ParseException.elseNoIf (scanner);
else if (((Boolean)alreadyProcessedABranch.peek ()).booleanValue ())
skipToEndif ();
else
{
alreadyProcessedABranch.pop ();
alreadyProcessedABranch.push (new Boolean (true));
token = scanner.getToken ();
}
break;
case Token.Elif:
elif ();
break;
case Token.Endif:
if (alreadyProcessedABranch.empty ())
throw ParseException.endNoIf (scanner);
else
{
alreadyProcessedABranch.pop ();
token = scanner.getToken ();
break;
}
case Token.Define:
define ();
break;
case Token.Undef:
undefine ();
break;
case Token.Pragma:
pragma ();
break;
case Token.Unknown:
if (!parser.noWarn)
ParseException.warning (scanner, Util.getMessage ("Preprocessor.unknown", token.name));
case Token.Error:
case Token.Line:
case Token.Null:
// ignore
default:
scanner.skipLineComment ();
token = scanner.getToken ();
}
}
catch (IOException e)
{
// <f46082.40> Underscore may now precede any identifier, so underscoreOK
// is vestigal. The Preprocessor must reset escapedOK so that Scanner
// will process escaped identifiers according to specification.
//scanner.underscoreOK = false;
scanner.escapedOK = true;
throw e;
}
catch (ParseException e)
{
// <f46082.40> See above.
//scanner.underscoreOK = false;
scanner.escapedOK = true;
throw e;
}
// <f46082.40> See above.
//scanner.underscoreOK = false;
scanner.escapedOK = true;
return token;
} // process
/**
*
**/
private void include () throws IOException, ParseException
{
match (Token.Include);
IncludeEntry include = parser.stFactory.includeEntry (parser.currentModule);
include.sourceFile (scanner.fileEntry ());
scanner.fileEntry ().addInclude (include);
if (token.type == Token.StringLiteral)
include2 (include);
else if (token.type == Token.LessThan)
include3 (include);
else
{
int[] expected = {Token.StringLiteral, Token.LessThan};
throw ParseException.syntaxError (scanner, expected, token.type);
}
if (parser.currentModule instanceof ModuleEntry)
((ModuleEntry)parser.currentModule).addContained (include);
else if (parser.currentModule instanceof InterfaceEntry)
((InterfaceEntry)parser.currentModule).addContained (include);
} // include
/**
*
**/
private void include2 (IncludeEntry include) throws IOException, ParseException
{
include.name ('"' + token.name + '"');
include4 (include, token.name);
match (Token.StringLiteral);
} // include2
/**
*
**/
private void include3 (IncludeEntry include) throws IOException, ParseException
{
if (token.type != Token.LessThan)
// match will throw an exception
match (Token.LessThan);
else
{
try
{
String includeFile = getUntil ('>');
token = scanner.getToken ();
include.name ('<' + includeFile + '>');
include4 (include, includeFile);
match (Token.GreaterThan);
}
catch (IOException e)
{
throw ParseException.syntaxError (scanner, ">", "EOF");
}
}
} // include3
/**
*
**/
private void include4 (IncludeEntry include, String filename) throws IOException, ParseException
{
try
{
// If the #include is at the global scope, it is treated as
// an import statement. If it is within some other scope, it
// is treated as a normal #include.
boolean includeIsImport = parser.currentModule == parser.topLevelModule;
//daz
include.absFilename (Util.getAbsolutePath (filename, parser.paths));
scanner.scanIncludedFile (include, getFilename (filename), includeIsImport);
}
catch (IOException e)
{
ParseException.generic (scanner, e.toString ());
}
} // include4
/**
*
**/
private void define () throws IOException, ParseException
{
match (Token.Define);
if (token.equals (Token.Identifier))
{
String symbol = scanner.getStringToEOL ();
symbols.put (token.name, symbol.trim ());
match (Token.Identifier);
}
else if (token.equals (Token.MacroIdentifier))
{
symbols.put (token.name, '(' + scanner.getStringToEOL () . trim ());
macros.addElement (token.name);
match (Token.MacroIdentifier);
}
else
throw ParseException.syntaxError (scanner, Token.Identifier, token.type);
} // define
/**
*
**/
private void undefine () throws IOException, ParseException
{
match (Token.Undef);
if (token.equals (Token.Identifier))
{
symbols.remove (token.name);
macros.removeElement (token.name);
match (Token.Identifier);
}
else
throw ParseException.syntaxError (scanner, Token.Identifier, token.type);
} // undefine
/**
*
**/
private void ifClause () throws IOException, ParseException
{
match (Token.If);
constExpr ();
} // ifClause
/**
*
**/
private void constExpr () throws IOException, ParseException
{
SymtabEntry dummyEntry = new SymtabEntry (parser.currentModule);
dummyEntry.container (parser.currentModule);
parser.parsingConditionalExpr = true;
Expression boolExpr = booleanConstExpr (dummyEntry);
parser.parsingConditionalExpr = false;
boolean expr;
if (boolExpr.value () instanceof Boolean)
expr = ((Boolean)boolExpr.value ()).booleanValue ();
else
expr = ((Number)boolExpr.value ()).longValue () != 0;
alreadyProcessedABranch.push (new Boolean (expr));
if (!expr)
skipToEndiforElse ();
} // constExpr
/**
*
**/
Expression booleanConstExpr (SymtabEntry entry) throws IOException, ParseException
{
Expression expr = orExpr (null, entry);
try
{
expr.evaluate ();
}
catch (EvaluationException e)
{
ParseException.evaluationError (scanner, e.toString ());
}
return expr;
} // booleanConstExpr
/**
*
**/
private Expression orExpr (Expression e, SymtabEntry entry) throws IOException, ParseException
{
if (e == null)
e = andExpr (null, entry);
else
{
BinaryExpr b = (BinaryExpr)e;
b.right (andExpr (null, entry));
e.rep (e.rep () + b.right ().rep ());
}
if (token.equals (Token.DoubleBar))
{
match (token.type);
BooleanOr or = parser.exprFactory.booleanOr (e, null);
or.rep (e.rep () + " || ");
return orExpr (or, entry);
}
else
return e;
} // orExpr
/**
*
**/
private Expression andExpr (Expression e, SymtabEntry entry) throws IOException, ParseException
{
if (e == null)
e = notExpr (entry);
else
{
BinaryExpr b = (BinaryExpr)e;
b.right (notExpr (entry));
e.rep (e.rep () + b.right ().rep ());
}
if (token.equals (Token.DoubleAmpersand))
{
match (token.type);
BooleanAnd and = parser.exprFactory.booleanAnd (e, null);
and.rep (e.rep () + " && ");
return andExpr (and, entry);
}
else
return e;
} // andExpr
/**
*
**/
private Expression notExpr (/*boolean alreadySawExclamation, */SymtabEntry entry) throws IOException, ParseException
{
Expression e;
if (token.equals (Token.Exclamation))
{
match (Token.Exclamation);
e = parser.exprFactory.booleanNot (definedExpr (entry));
e.rep ("!" + ((BooleanNot)e).operand ().rep ());
}
else
e = definedExpr (entry);
return e;
} // notExpr
/**
*
**/
private Expression definedExpr (SymtabEntry entry) throws IOException, ParseException
{
if (token.equals (Token.Identifier) && token.name.equals ("defined"))
match (Token.Identifier);
return equalityExpr (null, entry);
} // definedExpr
/**
*
**/
private Expression equalityExpr (Expression e, SymtabEntry entry) throws IOException, ParseException
{
if (e == null)
{
parser.token = token; // Since parser to parse, give it this token
e = parser.constExp (entry);
token = parser.token; // Since parser last parsed, get its token
}
else
{
BinaryExpr b = (BinaryExpr)e;
parser.token = token; // Since parser to parse, give it this token
Expression constExpr = parser.constExp (entry);
token = parser.token; // Since parser last parsed, get its token
b.right (constExpr);
e.rep (e.rep () + b.right ().rep ());
}
if (token.equals (Token.DoubleEqual))
{
match (token.type);
Equal eq = parser.exprFactory.equal (e, null);
eq.rep (e.rep () + " == ");
return equalityExpr (eq, entry);
}
else if (token.equals (Token.NotEqual))
{
match (token.type);
NotEqual n = parser.exprFactory.notEqual (e, null);
n.rep (e.rep () + " != ");
return equalityExpr (n, entry);
}
else if (token.equals (Token.GreaterThan))
{
match (token.type);
GreaterThan g = parser.exprFactory.greaterThan (e, null);
g.rep (e.rep () + " > ");
return equalityExpr (g, entry);
}
else if (token.equals (Token.GreaterEqual))
{
match (token.type);
GreaterEqual g = parser.exprFactory.greaterEqual (e, null);
g.rep (e.rep () + " >= ");
return equalityExpr (g, entry);
}
else if (token.equals (Token.LessThan))
{
match (token.type);
LessThan l = parser.exprFactory.lessThan (e, null);
l.rep (e.rep () + " < ");
return equalityExpr (l, entry);
}
else if (token.equals (Token.LessEqual))
{
match (token.type);
LessEqual l = parser.exprFactory.lessEqual (e, null);
l.rep (e.rep () + " <= ");
return equalityExpr (l, entry);
}
else
return e;
} // equalityExpr
/**
*
**/
Expression primaryExpr (SymtabEntry entry) throws IOException, ParseException
{
Expression primary = null;
switch (token.type)
{
case Token.Identifier:
// If an identifier gets this far, it means that no
// preprocessor variable was defined with that name.
// Generate a FALSE boolean expr.
//daz primary = parser.exprFactory.terminal ("0", new Long (0));
primary = parser.exprFactory.terminal ("0", BigInteger.valueOf (0));
token = scanner.getToken ();
break;
case Token.BooleanLiteral:
case Token.CharacterLiteral:
case Token.IntegerLiteral:
case Token.FloatingPointLiteral:
case Token.StringLiteral:
//daz primary = parser.literal ();
primary = parser.literal (entry);
token = parser.token;
break;
case Token.LeftParen:
match (Token.LeftParen);
primary = booleanConstExpr (entry);
match (Token.RightParen);
primary.rep ('(' + primary.rep () + ')');
break;
default:
int[] expected = {Token.Literal, Token.LeftParen};
throw ParseException.syntaxError (scanner, expected, token.type);
}
return primary;
} // primaryExpr
/**
*
**/
private void ifDefine (boolean inParens, boolean not) throws IOException, ParseException
{
if (token.equals (Token.Identifier))
if ((not && symbols.containsKey (token.name)) || (!not && !symbols.containsKey (token.name)))
{
alreadyProcessedABranch.push (new Boolean (false));
skipToEndiforElse ();
}
else
{
alreadyProcessedABranch.push (new Boolean (true));
match (Token.Identifier);
if (inParens)
match (Token.RightParen);
}
else
throw ParseException.syntaxError (scanner, Token.Identifier, token.type);
} // ifDefine
/**
*
**/
private void ifdef (boolean not) throws IOException, ParseException
{
if (not)
match (Token.Ifndef);
else
match (Token.Ifdef);
if (token.equals (Token.Identifier))
if ((not && symbols.containsKey (token.name)) || (!not && !symbols.containsKey (token.name)))
{
alreadyProcessedABranch.push (new Boolean (false));
skipToEndiforElse ();
}
else
{
alreadyProcessedABranch.push (new Boolean (true));
match (Token.Identifier);
}
else
throw ParseException.syntaxError (scanner, Token.Identifier, token.type);
} // ifdef
/**
*
**/
private void elif () throws IOException, ParseException
{
if (alreadyProcessedABranch.empty ())
throw ParseException.elseNoIf (scanner);
else if (((Boolean)alreadyProcessedABranch.peek ()).booleanValue ())
skipToEndif ();
else
{
match (Token.Elif);
constExpr ();
}
} // elif
/**
*
**/
private void skipToEndiforElse () throws IOException, ParseException
{
while (!token.equals (Token.Endif) && !token.equals (Token.Else) && !token.equals (Token.Elif))
{
if (token.equals (Token.Ifdef) || token.equals (Token.Ifndef))
{
alreadyProcessedABranch.push (new Boolean (true));
skipToEndif ();
}
else
token = scanner.skipUntil ('#');
}
process (token);
} // skipToEndiforElse
/**
*
**/
private void skipToEndif () throws IOException, ParseException
{
while (!token.equals (Token.Endif))
{
token = scanner.skipUntil ('#');
if (token.equals (Token.Ifdef) || token.equals (Token.Ifndef))
{
alreadyProcessedABranch.push (new Boolean (true));
skipToEndif ();
}
}
alreadyProcessedABranch.pop ();
match (Token.Endif);
} // skipToEndif
///////////////
// For Pragma
/**
*
**/
private void pragma () throws IOException, ParseException
{
match (Token.Pragma);
String pragmaType = token.name;
// <d59165> Enable escaped identifiers while processing pragma internals.
// Don't enable until scanning pragma name!
scanner.escapedOK = true;
match (Token.Identifier);
// Add pragma entry to container
PragmaEntry pragmaEntry = parser.stFactory.pragmaEntry (parser.currentModule);
pragmaEntry.name (pragmaType);
pragmaEntry.sourceFile (scanner.fileEntry ());
pragmaEntry.data (scanner.currentLine ());
if (parser.currentModule instanceof ModuleEntry)
((ModuleEntry)parser.currentModule).addContained (pragmaEntry);
else if (parser.currentModule instanceof InterfaceEntry)
((InterfaceEntry)parser.currentModule).addContained (pragmaEntry);
// If the token was an identifier, then pragmaType WILL be non-null.
if (pragmaType.equals ("ID"))
idPragma ();
else if (pragmaType.equals ("prefix"))
prefixPragma ();
else if (pragmaType.equals ("version"))
versionPragma ();
// we are adding extensions to the Sun's idlj compiler to
// handle correct code generation for local Objects, where
// the OMG is taking a long time to formalize stuff. Good
// example of this is poa.idl. Two proprietory pragmas
// sun_local and sun_localservant are defined. sun_local
// generates only Holder and Helper classes, where read
// and write methods throw marshal exceptions. sun_localservant
// is to generate Helper, Holder, and only Skel with _invoke
// throwing an exception, since it does not make sense for
// local objects.
else if (pragmaType.equals ("sun_local"))
localPragma();
else if (pragmaType.equals ("sun_localservant"))
localServantPragma();
else
{
otherPragmas (pragmaType, tokenToString ());
token = scanner.getToken ();
}
scanner.escapedOK = false; // <d59165> Disable escaped identifiers.
} // pragma
// <d57110> Pragma ID can be appiled to modules and it is an error to
// name a type in more than one ID pragma directive.
private Vector PragmaIDs = new Vector ();
private void localPragma () throws IOException, ParseException
{
// Before I can use a parser method, I must make sure it has the current token.
parser.token = token;
// this makes sense only for interfaces, if specified for modules,
// parser should throw an error
SymtabEntry anErrorOccurred = new SymtabEntry ();
SymtabEntry entry = parser.scopedName (parser.currentModule, anErrorOccurred);
// Was the indicated type found in the symbol table?
if (entry == anErrorOccurred)
{
System.out.println("Error occured ");
// Don't have to generate an error, scopedName already has.
scanner.skipLineComment ();
token = scanner.getToken ();
}
else
{
// by this time we have already parsed the ModuleName and the
// pragma type, therefore setInterfaceType
if (entry instanceof InterfaceEntry) {
InterfaceEntry ent = (InterfaceEntry) entry;
ent.setInterfaceType (InterfaceEntry.LOCAL_SIGNATURE_ONLY);
}
token = parser.token;
String string = token.name;
match (Token.StringLiteral);
// for non-interfaces it doesn't make sense, so just ignore it
}
} // localPragma
private void localServantPragma () throws IOException, ParseException
{
// Before I can use a parser method, I must make sure it has the current token.
parser.token = token;
// this makes sense only for interfaces, if specified for modules,
// parser should throw an error
SymtabEntry anErrorOccurred = new SymtabEntry ();
SymtabEntry entry = parser.scopedName (parser.currentModule, anErrorOccurred);
// Was the indicated type found in the symbol table?
if (entry == anErrorOccurred)
{
// Don't have to generate an error, scopedName already has.
scanner.skipLineComment ();
token = scanner.getToken ();
System.out.println("Error occured ");
}
else
{
// by this time we have already parsed the ModuleName and the
// pragma type, therefore setInterfaceType
if (entry instanceof InterfaceEntry) {
InterfaceEntry ent = (InterfaceEntry) entry;
ent.setInterfaceType (InterfaceEntry.LOCALSERVANT);
}
token = parser.token;
String string = token.name;
match (Token.StringLiteral);
// for non-interfaces it doesn't make sense, so just ignore it
}
} // localServantPragma
/**
*
**/
private void idPragma () throws IOException, ParseException
{
// Before I can use a parser method, I must make sure it has the current token.
parser.token = token;
// <d57110> This flag will relax the restriction that the scopedNamed
// in this ID pragma directive cannot resolve to a module.
parser.isModuleLegalType (true);
SymtabEntry anErrorOccurred = new SymtabEntry ();
SymtabEntry entry = parser.scopedName (parser.currentModule, anErrorOccurred);
parser.isModuleLegalType (false); // <57110>
// Was the indicated type found in the symbol table?
if (entry == anErrorOccurred)
{
// Don't have to generate an error, scopedName already has.
scanner.skipLineComment ();
token = scanner.getToken ();
}
// <d57110>
//else if (PragmaIDs.contains (entry))
//{
// ParseException.badRepIDAlreadyAssigned (scanner, entry.name ());
// scanner.skipLineComment ();
// token = scanner.getToken ();
//}
else
{
token = parser.token;
String string = token.name;
// Do not match token until after raise exceptions, otherwise
// incorrect messages will be emitted!
if (PragmaIDs.contains (entry)) // <d57110>
{
ParseException.badRepIDAlreadyAssigned (scanner, entry.name ());
}
else if (!RepositoryID.hasValidForm (string)) // <d57110>
{
ParseException.badRepIDForm (scanner, string);
}
else
{
entry.repositoryID (new RepositoryID (string));
PragmaIDs.addElement (entry); // <d57110>
}
match (Token.StringLiteral);
}
} // idPragma
/**
*
**/
private void prefixPragma () throws IOException, ParseException
{
String string = token.name;
match (Token.StringLiteral);
((IDLID)parser.repIDStack.peek ()).prefix (string);
((IDLID)parser.repIDStack.peek ()).name ("");
} // prefixPragma
/**
*
**/
private void versionPragma () throws IOException, ParseException
{
// Before I can use a parser method, I must make sure it has the current token.
parser.token = token;
// This flag will relax the restriction that the scopedNamed
// in this Version pragma directive cannot resolve to a module.
parser.isModuleLegalType (true);
SymtabEntry anErrorOccurred = new SymtabEntry ();
SymtabEntry entry = parser.scopedName (parser.currentModule, anErrorOccurred);
// reset the flag to original value
parser.isModuleLegalType (false);
if (entry == anErrorOccurred)
{
// Don't have to generate an error, scopedName already has.
scanner.skipLineComment ();
token = scanner.getToken ();
}
else
{
token = parser.token;
String string = token.name;
match (Token.FloatingPointLiteral);
if (entry.repositoryID () instanceof IDLID)
((IDLID)entry.repositoryID ()).version (string);
}
} // versionPragma
private Vector pragmaHandlers = new Vector ();
/**
*
**/
void registerPragma (PragmaHandler handler)
{
pragmaHandlers.addElement (handler);
} // registerPragma
/**
*
**/
private void otherPragmas (String pragmaType, String currentToken) throws IOException
{
for (int i = pragmaHandlers.size () - 1; i >= 0; --i)
{
PragmaHandler handler = (PragmaHandler)pragmaHandlers.elementAt (i);
if (handler.process (pragmaType, currentToken))
break;
}
} // otherPragmas
/*
* These protected methods are used by extenders, by the code
* which implements otherPragma.
*/
/**
* Get the current token.
**/
String currentToken ()
{
return tokenToString ();
} // currentToken
/**
* This method, given an entry name, returns the entry with that name.
* It can take fully or partially qualified names and returns the
* appropriate entry defined within the current scope. If no entry
* exists, null is returned.
**/
SymtabEntry getEntryForName (String string)
{
boolean partialScope = false;
boolean globalScope = false;
// Change all ::'s to /'s
if (string.startsWith ("::"))
{
globalScope = true;
string = string.substring (2);
}
int index = string.indexOf ("::");
while (index >= 0)
{
partialScope = true;
string = string.substring (0, index) + '/' + string.substring (index + 2);
index = string.indexOf ("::");
}
// Get the entry for that string
SymtabEntry entry = null;
if (globalScope)
entry = parser.recursiveQualifiedEntry (string);
else if (partialScope)
entry = parser.recursivePQEntry (string, parser.currentModule);
else
entry = parser.unqualifiedEntryWMod (string, parser.currentModule);
return entry;
} // getEntryForName
/**
* This method returns a string of all of the characters from the
* input file from the current position up to, but not including,
* the end-of-line character(s).
**/
String getStringToEOL () throws IOException
{
return scanner.getStringToEOL ();
} // getStringToEOL
/**
* This method returns a string of all of the characters from the
* input file from the current position up to, but not including,
* the given character. It encapsulates parenthesis and quoted strings,
* meaning it does not stop if the given character is found within
* parentheses or quotes. For instance, given the input of
* `start(inside)end', getUntil ('n') will return "start(inside)e"
**/
String getUntil (char c) throws IOException
{
return scanner.getUntil (c);
} // getUntil
private boolean lastWasMacroID = false;
/**
*
**/
private String tokenToString ()
{
if (token.equals (Token.MacroIdentifier))
{
lastWasMacroID = true;
return token.name;
}
else if (token.equals (Token.Identifier))
return token.name;
else
return token.toString ();
} // tokenToString
/**
* This method returns the next token String from the input file.
**/
String nextToken () throws IOException
{
if (lastWasMacroID)
{
lastWasMacroID = false;
return "(";
}
else
{
token = scanner.getToken ();
return tokenToString ();
}
} // nextToken
/**
* This method assumes that the current token marks the beginning
* of a scoped name. It then parses the subsequent identifier and
* double colon tokens, builds the scoped name, and finds the symbol
* table entry with that name.
**/
SymtabEntry scopedName () throws IOException
{
boolean globalScope = false;
boolean partialScope = false;
String name = null;
SymtabEntry entry = null;
try
{
if (token.equals (Token.DoubleColon))
globalScope = true;
else
{
if (token.equals (Token.Object))
{
name = "Object";
match (Token.Object);
}
else if (token.type == Token.ValueBase)
{
name = "ValueBase";
match (Token.ValueBase);
}
else
{
name = token.name;
match (Token.Identifier);
}
}
while (token.equals (Token.DoubleColon))
{
match (Token.DoubleColon);
partialScope = true;
if (name != null)
name = name + '/' + token.name;
else
name = token.name;
match (Token.Identifier);
}
if (globalScope)
entry = parser.recursiveQualifiedEntry (name);
else if (partialScope)
entry = parser.recursivePQEntry (name, parser.currentModule);
else
entry = parser.unqualifiedEntryWMod (name, parser.currentModule);
}
catch (ParseException e)
{
entry = null;
}
return entry;
} // scopedName
/**
* Skip to the end of the line.
**/
void skipToEOL () throws IOException
{
scanner.skipLineComment ();
} // skipToEOL
/**
* This method skips the data in the input file until the specified
* character is encountered, then it returns the next token.
**/
String skipUntil (char c) throws IOException
{
if (!(lastWasMacroID && c == '('))
token = scanner.skipUntil (c);
return tokenToString ();
} // skipUntil
/**
* This method displays a Parser Exception complete with line number
* and position information with the given message string.
**/
void parseException (String message)
{
// <d62023> Suppress warnings
if (!parser.noWarn)
ParseException.warning (scanner, message);
} // parseException
// For Pragma
///////////////
// For macro expansion
/**
*
**/
String expandMacro (String macroDef, Token t) throws IOException, ParseException
{
token = t;
// Get the parameter values from the macro 'call'
Vector parmValues = getParmValues ();
// Get the parameter names from the macro definition
// NOTE: a newline character is appended here so that when
// getStringToEOL is called, it stops scanning at the end
// of this string.
scanner.scanString (macroDef + '\n');
Vector parmNames = new Vector ();
macro (parmNames);
if (parmValues.size () < parmNames.size ())
throw ParseException.syntaxError (scanner, Token.Comma, Token.RightParen);
else if (parmValues.size () > parmNames.size ())
throw ParseException.syntaxError (scanner, Token.RightParen, Token.Comma);
macroDef = scanner.getStringToEOL ();
for (int i = 0; i < parmNames.size (); ++i)
macroDef = replaceAll (macroDef, (String)parmNames.elementAt (i), (String)parmValues.elementAt (i));
return removeDoublePound (macroDef);
} // expandMacro
// This method is only used by the macro expansion methods.
/**
*
**/
private void miniMatch (int type) throws ParseException
{
// A normal production would now execute:
// match (type);
// But match reads the next token. I don't want to do that now.
// Just make sure the current token is a 'type'.
if (!token.equals (type))
throw ParseException.syntaxError (scanner, type, token.type);
} // miniMatch
/**
*
**/
private Vector getParmValues () throws IOException, ParseException
{
Vector values = new Vector ();
if (token.equals (Token.Identifier))
{
match (Token.Identifier);
miniMatch (Token.LeftParen);
}
else if (!token.equals (Token.MacroIdentifier))
throw ParseException.syntaxError (scanner, Token.Identifier, token.type);
if (!token.equals (Token.RightParen))
{
values.addElement (scanner.getUntil (',', ')').trim ());
token = scanner.getToken ();
macroParmValues (values);
}
return values;
} // getParmValues
/**
*
**/
private void macroParmValues (Vector values) throws IOException, ParseException
{
while (!token.equals (Token.RightParen))
{
miniMatch (Token.Comma);
values.addElement (scanner.getUntil (',', ')').trim ());
token = scanner.getToken ();
}
} // macroParmValues
/**
*
**/
private void macro (Vector parmNames) throws IOException, ParseException
{
match (token.type);
match (Token.LeftParen);
macroParms (parmNames);
miniMatch (Token.RightParen);
} // macro
/**
*
**/
private void macroParms (Vector parmNames) throws IOException, ParseException
{
if (!token.equals (Token.RightParen))
{
parmNames.addElement (token.name);
match (Token.Identifier);
macroParms2 (parmNames);
}
} // macroParms
/**
*
**/
private void macroParms2 (Vector parmNames) throws IOException, ParseException
{
while (!token.equals (Token.RightParen))
{
match (Token.Comma);
parmNames.addElement (token.name);
match (Token.Identifier);
}
} // macroParms2
/**
*
**/
private String replaceAll (String string, String from, String to)
{
int index = 0;
while (index != -1)
{
index = string.indexOf (from, index);
if (index != -1)
{
if (!embedded (string, index, index + from.length ()))
if (index > 0 && string.charAt(index) == '#')
string = string.substring (0, index) + '"' + to + '"' + string.substring (index + from.length ());
else
string = string.substring (0, index) + to + string.substring (index + from.length ());
index += to.length ();
}
}
return string;
} // replaceAll
/**
*
**/
private boolean embedded (String string, int index, int endIndex)
{
// Don't replace if found substring is not an independent id.
// For example, don't replace "thither".indexOf ("it", 0)
boolean ret = false;
char preCh = index == 0 ? ' ' : string.charAt (index - 1);
char postCh = endIndex >= string.length () - 1 ? ' ' : string.charAt (endIndex);
if ((preCh >= 'a' && preCh <= 'z') || (preCh >= 'A' && preCh <= 'Z'))
ret = true;
else if ((postCh >= 'a' && postCh <= 'z') || (postCh >= 'A' && postCh <= 'Z') || (postCh >= '0' && postCh <= '9') || postCh == '_')
ret = true;
else
ret = inQuotes (string, index);
return ret;
} // embedded
/**
*
**/
private boolean inQuotes (String string, int index)
{
int quoteCount = 0;
for (int i = 0; i < index; ++i)
if (string.charAt (i) == '"') ++quoteCount;
// If there are an odd number of quotes before this region,
// then this region is within quotes
return quoteCount % 2 != 0;
} // inQuotes
/**
* Remove any occurrences of ##.
**/
private String removeDoublePound (String string)
{
int index = 0;
while (index != -1)
{
index = string.indexOf ("##", index);
if (index != -1)
{
int startSkip = index - 1;
int stopSkip = index + 2;
if (startSkip < 0)
startSkip = 0;
if (stopSkip >= string.length ())
stopSkip = string.length () - 1;
while (startSkip > 0 &&
(string.charAt (startSkip) == ' ' ||
string.charAt (startSkip) == '\t'))
--startSkip;
while (stopSkip < string.length () - 1 &&
(string.charAt (stopSkip) == ' ' ||
string.charAt (stopSkip) == '\t'))
++stopSkip;
string = string.substring (0, startSkip + 1) + string.substring (stopSkip);
}
}
return string;
} // removeDoublePound
// For macro expansion
///////////////
/**
*
**/
private String getFilename (String name) throws FileNotFoundException
{
String fullName = null;
File file = new File (name);
if (file.canRead ())
fullName = name;
else
{
Enumeration pathList = parser.paths.elements ();
while (!file.canRead () && pathList.hasMoreElements ())
{
fullName = (String)pathList.nextElement () + File.separatorChar + name;
file = new File (fullName);
}
if (!file.canRead ())
throw new FileNotFoundException (name);
}
return fullName;
} // getFilename
/**
*
**/
private void match (int type) throws IOException, ParseException
{
if (!token.equals (type))
throw ParseException.syntaxError (scanner, type, token.type);
token = scanner.getToken ();
// <d62023> Added for convenience, but commented-out because there is
// no reason to issue warnings for tokens scanned during preprocessing.
// See issueTokenWarnings().
//issueTokenWarnings ();
//System.out.println ("Preprocessor.match token = " + token.type);
//if (token.equals (Token.Identifier) || token.equals (Token.MacroIdentifier))
// System.out.println ("Preprocessor.match token name = " + token.name);
// If the token is a defined thingy, scan the defined string
// instead of the input stream for a while.
if (token.equals (Token.Identifier) || token.equals (Token.MacroIdentifier))
{
String string = (String)symbols.get (token.name);
if (string != null && !string.equals (""))
// If this is a macro, parse the macro
if (macros.contains (token.name))
{
scanner.scanString (expandMacro (string, token));
token = scanner.getToken ();
}
// else this is just a normal define
else
{
scanner.scanString (string);
token = scanner.getToken ();
}
}
} // match
// <d62023>
/**
* Issue warnings about tokens scanned during preprocessing.
**/
private void issueTokenWarnings ()
{
if (parser.noWarn)
return;
// There are no keywords defined for preprocessing (only directives), so:
//
// 1.) Do not issue warnings for identifiers known to be keywords in
// another level of IDL.
// 2.) Do not issue warnings for identifiers that collide with keywords
// in letter, but not case.
// 3.) Do not issue warnings for deprecated keywords.
//
// Should we warn when a macro identifier replaces a keyword? Hmmm.
// Deprecated directives? None to date.
//if (token.isDirective () && token.isDeprecated ())
// ParseException.warning (scanner, Util.getMesage ("Deprecated.directive", token.name));
} // issueTokenWarnings
/**
* This method is called when the parser encounters a left curly brace.
* An extender of PragmaHandler may find scope information useful.
* For example, the prefix pragma takes effect as soon as it is
* encountered and stays in effect until the current scope is closed.
* If a similar pragma extension is desired, then the openScope and
* closeScope methods are available for overriding.
* @param entry the symbol table entry whose scope has just been opened.
* Be aware that, since the scope has just been entered, this entry is
* incomplete at this point.
**/
void openScope (SymtabEntry entry)
{
for (int i = pragmaHandlers.size () - 1; i >= 0; --i)
{
PragmaHandler handler = (PragmaHandler)pragmaHandlers.elementAt (i);
handler.openScope (entry);
}
} // openScope
/**
* This method is called when the parser encounters a right curly brace.
* An extender of PragmaHandler may find scope information useful.
* For example, the prefix pragma takes effect as soon as it is
* encountered and stays in effect until the current scope is closed.
* If a similar pragma extension is desired, then the openScope and
* closeScope methods are available for overriding.
* @param entry the symbol table entry whose scope has just been closed.
**/
void closeScope (SymtabEntry entry)
{
for (int i = pragmaHandlers.size () - 1; i >= 0; --i)
{
PragmaHandler handler = (PragmaHandler)pragmaHandlers.elementAt (i);
handler.closeScope (entry);
}
} // closeScope
private Parser parser;
private Scanner scanner;
private Hashtable symbols;
private Vector macros;
// The logic associated with this stack is scattered above.
// A concise map of the logic is:
// case #if false, #ifdef false, #ifndef true
// push (false);
// skipToEndifOrElse ();
// case #if true, #ifdef true, #ifndef false
// push (true);
// case #elif <conditional>
// if (top == true)
// skipToEndif ();
// else if (conditional == true)
// pop ();
// push (true);
// else if (conditional == false)
// skipToEndifOrElse ();
// case #else
// if (top == true)
// skipToEndif ();
// else
// pop ();
// push (true);
// case #endif
// pop ();
private Stack alreadyProcessedABranch = new Stack ();
Token token;
private static String indent = "";
}