/**
         * 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];
            }
        }
Beispiel #2
0
        /**
         * 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());
        }
Beispiel #3
0
        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);
        }
Beispiel #4
0
        /**
         * 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));
        }
Beispiel #5
0
        /**
         * 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);
        }