/**
* Reads an external skeleton file from a BufferedReader.
*
* @param reader the reader to read from (must be != null)
* @throws IOException if an IO error occurs
* @throws GeneratorException if the number of skeleton sections does not match
*/
public static void readSkel(TextReader reader)
{
isCSharpSkeleton = false;
notCSharpSkeletonWarned = false;
ArrayList lines = new PrettyArrayList();
StringBuilder section = new StringBuilder();
String ln;
while ((ln = reader.ReadLine()) != null)
{
if (ln.StartsWith("---")) //$NON-NLS-1$
{
lines.Add(section.ToString());
section.Length = 0;
}
else
{
section.Append(ln);
section.Append(NL);
}
}
if (section.Length > 0)
{
lines.Add(section.ToString());
}
if (lines.Count != size)
{
if (lines.Count == size * 2)
{
isCSharpSkeleton = true;
}
else
{
Out.error(ErrorMessages.WRONG_SKELETON);
throw new GeneratorException();
}
}
line = new String[lines.Count];
for (int i = 0; i < lines.Count; i++)
{
line[i] = (String)lines[i];
}
}
/**
* Returns all unused macros.
*
* @return the enumeration of macro names that have not been used.
*/
public IEnumerator unused()
{
#if DEBUG_TRACE
log.WriteLine("unused()");
#endif // DEBUG_TRACE
ArrayList unUsed = new PrettyArrayList();
IEnumerator names = used.Keys.GetEnumerator();
while (names.MoveNext())
{
String name = (String)names.Current;
bool isUsed = (bool)used[name];
if (!isUsed)
{
unUsed.Add(name);
}
}
return(unUsed.GetEnumerator());
}
public static ArrayList parseOptions(String[] argv)
{
ArrayList files = new PrettyArrayList();
for (int i = 0; i < argv.Length; i++)
{
if ((argv[i] == "-d") || (argv[i] == "--outdir")) //$NON-NLS-1$ //$NON-NLS-2$
{
if (++i >= argv.Length)
{
Out.error(ErrorMessages.NO_DIRECTORY);
throw new GeneratorException();
}
Options.setDir(argv[i]);
continue;
}
if ((argv[i] == "--skel") || (argv[i] == "-skel")) //$NON-NLS-1$ //$NON-NLS-2$
{
if (++i >= argv.Length)
{
Out.error(ErrorMessages.NO_SKEL_FILE);
throw new GeneratorException();
}
Options.setSkeleton(new File(argv[i]));
continue;
}
if ((argv[i] == "--nested-default-skeleton") || (argv[i] == "-nested"))
{
Options.setSkeleton(new File("<nested>"));
continue;
}
if ((argv[i] == "-jlex") || (argv[i] == "--jlex")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.jlex = true;
continue;
}
if ((argv[i] == "-v") || (argv[i] == "--verbose") || (argv[i] == "-verbose")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
{
Options.verbose = true;
Options.progress = true;
continue;
}
if ((argv[i] == "-q") || (argv[i] == "--quiet") || (argv[i] == "-quiet")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
{
Options.verbose = false;
Options.progress = false;
continue;
}
if ((argv[i] == "--dump") || (argv[i] == "-dump")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.dump = true;
continue;
}
if ((argv[i] == "--time") || (argv[i] == "-time")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.time = true;
continue;
}
if ((argv[i] == "--version") || (argv[i] == "-version")) //$NON-NLS-1$ //$NON-NLS-2$
{
Out.println(ErrorMessages.THIS_IS_CSFLEX, version);
throw new SilentExit();
}
if ((argv[i] == "--dot") || (argv[i] == "-dot")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.dot = true;
continue;
}
if ((argv[i] == "--help") || (argv[i] == "-h") || (argv[i] == "/h")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
{
printUsage();
throw new SilentExit();
}
if ((argv[i] == "--info") || (argv[i] == "-info")) //$NON-NLS-1$ //$NON-NLS-2$
{
Out.printSystemInfo();
throw new SilentExit();
}
if ((argv[i] == "--nomin") || (argv[i] == "-nomin")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.no_minimize = true;
continue;
}
if ((argv[i] == "--pack") || (argv[i] == "-pack")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.gen_method = Options.PACK;
continue;
}
if ((argv[i] == "--table") || (argv[i] == "-table")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.gen_method = Options.TABLE;
continue;
}
if ((argv[i] == "--switch") || (argv[i] == "-switch")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.gen_method = Options.SWITCH;
continue;
}
if ((argv[i] == "--nobak") || (argv[i] == "-nobak")) //$NON-NLS-1$ //$NON-NLS-2$
{
Options.no_backup = true;
continue;
}
if ((argv[i] == "--csharp") || (argv[i] == "-cs"))
{
Options.emit_csharp = true;
continue;
}
if (argv[i].StartsWith("-")) //$NON-NLS-1$
{
Out.error(ErrorMessages.UNKNOWN_COMMANDLINE, argv[i]);
printUsage();
throw new SilentExit();
}
// if argv[i] is not an option, try to read it as file
File f = new File(argv[i]);
if (f.isFile() && f.canRead())
{
files.Add(f);
}
else
{
Out.error("Sorry, couldn't open \"" + f + "\""); //$NON-NLS-2$
throw new GeneratorException();
}
}
return(files);
}
/**
* Constructs an NFA accepting the complement of the language
* of a given NFA.
*
* Converts the NFA into a DFA, then negates that DFA.
* Exponential state blowup possible and common.
*
* @param the NFA to construct the complement for.
*
* @return a pair of integers denoting the index of start
* and end state of the complement NFA.
*/
private IntPair complement(IntPair nfa)
{
if (Options.DEBUG)
{
Out.debug("complement for " + nfa);
Out.debug("NFA is :" + Out.NL + this);
}
int dfaStart = nfa.end + 1;
// fixme: only need epsilon closure of states reachable from nfa.start
epsilonFill();
Hashtable dfaStates = new PrettyHashtable(numStates);
ArrayList dfaVector = new PrettyArrayList(numStates);
int numDFAStates = 0;
int currentDFAState = 0;
StateSet currentState, newState;
newState = epsilon[nfa.start];
dfaStates[newState] = new Integer(numDFAStates);
dfaVector.Add(newState);
if (Options.DEBUG)
{
Out.debug("pos DFA start state is :" + Out.NL + dfaStates + Out.NL + Out.NL + "ordered :" + Out.NL + dfaVector);
}
currentDFAState = 0;
while (currentDFAState <= numDFAStates)
{
currentState = (StateSet)dfaVector[currentDFAState];
for (char input = (char)0; input < numInput; input++)
{
newState = DFAEdge(currentState, input);
if (newState.containsElements())
{
// Out.debug("DFAEdge for input "+(int)input+" and state set "+currentState+" is "+newState);
// Out.debug("Looking for state set "+newState);
Integer nextDFAState = (Integer)dfaStates[newState];
if (nextDFAState != null)
{
// Out.debug("FOUND!");
addTransition(dfaStart + currentDFAState, input, dfaStart + nextDFAState.intValue());
}
else
{
if (Options.dump)
{
Out.print("+");
}
// Out.debug("NOT FOUND!");
// Out.debug("Table was "+dfaStates);
numDFAStates++;
dfaStates[newState] = new Integer(numDFAStates);
dfaVector.Add(newState);
addTransition(dfaStart + currentDFAState, input, dfaStart + numDFAStates);
}
}
}
currentDFAState++;
}
// We have a dfa accepting the positive regexp.
// Now the complement:
if (Options.DEBUG)
{
Out.debug("dfa finished, nfa is now :" + Out.NL + this);
}
int start = dfaStart + numDFAStates + 1;
int error = dfaStart + numDFAStates + 2;
int end = dfaStart + numDFAStates + 3;
addEpsilonTransition(start, dfaStart);
for (int i = 0; i < numInput; i++)
{
addTransition(error, i, error);
}
addEpsilonTransition(error, end);
for (int s = 0; s <= numDFAStates; s++)
{
currentState = (StateSet)dfaVector[s];
currentDFAState = dfaStart + s;
// if it was not a final state, it is now in the complement
if (!currentState.isElement(nfa.end))
{
addEpsilonTransition(currentDFAState, end);
}
// all inputs not present (formerly leading to an implicit error)
// now lead to an explicit (final) state accepting everything.
for (int i = 0; i < numInput; i++)
{
if (table[currentDFAState][i] == null)
{
addTransition(currentDFAState, i, error);
}
}
}
// eliminate transitions leading to dead states
if (live == null || live.Length < numStates)
{
live = new bool [2 * numStates];
visited = new bool [2 * numStates];
}
_end = end;
_dfaStates = dfaVector;
_dfaStart = dfaStart;
removeDead(dfaStart);
if (Options.DEBUG)
{
Out.debug("complement finished, nfa (" + start + "," + end + ") is now :" + this);
}
return(new IntPair(start, end));
}
/**
* Returns an DFA that accepts the same language as this NFA.
* This DFA is usualy not minimal.
*/
public DFA getDFA()
{
Hashtable dfaStates = new PrettyHashtable(numStates);
ArrayList dfaVector = new PrettyArrayList(numStates);
DFA dfa = new DFA(2 * numLexStates, numInput);
int numDFAStates = 0;
int currentDFAState = 0;
Out.println("Converting NFA to DFA : ");
epsilonFill();
StateSet currentState, newState;
for (int i = 0; i < 2 * numLexStates; i++)
{
newState = epsilon[i];
dfaStates[newState] = new Integer(numDFAStates);
dfaVector.Add(newState);
dfa.setLexState(i, numDFAStates);
dfa.setFinal(numDFAStates, containsFinal(newState));
dfa.setPushback(numDFAStates, containsPushback(newState));
dfa.setAction(numDFAStates, getAction(newState));
numDFAStates++;
}
numDFAStates--;
if (Options.DEBUG)
{
Out.debug("DFA start states are :" + Out.NL + dfaStates + Out.NL + Out.NL + "ordered :" + Out.NL + dfaVector);
}
currentDFAState = 0;
StateSet tempStateSet = NFA.tempStateSet;
StateSetEnumerator states = NFA.states;
// will be reused
newState = new StateSet(numStates);
while (currentDFAState <= numDFAStates)
{
currentState = (StateSet)dfaVector[currentDFAState];
for (char input = (char)0; input < numInput; input++)
{
// newState = DFAEdge(currentState, input);
// inlining DFAEdge for performance:
// Out.debug("Calculating DFAEdge for state set "+currentState+" and input '"+input+"'");
tempStateSet.clear();
states.reset(currentState);
while (states.hasMoreElements())
{
tempStateSet.add(table[states.nextElement()][input]);
}
newState.copy(tempStateSet);
states.reset(tempStateSet);
while (states.hasMoreElements())
{
newState.add(epsilon[states.nextElement()]);
}
// Out.debug("DFAEdge is : "+newState);
if (newState.containsElements())
{
// Out.debug("DFAEdge for input "+(int)input+" and state set "+currentState+" is "+newState);
// Out.debug("Looking for state set "+newState);
Integer nextDFAState = (Integer)dfaStates[newState];
if (nextDFAState != null)
{
// Out.debug("FOUND!");
dfa.addTransition(currentDFAState, input, nextDFAState.intValue());
}
else
{
if (Options.progress)
{
Out.print(".");
}
// Out.debug("NOT FOUND!");
// Out.debug("Table was "+dfaStates);
numDFAStates++;
// make a new copy of newState to store in dfaStates
StateSet storeState = new StateSet(newState);
dfaStates[storeState] = new Integer(numDFAStates);
dfaVector.Add(storeState);
dfa.addTransition(currentDFAState, input, numDFAStates);
dfa.setFinal(numDFAStates, containsFinal(storeState));
dfa.setPushback(numDFAStates, containsPushback(storeState));
dfa.setAction(numDFAStates, getAction(storeState));
}
}
}
currentDFAState++;
}
if (Options.verbose)
{
Out.println("");
}
return(dfa);
}