Intro to Theory of Computation

JFLAP7.1.jar

Home >Computer Science homework help >Intro to Theory of Computation

META-INF/MANIFEST.MF

Manifest-Version: 1.0 Main-Class: gui.Main Class-Path: .

DOCS/README

Whenever the user chooses "Help" from the help menu, JFLAP searches for a URL based on the class name of the currently active view in the environment. (The help function has other options available as well.) Therefore, to add help for a view that is an instance of a class or subclass of gui.wingdoodle.ClassBoy, merely add "gui.wingdoodle.ClassBoy.html" to this directory.

DOCS/combineAutomata.html

Combine Automata

This combines two automata to form a new automata. When invoked in one automaton, this oeprator searches for one or more automaton of the same type. The user then has a chance to select which of the others he wishes to combine with this automaton. Once selected, a new automaton with the states and transitions of both appears. Since an automaton may have only one initial state, the initial state of the automaton chosen in the dialog box is discarded. No transitions between the two automata will be created.

DOCS/error.html

You have encountered an error within JFLAP we apparently did not anticipate. Please, copy and paste the report below in an email to [email protected]. Please make sure you:

Are running the most recent version of JFLAP,
Copy and paste the contents of the box below as a report.
Also include a detailed description of what you were doing.

Alternatively, you may ignore this message if you'd rather not be bothered, but we do appreciate reports.

DOCS/fastSimulator.html

Fast Run...

This operator runs input on a machine without stepping. The user enters input, and JFLAP merely runs the input until the machine accepts or rejects the input, and informs the user. If the input is accepted, the trace of configurations that led to an acceptance is displayed, and the user has the option of stopping there (the "I'm done" button), or searching for alternate accepting traces in the event of nondeterminism (the "Keep looking" button).

Because Turing class machines have the ability to run forever without any guarantee of ever halting, after a large number of configurations are generated the user is prompted with the option of aborting the run, or continuing to search.

DOCS/filemenu.html

File Menu

New: This will allow the user to create a new, empty structure. A list of choices will allow the user to choose what type of structure to create: some variety of automaton, grammar, or regular expression.
Open: When chosen, an open dialog will allow the user to select and load a file previously saved with JFLAP.
Save: The structure in the window for this menu item will be saved to its file. If this structure does not have a file yet, this menu item will behave like "Save As", described below.
Save As: A save dialog will allow the user to choose a location and name for a file; once entered, the structure for the current window will be saved to that file. Further, the structure will thence be associated with that file.
Dismiss Tab: In every window there is at least one tab (tabs are shown just below the menu bar). If the user is done with the currently active tab, they may select this menu item to get rid of that tab. Some tabs cannot be dismissed, in which event the menu item will be grayed out.
Close: The current structure's window will be closed. If the structure has not been saved recently, it shall be.
Quit: All windows will be closed, and JFLAP will exit.

DOCS/gui.action.LambdaHighlightAction$LambdaPane.html

Highlight Lambda Transitions

This will highlight all lambda transitions. This operator may be applied to all machine types, but since only FAs and PDAs may have lambda transitions it will only produce useful results for those types of machines.

DOCS/gui.action.MultipleSimulateAction$MultiplePane.html

Multiple Run

This operator acts similarly to the "Fast Run" operator, except that it is able to run multiple inputs on a machine and acceptance traces cannot be viewed. The inputs to run are entered in a table. The left column of the table holds the inputs.

When the "Run Inputs" button is pressed, the right column of the table reports whether that input was accepted or not. The "Clear" button will delete all inputs. The "Enter Lambda" will blank the currently selected input, acting as though nothing were truly entered in that part of the table. The "View Trace" button returns a trace of the last configuration generated for a run.

There may be an arbitrary number of inputs. Similar to grammar input, when the last row of the table is edited, a new row will be added. Additionally, the input entries will be remembered between separate multiple input runs; this is useful if a user wants to check a batch of inputs on a variety of machines without having to retype the inputs, which is useful for grading purposes (for example).

The alternate "Multiple Run (Transducer)" action is applicable only to Turing machines, and behaves similarly to the regular multiple runs, except it produces not only whether the machine accepted, but also the output from each of the tapes. In other words, it runs the Turing machine as a transducer that not only accepts a given input but modifies it. The output for a tape is defined to be the contents of the tape from the symbol under tape head, and all symbols to the right of the tape head until the next blank tape symbol.

DOCS/gui.action.NewAction.html

Welcome to JFLAP. To start using this program, choose a machine type.

DOCS/gui.action.NondeterminismAction$NondeterminismPane.html

Highlight Nondeterminism

This operator may be applied to all machine types. It highlights those states that are nondeterministic, i.e., those states with nondeterministic transitions.

The above diagram shows an example NFA with nondeterministic states q0 and q3. q0 is obviously nondeterministic because of the a transitions. q3 is nondeterministic because JFLAP always considers any state with lambda transitions to be nondeterministic.

DOCS/gui.deterministic.ConversionPane.html

NFA to DFA

This operator may be applied to any nondeterministic FA. At the end of the operation, there will be a completed NFA.

The conversion practice used is the standard canonical method of creating an equivalent DFA from an NFA, that is: each state in the DFA being built corresponds to a nonempty set of states in the original NFA. Therefore, for an NFA with n states, there are potentially 2n - 1 states in the DFA, though realistically this upper bound is rarely met.

The interface for the creating a DFA from an NFA is shown above. The NFA is displayed for reference purposes in the left portion of the view. The DFA is created in the right portion of the view; in the example given, the conversion is complete and correct. The set of NFA states in shown in the label below each DFA state. Between the two diagrams for the two automatons is a bar that may be dragged left and right to adjust the allocation of sizes between the two diagrams.

Expansion of States

The first thing that happens is that the initial state is created. The initial state's set for the DFA consists of the initial set of the NFA, and the closure of all states reachable from that initial state on lambda transitions. This is done for the user: the only thing the user sees at first in the DFA constructor is this one initial state. In the example above, the initial NFA state is q0 and there are no lambda transitions from it, so the initial set is only 0.

One then uses the "Expand Group on Terminal" tool () to build the DFA. When this tool is active, one drags from a state (or group) into empty space.

The user is then queried as to what symbol to expand this group on, shown above. For example, for the initial set of q0, one can expand on 1 since there are transitions from that state in the original NFA.

Assuming that the original set of states actually expands on the input terminal, the user is then queried above the set of NFA states that group expands to on that terminal. In our running example, from the diagram we see that q0 expands on 1 to the states q0, q1 and q2. While q0 and q1 are fairly obvious, less obvious is the presence of q2. However, since there is a lambda transition from q1 to q2, the closure of q1 implies q2.

One would therefore enter 0 1 2 into the dialog shown above, as shown. (JFLAP would also accept q0 q1 q2, or 0,1,2, or q0, q1, q2, etc etc.)

When the user enters the set of states, and it is correct, the new DFA state is created at the point in empty space where the user originally dragged to. (If the user is incorrect, the user is gently chastised and nothing is added.)

Final states in the DFA are those states whose NFA state sets contain at least one final state from the NFA: in the example, notice that every state in the DFA with the NFA final state q3 in its set is a final state. JFLAP will detect if the user entered any states that were final states, and if so make the state it creates a final state.

The "Done?" button will check the DFA to see if it is complete. If it is, then this completed DFA will be exported to its own window, where it may be treated like any other FA.

Help

While it is possible for one to build the DFA entirely through use of the "Expand Group on Terminal" tool (), one also has the option of letting JFLAP do some or all of the work.

The "State Expander" tool () is a moderate help tool. When active, if you click on a state, it will expand that group on all terminals to all other groups it goes to. Any newly created states will be randomly placed.

The "Complete" button will complete the DFA entirely.

Details and Detritus

The NFA to DFA procedure depends on having transitions with at most one character. As JFLAP allows multiple character transitions, all of these are automatically broken up: the transition abc would be broken into three transitions, with two new bridge states created.

Additionally, when expanding a set of states, if the destination set of states is already in the DFA, instead of dragging to empty space, one may drag to that second set of states, and the user will not be queried as to the set of states it goes to. It is considered that the user has already made that choice. However, if the user does drag to empty space and input a set that already exists, then a new state will not be created; it clearly does not do to have multiple identical sets.

DOCS/gui.editor.EditorPane.html

The Automaton Editor

Editing a finite automaton.

The Editor Pane

The editor pane has two main components. On the top is a detachable tool bar (the section with the four iconic buttons), and on the bottom is the canvas where the automaton is drawn.

The automaton is edited through clicks on the canvas. The current action taken in response to those clicks depends on the currently selected tool. Notice in the picture that the first button, the one with the mouse cursor, is selected: this indicates that it is selected.

To select another tool, click on it, or use its shortcut key. You can get the shortcut key, as well as a short description of the tool, by holding the cursor over the tool button. After a short time this should display a tool-tip with information.

The descriptions for those tools are shown below.

The Tools

The State Tool (the "S" key): While the state tool is selected, a click on the canvas will create a new state centered at the point that was clicked.
The Transition Tool (the "T" key): By dragging from one state to another, a transition from the first state clicked to the second state dragged to will be created. Looping transitions from a state to itself are handled no differently. Once two states are joined with the tool, the user will then be asked for certain parameters of the transitions.
The Delete Tool (the "D" key): This will erase any transition or state it is clicked on. If a state is deleted, those transitions incident on or emanating from a state will be deleted as well.
The Attribute Tool (the "A" key): This tool is used to modify existing states and transitions. To move states, drag them with this tool. Dragging transitions will move transitions. Clicking on a transition edits a transition. A user may right-click (control click on Macs that have only one mouse button) on a state to bring up a pop-up menu to define the state as final, to define the state as initial, to set its label (an auxiliary description for a state), to clear its label (if it has one), or to clear all labels of all states.
Right-clicking in a blank portion of the canvas will bring up a different pop-up menu. One option of this menu is to hide or show labels; if labels are hiden, the user may hold the mouse cursor over a state to bring up a tool-tip with the label for that state. The other option is the graph layout algorithm, which will rearrange the states of the automaton. As a nota bene, this popup menu is available in all views with an automaton; however, as one might expect the user may use the graph layout algorithm only where JFLAP allows the moving of states.

Editing Transitions

Only one transition may be edited at a time. While a transition is being edited, fields appear that allow the user to change parameters regarding that particular transition. Each field corresponds to a particular parameter of that transition. In order to find out which is which during runtime, hold the mouse cursor over one of the fields; a tool tip will pop up to tell what it is.

Note that separate transitions must be placed in separate transitions; for example, in a FA, the three separate transitions a, c, and d cannot be abbreviated as the single transition a, c, d.

Editing a Turing machine transition.

A finite automaton's transition editor will have a single field representing what characters are read from the input. A pushdown automaton's transition editor will have three fields, the first to define what characters to read from input, the second to define what characters to pop from the stack, and the third to define what characters to push. A Turing machine's transition editor will also have three fields, one for the read character, one for the write character, and one for the direction to move the tape head (L, S, and R for left, stay, and right). To select the direction, click on the direction field and select from the menu or type shift-L, shift-S, or shift-R when the direction field is selected. A multi-tape Turing machine is similar, but it has as many rows as tapes; each row follows the convention of Turing machine transitions defined previously. To enter lambda entries for FAs and PDAs, simply leave a field blank. Leaving a field blank in a Turing machine is not lambda, but is the blank tape symbol (represented as a square).

To stop editing, take some other action with the tool, or click in an empty space on the canvas, or press return/enter. To cancel the editing of a transition and to revert that transition to its state before the edit, press escape. If there is anything irregular about the transition entered, the program will display an error and revert the transition to its state before the edit. Currently, the only restriction on transitions are on transitions for Turing machine: a Turing machine transition must read exactly one character and write exactly one character per tape. If the read or write fields for a Turing machine are left empty, the blank tape alphabet symbol is assumed to be the content of that field. Pressing shift-return/enter will stop editing the transition, and begin the process of editing a new one between the start and end states of the transition that we just stopped editing.

In Haiku

In the editor, The canvas dominates all, The tool-bar's on top.

Choose a different tool. Your clicks upon the canvas now serve different ends.

Clicks on the canvas make new automaton states when this tool's active.

This creates transitions. From one state to another one may drag the mouse.

A table pops up to define the transition. When done, press return.

If in editing mistakes are made in entry escape will cancel.

State or transitions are removed from the canvas through use of this tool.

This changes attributes. A click edits transitions, dragging states moves states.

Right click on a state. A menu lets you make it final or initial.

To switch tools quickly without much mousing about use the shortcut keys.

Tools each have tool-tips. Mouse over a tool to see it. The shortcut's shown there.

When you are finished, to apply an operation, choose from the menu.

DOCS/gui.grammar.GrammarInputPane.html

The Grammar Editor

In JFLAP grammars are edited and displayed in a simple table, as shown above. Each row corresponds to a single production. The left and right columns correspond to the left and right sides of a production, naturally. To enter a rule in a particular row, select the leftmost cell of that row and type in the left hand side of the rule. Then select the rightmost column (the arrow in the middle column will appear automatically) and enter the right hand side of the rule. Lambda productions have blank right hand sides. Every symbol in the grammar is assumed to be a single character, with upper case letters as the variables, and all other characters as terminals. The left hand side of the production in the first row is always assumed to be the start variable. The table is automatically grown by one row if the last row is ever edited.

In the above picture, for example, the grammar shown has the variable set {S, A, B}, and the terminal set {a, b}. The start variable is S. There are the productions S AB, A a, B bB, and B . So, the language accepted by this grammar is ab*, that is, a followed by zero or more bs.

Unlike automaton editing, the type of grammar is not defined at the time when editing begins. Rather, many of the operators applied to grammars have conditions that a grammar must satisfy. This is to say that JFLAP will notify the user of constraints upon a grammar when the user attempts to apply an operation to the grammar.

DOCS/gui.grammar.automata.ConvertPane.html

Automaton to Grammar Converters

Converting an FA to a Grammar Incomplete conversion of an FA to a grammar

To add the productions for an object, click on an object that corresponds to a production in the FA. If a grammar production is selected, the object in the automaton that it was generated by will be highlighted. Eventually all productions will be added, and the grammar may be exported. For an FA, there will be exactly one production for every transition and final state. For a PDA, there will be productions for only transitions, though there may be many of them. Specialized notes for these two operations are written below.

The tool bar has some helpful controls:

Hint: This will convert one object (transition or, in the case of FA, final state) to the appropriate set of productions.
Show All: All remaining productions will be added.
What's Left?: All convertible but as yet unconverted objects will be highlighted.
Export: Once conversion has finished, the grammar may be output.

FA to Grammar

This operation converts a FA to a regular (specifically right linear) grammar. This operation is featured in the window above. Each state in the FA corresponds to a variable in the grammar, which is shown slung beneath each state. The terminals for the grammar are the symbols on the transitions.

Each transition and each final state correspond to a production in the grammar, with finals states correspond to lambda productions, and for a transition of a between two states labeled A to B, the production A aB is added.

PDA to Grammar

The conversion from PDA to Context-Free Grammar requires that the PDA have a certain form before the conversion begins:

only one final state
accepts only if stack is empty
each transition has the form: a,A; or a,A;BC

In the PDA transformation, all variables in the resulting Context Free Grammar (CFG) will be formed from two states and a symbol from the alphabet. In other words, one variable is represented in the form qiAqj where i and j are numbers corresponding to states in the PDA and A is a symbol in the alphabet of the PDA.

The actual rule generating begins with the starting rule. The variable for the starting rule is found by concatenating the initial state with the end of stack character(Z) and the beginning state.

For example, if an automata had an initial state q0 and a final state q3, the starting rule would be Sq0Zq3.

Once the starting state is established, the transitions must be processed.

Transitions of the form a, A; from state qi to state qj are converted to qiAqja
Transitions of the form a, A; BC from state qi to state qj are converted to the set of rules: { qiAqx a (qjBqy) (qyCqx) | qx and qy are states in the automaton}.

When exporting, each of the qiAqj symbols has a single character variable substituted in its place.

DOCS/gui.grammar.convert.ConvertPane.html

Grammar to Automaton Converters

LL conversion of a grammar to a PDA. Completed LL Conversion of a Grammar

LL conversion of a grammar to a PDA. Completed LR Conversion of a Grammar

There are three options to transform a grammar to an automaton: "Convert to PDA (LL)", "Convert to PDA (LR)", and "Convert Right Linear Grammar to FA". Any restricted grammar may be transformed to a PDA by either the LL or LR algorithm, while converting a grammar to an FA requires a right-linear grammar. Every production in a right-linear grammar has on the right hand side at most one variable, which is to the right of any terminals.

The grammar to PDA interfaces (both LL and LR) are shown above. In the LL converter, each production on the left side of the window corresponds to a loop transition on the middle state of the automaton. By selecting productions in the left hand side, if the corresponding transition has already been created it is highlighted. A small checkbox next to each productions reveals if it has been created yet.

In these sorts of converters, each production in the grammar corresponds to a transition. There is an automaton editor in which a user enters transitions normally. If the transition the user enters does not correspond to any production, she is notified and the transition is removed. Other controls are available as well:

Show All
: All required transitions are added.
Create Selected
: This will take all selected productions in the left table and add the corresponding transition.
Done?
: This will check if anything remains to be done. If something remains, the user is informed. If nothing remains, the user is informed to this effect and is then allowed to export the resulting PDA.
Export
: Once all the transitions that need to be added are added, and the user has checked whether she is done yet, the user may export and use this newly built automaton with this control.

DOCS/gui.grammar.parse.BruteParsePane.html

Brute Parser

Parsing an unrestricted grammar.

JFLAP can not only parse grammars with parse tables, but can attempt a brute force substitution parse as well. This sort of parse works not only for restricted grammars, but unrestricted grammars as well where there may be terminals and multiple symbols on the left hand side. A simple unrestricted grammar is shown above.

First, one enters a string to attempt to parse in the text field labeled "Input." When one has entered the string, one either presses "Start" or types return to begin the process of parsing. The brute force parser will attempt to parse the string. The first accepting parse found will be shown.

This method of parsing can take a very long time since it explores every possibility of substitution of variables. Moreover, since the language accepted by unrestricted grammars is equivalent to Turing recognizable languages, there is no guarantee that the brute force parser will ever stop in the event of an unrestricted brute force parse. An example is the grammar shown in the example picture above: attempt to parse ab on that grammar and it will never terminate. If a parse is taking too long for the user's taste, pressing "Pause" will halt it. The search can be resumed by pressing "Resume." If another string is input while the searcher is searching, the original search will be terminated in favor of the new search.

During the course of this search, a small display will indicate how many non-pruned nodes have been added to the tree. Another (faster changing) value in parentheses will indicate how many nodes were examined in the current subtree. JFLAP performs some very aggressive pruning to make this most inefficient of routines run as quickly as possible, so there will usually be few nodes added to the tree versus the number of nodes examined.

If a string is rejected, unlike in LR(1) and LL(1) parsing there is no intermediate tree displayed; a simple message will appear below the input field. If a string is accepted, one repeatedly presses "Step" to show the next phase of the transformation. The "Input Remaining" shows what input the parser has yet to process, including a terminating $ character. The "Stack" shows the current contents of the stack. A message at the bottom of the window will show what is currently happening; in the image above, it shows that we are in the process of replacing S with aSb. JFLAP will highlight the node of the tree that was last processed on the stack. Whenever an entry in the parse table is used, that entry is highlighted in the table. One presses this step button until the accepting derivation is shown.

The default view is a non-inverted tree. In the tree, yellow nodes are the leaf nodes, i.e., terminals that are not substituted in the future. Green nodes are internal nodes, i.e., non-terminals and terminals that are substituted. An unrestricted grammar parse has the ability to combine multiple symbols together and substitute them with other symbols; this multiple parentage is achieved by grouping nodes together in a blue rounded rectangle and treating that as a single node. The other view option available is the "Derivation Table": this will show the attempts of the parser to derive the input string from the start variable, and the productions used in the process of derivation.

DOCS/gui.grammar.parse.LLParsePane.html

LL(1) Parsing

In the middle of a sample LL(1) parsing.

Before LL(1) parsing can take place, first an LL(1) parse table must be defined according to the operations defined here.

First, one enters a string to attempt to parse in the text field labeled "Input." When one has entered the string, one either presses "Start" or types return to begin the process of parsing.

After a string is entered, one repeatedly presses "Step" to show the next phase of the parse. The "Input Remaining" shows what input the parser has yet to process, including a terminating $ character. The "Stack" shows the current contents of the stack. A message at the bottom of the window will show what is currently happening; in the image above, it shows that we are in the process of replacing S with aSb. JFLAP will highlight the node of the tree that was last processed on the stack. Whenever an entry in the parse table is used, that entry is highlighted in the table. One presses this step button until the string is either accepted or rejected by the parse table.

The default view is a non-inverted tree. In the tree, yellow nodes are the leaf nodes, i.e., terminals. Green nodes are internal nodes, i.e., non-terminals. There are other view options available. The current display shows a non-inverted parse tree. Also available is an "Inverted Tree" which is the same thing drawn upside down, which is more useful for LR(1) parsing. Also available is the string derivation view: for LL(1), this will show the attempts of the parser to derive the input string from the start variable, and the productions used in this derivation.

DOCS/gui.grammar.parse.LLParseTableDerivationPane.html

Build LL(1) Parse Table

LL(1) parse table building.

The user may build a LL(1) parse table for a grammar with this operator. A full discussion of the method of building an LL(1) parse table is far too elaborate for this documentation. Rather, this assumes that one has some understanding of building LL(1) parse tables, and merely explains JFLAPs interface convention for helping the user complete this procedure.

The LL(1) parse table construction and parse tree construction algorithm is as described in the ``Dragon'' compiler book. Put very loosely, the idea behind LL(1) parsing is that the grammar starts with the start symbol, and repeatedly attempts to replace variables with their right hand side expansion based on what the next symbol of the input is, until the input string is derived.

Steps

When the user first chooses the menu item to build the parse table, JFLAP first checks to make sure that the grammar is LL(1). If it is not, then the user is warned and is given the option to abort. Assuming the grammar is LL(1), or if the user wishes to continue in spite of the grammar not being LL(1), these following steps are completed in order:

The user first enters the first sets for each variable, i.e., the set of terminals that a variable can start with. ! serves as the special symbol for lambda. This set is entered by the user as a simple string of symbols, without any delimiters: e.g., if the user wishes to indicate that a, b, and are in the first set, then the user enters ab! as a single non-spaced string. When the user is finished defining the first sets, he or she may press "Next," and JFLAP will either move to defining the follow sets, or will notify the user about errors.
The user then enters the follow sets for each variable, i.e., the set of terminals that can immediately follow a variable in a derivation. The input convention is the same as for the first sets, except that the $ symbol indicates the end-of-string character. When the user has finished, again "Next" may be pressed to move on or be notified of errors.
With the first and follow sets as a reference, it is possible to fill out the entries in the parse table. Given a production A and every symbol b in FIRST(), the (b, A) entry in the table gets . Multiple entries in a table cell (possible only if the grammar is not LL(1)) are separated by spaces. The ! string represents a lambda production.

Help

Users may elect to let JFLAP do some or all of the work rather than entering data themselves.

Do Selected: In any of the above steps, the user enters input into cells in a table. If the user selects any of these cells and elects to "Do Selected", the answer appropriate to the cells will be entered into those cells which are currently selected. Non-selected cells shall be left alone.
Do Step: This will either complete all first sets, or all follow sets, or complete the parse table according to which step we are on.
Do All: This will do everything. After pressing this, JFLAP should display a working parse table.

Parsing Details

The top figure shows a completed LL(1) parse table. Once the table is completed, the user has the option to proceed to parsing strings using the table by pressing the "Parse" button. The interface for that parsing is explained here. If the original grammar was not LL(1) the user will not be able to use the parse table to parse strings.

DOCS/gui.grammar.parse.LRParsePane.html

LR(1) Parsing

In the middle of a sample LR(1) parsing.

Before LR(1) parsing can take place, first an LR(1) parse table must be defined according to the operations defined here.

The interaction relevant to the parsing of strings in LR(1) parsing is identical to the parsing of strings in LL(1) parsing. See the notes on LL(1) parsing to learn about the interface.

The LR(1) parsing algorithm is, of course, very different from LL(1): the stack is used differently, and the parse is bottom-up rather than top-down as in LL(1) parsing. In addition, when reducing according to a production, the production is highlighted. However, the interface is identical.

DOCS/gui.grammar.parse.LRParseTableDerivationPane.html

Build LR(1) Parse Table

LR(1) parse table building.

The user may build a LR(1) parse table for a grammar with this operator. As with LL(1) table building, a full discussion of the method of building an LR(1) parse table is beyond the scope of this discussion. The procedure followed is more or less the same as the SLR parse table building in the Dragon compiler book.

This shares some similarities with the LL(1) parse table builder view. The similarities include the building of the first and follow sets, the operations of controls at the top of the help window and so forth. That may be helpful as a reference.

NB: In this view, you may resize the views to see things better. For example, dragging the bar between the sets of items diagram and the parse table will adjust the sizes of both.

Steps

The following steps are completed in order to build an LR(1) parse table:

The user first enters the first and follow sets for each variable. The interaction that takes place here is identical to that of the LL(1) parse table's first and follow sets construction.
A set of items construction.
The next step is the construction of the sets of items in a transitional diagram. What a transitional diagram is and how it is put together is not covered here, as a full description would be prohibitively long. JFLAP represents a transitional diagram by a FA as shown in the figure at the top of the page, with each state corresponding to a set of items. The initial set of items corresponds to the initial state, and final states represent terminating sets of items. The items in a set are shown in the label below a state.

An item is essentially a production with some placeholder character; JFLAP uses an underscore, _, as this special character. A production A BCD can produce the four items A _BCD, A B_CD, A BC_D, and A BCD_. The marker _ in an item represents which symbols have been processed (to the left of the marker) and which have not been processed (to the right of the marker).

During the first part of the sets of items construction, the initial set of items is put together (i.e., S' S and its closure). To expand that set, use the transition tool (), and drag from a set to an empty space in the diagram. The user is queried as to the symbol to expand the set of items on. Once the user enters a grammar symbol and JFLAP confirms that the set of items does goto on that set, a dialog then pops up allowing the user to define the set of items.

The view used for defining a set of items is shown above. The left hand column lists those productions in the grammar. The right hand column lists items already part of the set. To add an item to the set, click a production in the left hand list. A pop-up menu will appear with all possible placements of the sets of items. To save time, the "Closure" item will take whatever items are selected in the right column, and add all items which comprise the closure of the selected item. The "Finish" button will add all items that should be in the set of items. When "OK" is pressed, the answer will be checked for mistakes. If everything is fine, a new set of items will appear at the point in the empty space that the user initially dragged to.

If the user wishes to define a transition from an existing set of items to another existing set of items, in creating the transition she may drag to the second set rather than to empty space. This will avoid the bother of defining the second set of items, as JFLAP will assume the set dragged to is that second set.

One uses the attribute tool () to drag states around, and set final and initial states as per the usual practice when editing. The attribute tool here does not have the ability to change transitions or set labels.
Once all sets of items are constructed, the parse table is built. In the parse table, a blank entry indicates an error in parsing, s means shift, r means reduce, a single number means goto that item, and acc is accept. To change the content of a cell, click the cell and start typing. For reduction, the number following the r is a production number. The productions are indexed from 0 onward in the order shown in the list on the left. For example, in the grammar given above r1 means "reduce by S aSb." To determine the number of a production without counting, hold the mouse over the production, and a tool tip will appear with the production number. Also, you may hold the mouse over entries over a parse table to get via tool tips descriptions more comprehensible than simple r1 or s2 or what have you. When the table is completed the user may press "Next." If there are no errors, one may proceed to parse strings with that table.

Help

The style of help that is available for LR(1) table construction is nearly identical to that available for LL(1) table construction: "Do Selected," "Do Step," and "Do All" are all there and work in the same fashion.

In the case of the sets of items construction, the help options available are "Do Step" and "Do All," which will randomly place any set of items. After the items are placed, one may rearrange them to make the view more aesthetically pleasing, but it will otherwise be immutable.

Parsing Details

The top figure shows a completed LR(1) parse table. Once the table is completed, the user has the option to proceed to parsing strings using the table by pressing the "Parse" button. The interface for that parsing is explained here.

There may be at least one cell in the table with more than one rule, and the user may choose which of the rules to use before parsing. Cells with more than one expansion are highlighted in a sort of sherbet orange color. One may click on these cells, and a pop-up menu will appear allowing the user to select which expansion to use for this cell. Note that if clarifying ambiguity becomes necessary, the parse table may not accept the same language as the original grammar since, obviously, the parser will not be aware that alternate shifts/reductions/whatever exist.

DOCS/gui.grammar.transform.ChomskyPane.html

Chomsky Converter

Unit production remover

This action is the final of four steps in transforming a grammar to Chomsky normal form (CNF). The goal is to reform the grammar so that it generates the same language as the original, but is in Chomsky normal form. A grammar in Chomsky normal form (CNF) has all productions be either to two variables, or a single terminal.

The converter works as follows: the user starts with the original grammar, and repeatedly converts productions that are not CNF already. It works rather simply on two cases.

The first case is if a production has multiple symbols in its right hand side with at least one of those symbols as a terminal. In this case, any terminal symbols are converted to variables like so: for any terminal , a production B() will be introduced, and the variable B() will replace in the original production.

The second case is if a production has more than two variables in its right hand side, but no terminals. For example, take ABCDE. In this case, that production is replaced with the two productions ABD(n) and D(n)CDE, where n is some positive integer. One would then have to convert the D(n)CDE production.

This process is repeated until there are no productions that are not in CNF form.

As a note, the CNF converter will attempt to introduce as few new productions as it can, and will attempt to reuse existing variables and productions wherever possible.

Help & Controls

"Convert Selected" will take any production currently selected in the grammar editing view, and break it down via the method listed above; double clicking on a production accomplishes the same effect. "Do All" will make the grammar CNF in one fell swoop. "What's Left?" will highlight those productions that remain to be converted. "Export" is available only when the grammar is CNF, and will take this reformed grammar and put it in its own window.

DOCS/gui.grammar.transform.LambdaPane.html

Lambda Removal

Lambda production remover

This action is the first of four steps in transforming a grammar to Chomsky normal form. The goal is to reform the grammar so that it generates the same language, but has no lambda productions. The goal is to have no rule in the grammar derives the empty string. The requirement is that the start variable cannot derive lambda. This operator consists of two major steps:

The selection of variables that derive lambda.
The modification of the grammar.

The left side of the interface shows the original grammar. The functionality of the two toolbars shall be covered later. There are three labels between the two toolbars; the first tells which step the user is currently on, the second indicates how much work remains, and the third indicates which variables derive lambda.

Selection of Lambda Variables

The first step is to select those variables that derive lambda. In the example grammar given in the picture above, obviously B and C derive lambda, but so does A because of the rule ABC.

The user indicates a variable by clicking in the grammar table to the left (which holds the original grammar); the left hand side of the production clicked is assumed to be the desired variable. For example, if the user clicks the production ABCD, then JFLAP believes the user is indicating the variable A.

In order to complete this step, the user must indicate all variables that derive lambda. As the variables are selected (and verified to be correct), they will appear in the third label that shows which variables derive lambda. The second label will indicate errors to the user if any are made.

Reforming the Grammar

The next step is to reform the grammar. There are two major parts to this: removing lambda productions, and adding new productions to ensure that the grammar accepts the same language.

To edit the grammar, use the grammar view in the lower right. Editing is like it is in the regular grammar view, with the exception that if any production is added that is not part of the reformed view, the user will be notified and it will be added. Additionally, existing productions cannot be edited: only the last row may be edited. To remove lambda productions, select those productions you wish to remove, and click the "Delete" button.

As far as what rules to add, if ABCDB is in the grammar and B and C derive lambda, the user would add the seven productions that consist of almost all permutations of the absence and presence of the variables that derive lambda, i.e., the first B, C and the second B. These are shown in the table below. (There are seven and not eight because the permutation where they are all there is already part of the grammar. Note that the variables are not really being deleted so much as they are being substituted with the empty string.)

Productions added for ABCDB.

AD	ADB	ACD	ACDB
ABD	ABDB	ABCD

Adding these permutations of rules can become tedious. If there is a rule which implies the addition of a large number of permutations, the user may select the rule in the left hand-side table, and press the "Complete Selected" control. This will make the additions implied by that production for the user.

There are a few caveats. First, no rule is added twice. If we had the production ABB with B deriving lambda, then the user would add the rule AB only once. Moreover, if AB just happened to be part of the grammar anyway, we would not add it at all. Additionally, in case it is not obvious, the user does not add lambda rules, so she would not add A .

Help & Controls

The "Do Step" button will complete the current step only (either detecting lambda variables, or reforming the grammar). "Do All" will complete both steps. The "Delete" and "Complete Selected" are covered in the section about reforming the grammar. "Proceed" and "Export" are available only when the grammar is completed: "Export" will take this reformed grammar and put it in its own window, while "Proceed" will take the reformed grammar and go to the next phase of the CNF conversion, unit production removal.

DOCS/gui.grammar.transform.UnitPane.html

Unit Removal

Unit production remover

This action is the second of four steps in transforming a grammar to Chomsky normal form. The goal is to reform the grammar so that it generates the same language as the original, but has no unit productions. A unit production is a production with a single variable on the right hand side. This operator consists of two major steps:

Drawing the variable dependency graph.
Modifying the grammar to remove unit productions.

The left side of the interface shows the original grammar. The functionality of the two toolbars (top and middle) shall be covered later. There are two labels between the top toolbar and the variable dependency graph; the first tells which step the user is currently on and the second indicates how much work remains.

Variable Dependency Graph

The first step is to draw a variable dependency graph (VDG). As you can see, drawing a variable dependency graph uses the same interface for defining an automaton. The regular arrow tool is there for moving variable nodes about, and the transition tool is there to define edges.

The directed graph is defined this way: there is a node for every variable, with the variable name displayed inside the node. The user has the responsibility of defining the edges in the VDG. An edge exists from node A to B in the VDG if and only if there is a unit production AB in the grammar.

The goal is to relate how variables are "connected" via unit productions, so that when we remove all unit productions we are able to better tell which relationships we need to preserve. This is discussed more later.

Reforming the Grammar

The next step is to reform the grammar. There are two major parts to this: removing unit productions, and adding new productions to ensure that the grammar accepts the same language.

Note that the interface for grammar editing is exactly the same as the reformation of the grammar with regard to the lambda production removal: we're merely adding and removing different types of productions. Since the interface is identical, it makes no sense to repeat that information.

As far as what rules to add, the idea is that if we have the unit production AB, then to generate the same language after removing that unit production we must add A for every B production. (As a special case, note that we do not add unit productions in this substitution, so that if AB and BC are in the grammar, we do not add AC.) However, in addition to this, if there are BC and CD unit productions, we also add A and A for every C and D .

This is where the VDG comes in handy: if A is an ancestor of B in the VDG (even a non-immediate ancestor!), then for every B we add A .

Note that if we select the unit production AB in the left grammar view, and press "Complete Selected", this will add all A productions for every B production currently in the grammar that is not already part of the grammar.

Note that in the example given in the figure above, we have the rules Ba and Bb, and since both A and S are ancestors of B, both variables now have rules where they directly derive a and b.

Help & Controls

The "Do Step" button will complete the current step only (either defining the edges in the VDG, or reforming the grammar). "Do All" will complete both steps. "Do Selected" is available only when the grammar is being edited; when pressed, any selected unit productions in the grammar editing table will be deleted, and replaced with the appropriate productions. "Proceed" and "Export" are available only when the grammar is completed: "Export" will take this reformed grammar and put it in its own window, while "Proceed" will take the reformed grammar and go to the next phase of the CNF conversion, useless production removal.

DOCS/gui.grammar.transform.UselessPane.html

Useless Removal

This action is the third of four steps in transforming a grammar to Chomsky normal form. The goal is to reform the grammar so that it generates the same language as the original, but any useless productions are removed.

Determining which variables derive terminals.
Drawing the variable dependency graph.
Modifying the grammar to remove these useless productions.

Terminal Deriving Variables

The first step is to determine which variables are even capable of deriving terminals. One can have those variables that derive only terminals, and then repeatedly find variables that have productions with only those variables and terminals, and repeat this process until no terminals are added.

The interface for the user to input these variables is identical to the interface for the user to input which variables derive lambda in the lambda production remover, so you are referred there for information about that interface.

Variable Dependency Graph

The second step is to draw a variable dependency graph (VDG) among those variables that derive terminals. As you can see, drawing a variable dependency graph uses the same interface for defining an automaton. The regular arrow tool is there for moving variable nodes about, and the transition tool is there to define edges. The initial variable in the grammar is represented as an initial state in an automaton.

The directed graph is defined this way: there is a node for every variable that derives a terminal, with the variable name displayed inside the node. The user has the responsibility of defining the edges in the VDG. An edge exists from node A to B in the VDG if and only if there is a production A B in the grammar, i.e., B appears in the right hand side of some production of A. The goal is to relate how variables depend on each other.

Reforming the Grammar

The last step is to reform the grammar. (Those rules with variables that do not derive terminals are automatically removed and will not appear.) In this case, one need only remove those productions that are useless.

At this stage, a useless production is a production with some variable V, where V in the VDG does not have the start variable's node as an ancestor. The deletion of those productions is handled just as it is when deleting lambda productions in the lambda production remover's grammar interface, so look there for help with the interface.

Help & Controls

The "Do Step" button will complete the current step only (either detecting terminal deriving variables, or defining the VDG, or deleting useless productions). "Do All" will complete both steps. "Proceed" and "Export" are available only when all useless productions have been removed: "Export" will take this reformed grammar and put it in its own window, while "Proceed" will take the reformed grammar and go to the next and last phase of the CNF conversion, Chomsky normal form converter.

DOCS/gui.lsystem.DisplayPane.html

L-System Renderer

Rendering of the Dragon Fractal

The L-system renderer available in the input menu allows one to take an L-system and render that system for various levels of substitution. In the example picture we see the rendering of the dragon L-system given here.

JFLAPs L-system renderer subscribes to the canonical "turtle" metaphor, that is, an imaginary entity that moves about in a world, turning this way and that, and marking its territory as it moves forward. Functionally it is similar to other L-system renderers that exist, but it has a few major differences from the majority I encountered:

It can render 3D L-systems (albeit as orthogonal projections).
Assignable values and parameters may take the form of mathematical expressions.
It has an actual GUI slightly more complex than a handful of buttons and a drawing area. I don't know why this is unusual, but it is.

Definition of an L-System

Parameters

During the definition of the L-system the user has the chance to define some parameters in the table of the L-system input pane to affect the initial state of the drawing environment. What follows are a list of all recognized parameters, their default value for the renderer if they are not defined, and how they are used.

Parameter	Default	Description
distance	15	Lines are drawn with length distance.
color	black	Lines are drawn with the color specified by color. Colors may be specified by name. The acceptable color names are black, blue, brown, cyan, darkGray, darkOliveGreen, darkOliveGreen2, dukeBlue, forestGreen, goldenrod, gray, green, lightGray, magenta, maroon, oliveDrab, orange, orangeRed, pink, purple, red, springGreen, violetRed, white, and yellow. Color names are case sensitive! Additionally, one may specify a given color according to three numbers of the form a,b,c. If a, b, and c are all within the range of [0.0, 1.0], they are interpreted as hue, saturation, and brightness values respectively (where the hue range of 0 through 1 represents a full tour around the color wheel), and are used to define a color appropriately. If any of those values is outside of that range they are treated as standard red, green, blue respectively, with each channel value ranging in increasing intensity from 0 to 255 as is normal. For example, blue may be defined either as an HSB color by .667,1,1 or as an RGB color by 0,0,255.
polygonColor	red	Polygons are filled with the color specified by polygonColor. This parameter accepts the same value types as the color parameter.
angle	15	Whenever the turtle is turned, pitched, or rolled, it does with angle degrees. Note that this parameter may also be named by angleIncrement (a compatibility measure with my first implementation).
hueChange	10	When the command to increment the hue of the current drawing color is given the degrees the hue is turned is hueChange.
lineWidth	1.0	Lines are drawn with a pixel-width of lineWidth. This parameter accepts real number values greater or equal to zero (e.g., 4, 1.5, 0).
lineIncrement	1.0	When the line width (the parameter lineWidth) is incremented or decremented, it is incremented or decremented by this amount.

Drawing & Turtle Symbols

The following symbols are used to move the turtle about, and otherwise affect the state of the drawing. Whenever appropriate, a parameter will appear to indicate that the action associated with the symbol uses a quantity that can be changed. For example, & causes the turtle to pitch down by angle degrees. If the user has specified that angle=30, then the turtle will pitch down by 30 degrees.

Symbol	Description
g	Move forward distance in the y direction with the pen down, producing a line of width lineWidth and of color color, unless we are building a polygon, in which case a line is not drawn and the end point of this move is added to the polygon.
g(value)	Like the above, but with a specified distance.
f	Move forward distance in the y direction with the pen up, producing no line but changing the position of the turtle.
f(value)	Like the above, but with a specified distance.
+	Turn right (clockwise in 2D) by angle degrees. Turns about the z-axis.
+(value)	Like the above, but with a specified number of degrees.
-	Turn left (counter-clockwise in 2D) by angle degrees. Turns about the z-axis.
-(value)	Like the above, but with a specified number of degrees.
&	Pitch down by angle degrees. Turns about the x-axis.
&(value)	Like the above, but with a specified number of degrees.
^	Pitch up by angle degrees. Turns about the x-axis.
^(value)	Like the above, but with a specified number of degrees.
/	Roll right by angle degrees. Turns about the y-axis.
/(value)	Like the above, but with a specified number of degrees.
*	Roll left by angle degrees. Turns about the y-axis.
*(value)	Like the above, but with a specified number of degrees.
[	Begin branch (i.e. push turtle state on stack).
]	End branch (i.e. pop turtle state from stack). If there is no corresponding [, this has no effect. Aside from restoring position and direction, any changes to variables since the last [ will be undone.
!	Increment lineWidth by lineIncrement.
!(value)	Like the above, but increments by the specified amount.
~	Decrement lineWidth by lineIncrement, with a minimum lineWidth of zero attainable.
~(value)	Like the above, but decrements by the specified amount.
{	Begin the definition of a polygon. The turtle position when the { is processed will be the first point in the polygon, and the end point reached by each g directive until the close of the polygon will be added to the polygon.
}	Ends the definition of a polygon. The turtle position when the } is processed will not be added to the polygon. The polygon will be filled with the color polygonColor and will have no outline.
%	Turn by 180 degrees about the z-axis, the same axis as the + and - turns.
#	Increments the hue angle of color by hueChange. Changing the hue angle will have no effect if color has no saturation, i.e., if color is black, grey, or white.
#(value)	Like the above, but with a specified number of degrees.
@	Decrements the hue angle of color by hueChange.
@(value)	Like the above, but with a specified number of degrees.
##	Increments the hue angle of polygonColor by hueChange. Changing the hue angle will have no effect if polygonColor has no saturation, i.e., if polygonColor is black, grey, or white.
##(value)	Like the above, but with a specified number of degrees.
@@	Decrements the hue angle of polygonColor by hueChange.
@@(value)	Like the above, but with a specified number of degrees.
parameter=value	This will attempt to set a parameter named parameter to value. For example, the symbol angle=20 will cause all subsequent turns to be made with 20 degrees, color=red will cause all subsequent g directives to produce red lines, and soforth. The names of parameters and acceptable values is the same as for the mappings in the parameter table. There must be no whitespace in the parameter=value symbol, or else it shall not be processed as a single symbol.

Values

You may have noticed that in the list of symbols were a number of symbols that take an argument, for example, the turn right symbol + can appear in the form +(value) to turn a specified number of degrees, and you can also say lineIncrement=value to set the amount the line width changes when the renderer encounters the symbols like ! and ~.

Every value may be as simple as a number, but it may be a mathematical expression involving parameters as values. One could say distance=distance+2, which will increment subsequent line lengths by 2. Moreover, if in the parameters list one specified that foo was 100, then the symbol g(3+(8+foo)/2) would yield a line of length 57. All g symbols are functionally equivalent to g(distance).

The operators allowed in a value are + (addition), - (subtraction), * (multiplication), / (division), ^ (power), ( and ) (parentheses), and they obey the usual rules of order of operations and soforth. If an undefined symbol appears in a mathematical expression, then a value of 0 is assumed for that symbol.

For higher performance, avoid the frequent use of expressions. For example, if you're curious about the relative performance of +(5*angle) versus + + + + +, the + + + + + will tend to be faster, though your milage may vary for your particular JVM.

Interface

The L-system renderer interface has 5 distinct components of interest.

3D Hilbert rendering with annotations

While the system is busy rendering an L-system, the progress back will report the amount done to the user.
This field will display the current symbols being drawn up to a point; since most interesting L-systems are exponential in their growth, this will usually be omitted since longer strings of symbols are usually quite nonsensicle to the user.
This spinner allows the user to specify the depth of L-system substitution recursion. A level of 0 means that only the axiom will be rendered.
The major portion of the view is used to display the rendering of the L-system. If the rendering extends beyond the extent of the view, scrollbars will appear to allow the user to inspect all of the rendering.
Though of little use for 2D rendering, for L-systems that take advantage of 3D renderings the ability to look at the rendering from different angles is important. By twiddling these values the user can get a feel for the shape of the rendering.

Notes

The 3D "renderer," as it is, is nothing more than the standard Java 2D graphics where the z coordinate is ignored for drawing. Consequences of this are that all projections are orthogonal and that lines drawn over each other may not be in sensible depth order. Until either gl4java or (heaven forbid) Java3D becomes standard issue for the JVM on all reasonable platforms, this system shall persist.

DOCS/gui.lsystem.LSystemInputPane.html

The L-System Editor

L-system Input Pane

As always, this documention assumes some general familiarity with L-systems and only describes JFLAP's implementation of these structures. JFLAP allows a user to define an L-system and to render that system with an arbitrary level of substitution in three dimensions. The formal definition of an L-system requires three components, to which we add one to aid in drawing:

System alphabet

JFLAP does not require the user to explicityly set the alphabet (i.e. set of recognized symbols) of the system. If a symbol is does not have significance to whatever is attempting to interpret it is ignored, e.g. a renderer of an L-system would be interested in those symbols that affect the rendering and those symbols which have replacement rules.

While the rules of replacement, the presence of an axiom, and soforth are universal to L-systems, the interpretation of those symbols to render a graphic is not part of the mathematical definition. At present there is one L-system renderer in JFLAP, and its description, including the symbols it recognizes, may be found here.

Axiom

At the top of the editing view is a text field for typing in the axiom labeled, appropriately enough, "axiom." As mentioned before symbols are space delimited. In the example given above, the three symbols in the axiom are +, g, and L, in that order.

Rewriting Rules

Below the axiom is a series of productions that represent the replacement rules; one enters these just as one would enter productions for a grammar. As with the axiom, symbols must be space delimited. In most cases you will want only one symbol on the left. The two rewriting rules in the example picture are L L + R g + and R - g L - R, that is, going from one level of substitution to the subsequent level of substitution, every L shall be replaced with the five symbols L + R g +, and every R shall be replaced with the five symbols - g L - R.

You can also have multiple symbols on the left side of the rewriting rule. JFLAP offers rules that are sensitive to context. These rules take the form of i a0 a1 ... ai-1 ai ai+1 ... an-2 an-1. In this list of n+1 symbols, the i symbol is an integer from 0 inclusive to n exclusive; the symbol ai is the symbol potentially being rewritten, but only if the string of symbols a0 a1 ... ai-1 come before it and ai+1 ... an-2 an-1 come after it. For example, the rewriting rule 2 a b c d x y z, in an expansion c would be rewritten with x y z if preceeded by the two symbols a b and the symbol d.

If multiple replacement rules dictate that a symbol is to be rewritten, one of the rules will be chosen uniformly at random when the expansion of symbols occurs. Additionally, lambda productions are allowed and indicate simply that the symbol should be removed.

Drawing Parameters

Below the grammar input, and at the bottom of the window, there is a table the user may set parameters that affect the rendering of the L-system. The user enters the parameter name in the left column, and its value in the right column. In the example L-system input figure, we have the two parameters named angleIncrement and distance, with values 90 and 4 respectively. Mind you, these parameter names are case sensitive! If the same parameter is defined multiple times in the table, only the last definition of the parameter is respected.

Above the right scroll bar, just to the right of the "Parameter" column label, there is a small button. If you press it, you will see a popup menu with a list of those parameters the L-system renderer in JFLAP recognizes (one can't remember them all, can we?). For a full description of these parameters, view the pages for the L-system Renderer When you select a parameter name from this list, it will be entered into the table, and you will begin editing the value for that parameter. If you select a parameter that already exists in the table, then you will begin editing the parameter value for the existing entry.

In Haiku

The axiom field holds the starting point of the L-system.

The middle table displays the rewriting rules. You edit them here!

Rewriting rules look like a grammar production with left and right sides.

A rule's left side holds the symbol to replace in derivation strings.

The right side contains what symbols the left symbol will be replaced with.

The strings of symbols in JFLAP's L-systems are space delimited.

Strings without whitespace should therefore be considered a single symbol.

That is important! Don't mistake "gfgg" for "g f g g"!

The bottom table holds drawing parameters for the L-system.

Parameters set in this table change how the L-system renders.

The left column "Name" holds the parameter name. Right holds the value.

As an example, set "color" to the value "green" and "g" draws green lines!

Also, consider setting "distance" to "18". Lines are that length now.

You click in the box above the table's scroll bar for a list of names.

Choose one of these names, and that named parameter shows in the table.

Want to render this? You choose the menu item named "Render System"

DOCS/gui.minimize.MinimizePane.html

Minimize DFA

This operation converts a DFA to another DFA that is minimized (i.e., has the least number of states possible while still accepting the same language). The process involves building a tree of groups of states that ``split'' on terminals. Once there are no sets of states that cannot be split any further, states in the same set are deemed equivalent. The user then proceeds to build a minimized DFA using these groups.

Splitting Groups

Splitting Groups

In the view, there is a toolbar along the top. To the left there is the original DFA, with the addition of the trap state (if necessary). To the right there is the tree where the set of distinguishable groups is determined.

When the tool starts out, there are two major groups: non-final and final states. The current groups are those groups in the leaf nodes. The union of all current groups is the set of all states, and all current groups are state disjoint.

A group is split on a terminal if the states in the group have transitions on this terminal to different groups. If all the transitions are to the same group, then there is no split on this group based on this terminal. If a group splits, it may split two or more ways. A group may split two or more ways.

Take the example given in the screen shot above. We start with the groups {0,1,3,4} and {2}. Notice that group {0,1,3,4} splits on a because while states {0,4} go to states in {0,1,3,4}, states {1,3} go to states in the group {2}. So, this group splits on a into the two groups {0,4} and {1,3}. Then, we note that group {0,4} splits on the terminal a again, since q0 goes to q3 which is in group {1,3}, while q4 goes to itself, which is in the current group {0,4}. So, {0,4} splits on a into the two groups {0} and {4}. (We also had the option of splitting {0,4} on b.)

Hopefully the interface is as straightforward as the theory. The tool bar along the top of the interface applies actions to the currently selected group. A group is selected if it is darkened. To select a group, click its node in the tree.

Set Terminal

This begins the process of splitting a group on a terminal. In order to split a node on a terminal, the terminal to split must first be entered. Once the user selects a group she may press this button, and enter a terminal to split the group on. (If the terminal does not split the group, the user is informed.)

After this is done, the process for splitting a group is started. Since splitting a group implies that at least two new groups will be created, two empty nodes appear as children to this group's node. To add a state to a group, select one of these children, and click a state in the left display. (The states in the currently selected group appear as selected states in the left DFA display. To remove a state from a group, similarly, you click the state again.)

Auto Partition

This will automatically split a group on some terminal. If the terminal has not yet been set on this node, a terminal that splits this group is randomly chosen. If the terminal to split this node's group on has already been chosen through "Set Terminal", then that terminal is used.

Complete Subtree

This will split the current group, and all children groups of this group, and their groups, and their groups too, until in the subtree rooted at the currently selected has no groups that can be distinguished further.

Check Node

If one manually splits a group, to end the process of splitting a group, select the group you had split, and press "Check Node". This will check the expansion, and report mistakes. If there are no mistakes, the work shall be approved.

Add Child

While the "Set Terminal" operation will automatically add two children to a node, it is possible that a group splits into more than two groups. To add another subgroup to the group you're splitting, press this button while the group you're splitting is selected.

Remove

If the user discovers that a child added is unnecessary, she may select and remove it with this button.

Finish

If all the groups on the leaves cannot be distinguished further, this stops the process of building distinguishable groups, and moves to the operation of defining the final minimized DFA.

Building the Minimized DFA

Minimized DFA Building

Once the "Finish" operation confirms that the tree is fully built, the final DFA is built. The view will be replaced with an editor view, where the user builds the DFA. In the minimized DFA, each indistinguishable group of states from the original DFA is shown in the label. The group of states that include the trap state are not considered part of the minimized DFA: they are by definition unnecessary. Creating transitions is just as it is during regular FA building, with the exception that if the user adds a transition that is not part of the minimized DFA, she is notified and the transition is not added. The "Hint" button will add some transition that needs to be added. "Complete" will add all transitions that need to be added. "Done?" will check the minimized DFA to see if it is complete. If it is complete, it will be exported to another window.

DOCS/gui.regular.ConvertPane.html

Convert FA to RE

The idea behind the transformation is that an FA is repeatedly collapsed until there is a single initial and different single final state, with transitions between them. This reformed FA is called a generalized transition graph.

Steps

On screen directions walk the user through every step of the transformation.

In the process of each step, we will pretend to convert this automaton.

The FA is transformed so that there is a single final state that is not the initial state. First, the user creates a new final state. Then, the user inserts lambda transitions from the old final states to the new final state. This is accomplished with the regular state creator () and transition creator () tools. The transition creator knows that if we are on this step, we will only be interested in creating lambda transitions. If there is already only a single final state, this step is skipped. The example does not require this step.
If there are multiple transitions from and to any two given states, they are combined into a single transition. For example, if from state qi to qj there are two transitions a and b, they are combined into the regular expression transition a+b. The user does this with the "Transition Collapser" tool (). To collapse multiple transitions between states, click one of these transitions while the tool is active. If there is no pair of states with multiple transitions between them, this step is skipped.
Empty transitions are added between all pairs of states for which there is no transition; that is, if from qi to qj there is no transition, an empty transition is added from qi to qj. Note that empty transitions are not lambda transitions! To add empty transitions for this step, use the transition tool () as you normally do. Since this step assumes you will only be adding empty transitions, dragging out a transition will automatically create an empty transition. The example picture shows all the necessary empty transitions needed: note the empty set symbol. If there is no pair of states without a transition between them, this step is skipped.
At this point, all non-initial, non-final states are collapsed, one at a time. To collapse a state, select the "State Collapser" tool () tool, and click on the state you wish to collapse. In the example, the only state to collapse is q1
. When you click on a state with the collapser, a window pops up, as shown above, showing the new transitions for the automaton; as JFLAP will soon remove q1, certain transitions have to be reformed to ensure that the automaton accepts the same language. In the example window shown, from state q0 to q2, there will be a transition ((a+b)c*)(b+c). If in this window an expression is selected, in the editor, those transitions that were combined to form the expression will be highlighted. When this inspection has finished, press "Finalize" and all transitions will be
Once only the final and initial states remain, this generalized transition graph will yield a regular expression. One can use the "Export" button to put this expression into a regular expression environment.

As a final point, the "Do It" button will complete the current step.

DOCS/gui.regular.ConvertToAutomatonPane.html

Regular Expression to Automaton

When the converter starts up, all that appears initially are two states (one initial and one final) with a transition. The transition between them contains the regular expression that we are trying to convert.

The critical idea of the converter is that at each stage of the conversion one has a valid machine where some transitions may happen to be regular expressions. Each regular expression may be recursively broken into smaller parts. The conversion is finished when the only transitions have only single (or zero) alphabet symbols on them.

There are four types of reductions that can be done on a regular expression:

Transitions are first broken according to the or symbol (+). For example, the expression a+bc+d can be broken into three subexpressions a, bc and d. An example of such a breakup is shown above.
Transitions that cannot be broken across ors are then broken across concatenations. For example, a(b+d)c* would be broken into the three subexpressions a, (b+d), c* as shown above.
If the transition does not break across either concatenation or or, then it may be a Kleene star (*) term, of the form a* or (b+cd)* (shown above) or something in that vein. In this case, the user effects the removal of the Klein star.
Lastly, if a regular expression is of the form (...), then the parentheses are simply removed from the transition.

The user interacts with the system in this way:

In the first stage of the breakup, one uses the "de-expressionify" tool () to select a transition with a regular expression that can be broken down. If a particular transition cannot be broken down further, the user is gently chastised.
If this is a reduction that requires additional lambda transitions, the user may add them with the transition tool (). A small message in the upper portion of the window will report how many transitions remain to add. If the user makes an error in the process of adding the transitions, the user will immediately receive a message to that effect. When all required transitions are added, the reduction is considered complete.
Steps 1 and 2 are repeated until there are no more transitions that can be "de-expressionified."

At any time, the user may press "Do Step" to complete the current RE reduction; if no RE reduction is in progress, this will choose a transition that remains to be reduced, and reduce it. "Do All" will complete the building of the automaton.

When the automaton is fully built, as with similar conversion operations the user has the option of placing the NFA in its own window with the "Export" button.

DOCS/gui.regular.EditorPane.html

The Regular Expression Editor

The editor for a regular expression is essentially just a single text field. Operators in a regular expression are the Kleene star (*), the ``or'' operator (+), parentheses are also usable, and concatenation is accomplished by making symbols adjacent.

In Haiku

To make expressions for this program to work with, type them in the field.

Adjacent symbols imply concatenation. No symbol is used.

Many or nothing, Asterisk (*) is the Kleine star. What precedes repeats.

Additionally, if you want an "or" symbol the plus (+) should be used.

Screaming nothingness, exclamations (!) are special. They act as lambda.

Formatting errors will be reported to you when you choose actions.

DOCS/gui.sim.SimulatorPane.html

The Step Simulators

These operators, "Step with Closure", "Step by State", and "Step" involve simulating input on an automaton. The first two, by state and with closure, are available only for FAs and PDAs. The last, simply "step," is available only for Turing machines. There are three major parts to the view. The top view displays the automaton, the middle view displays configurations, and the bottom view is a control panel. A sample run is displayed in the above picture.

Configurations are a snapshot of execution on an automaton at a particular point in time. In the case of a FA, a configuration has as attributes what input remains to be read, and the current state. In a PDA a configuration also includes the current contents of the stack. A Turing machine configuration includes the current state, as well as the current contents and position of a tape. The two-tape Turing machine is similar, but naturally it displays two tapes instead of one. The "step" action in the control panel progresses existing configurations.

In the display of the automaton, JFLAP highlights states to indicate that there is a configuration currently on that state. Configurations are shown in the configuration view; a regular configuration is displayed normally, accept configurations are green, reject configurations are red, and freeze configurations are blue. One may select and deselect configurations by clicking on them. The bottom control panel allows the user to change the state of the machine.

For Turing class machines, the input serves as the initial contents of the tape(s). The initial tape position is assumed to be the position of the leftmost character of the input.

The Control Panel

Along the bottom of the step simulator views there is a control panel.

Step: This is the primary operation. This will take all of the configurations available (aside from those that are frozen), and, if it is possible to proceed on any transition from the state of that configuration, it will do so. For example, for a PDA, if a configuration has next symbol on input is a, and top of the stack has b, and transition which reads a and pops b from the current state in the transition, that configuration will proceed on that transition. If we are able to proceed on more than one transition from the current state of the configuration, then multiple configurations are generated (nondeterminism). On the other hand, if we are not able to expand this configuration at all, then it is rejected.
Reset: This will force the step back to its virgin state when the step simulator first appeared.
Freeze: For a selected configuration, this will freeze a configuration. A frozen configuration persists in its original form when "step" is pressed, and is not expanded. You cannot freeze a halting configuration (either accept or reject).
Thaw: This is the inverse operation for freeze, i.e., when pressed, any selected frozen configurations will become normal once again.
Trace: Configurations are generated from other configurations. When this button is pressed, for any selected configuration this will pop up a small window showing the series of configurations that led to this configuration.
Remove: Any selected configuration will be removed.

Step by Closure vs. Step by State

There are new stepping options available. The "Step by Closure" and "Step by State" are new in this version, and are available only for FAs and PDAs. Under "Step by Closure," when a configuration proceeds to a state $q_i$, configurations are created for all states reachable on lambda transitions from $q_i$ (hence the name, step by closure). This is the situation illustrated in the figure at the top of the page. The "Step by State" option works as it did in the old version of JFLAP, without taking the closure. Turing machines do not have lambda transitions, and so have the single "Step" option available as there is no opportunity to ever take the closure of a state.

DOCS/index.html

Help Index

Here is the help index.

See www.jflap.org for tutorials on the newer JFLAP items.

Editors

Editors are used to define structures, whether they be some variety of automata, a grammar, a L-system, or a regular expression. This specifies how to use those structures.

Operators

Operators are actions that can be taken by the user. Many are applied to structures once they are created. They are shown in the order that they appear in the menus.

File menu holds items related to creating, saving, and loading structures.
Input menu holds items related to a structure's ability to accept input.

Test contains items for determining characteristics of a structure, with no creation of new structures or modification of structures implied.

Convert contains items that will take a structure, and produce another structure of a possibly different type from the original that accepts or generates the same language as the original.

NFA to DFA
Minimize DFA
FA to Grammar / PDA to Grammar
FA to RE
CFG to PDA (LL) / CFG to PDA (LR) / Right Linear Grammar to FA
Transform Grammar (in order, Lambda Removal, Unit Removal, Useless Removal, Chomsky Converter)
RE to NFA
Combine Automata

Help contains a single item that will display help. The help subject will be what is currently being done in the active window (i.e., if the user is editing an automaton, help on automaton editing will be displayed).

DOCS/nfaEquality.html

Compare Equivalence

This compares two FSAs to see if they accept the same language. This operator is unusual in that it requires that two DFAs be active in JFLAP. When invoked in the environment of one FSA, the user may select another open FSA; the user will then be informed as to whether or not these two FSAs accept the same language.

To make this more clear, suppose there are three DFAs open, A, B, and C. Within As window, the user invokes "Compare Equivalence." A small dialog pops up asking whether to run the comparison on B or C. If the user chooses B (WLOG, naturally), the DFAs A and B are tested to see if they accept the same language.

As a point of interest, the algorithm works by first converting the FSAs to DFAs, then minimizing both. Since there is a bijection between the set of minimized FSAs and the set of languages accepted by FSAs, running a simple graph comparison algorithm is enough to determine if they are equivalent. This comparison is run, and the user is then told if the original machines were or were not equivalent.

DOCS/nohelp.html

There is no help for this subject. Sorry!

DOCS/tags

!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ !_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ !_TAG_PROGRAM_AUTHOR Darren Hiebert /[email protected]/ !_TAG_PROGRAM_NAME Exuberant Ctags // !_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ !_TAG_PROGRAM_VERSION 5.6 //

DOCS/entities/alpha.png

DOCS/entities/beta.png

DOCS/entities/empty.png

DOCS/entities/gamma.png

DOCS/entities/lambda.png

DOCS/entities/rarr.png

DOCS/entities/tags

DOCS/images/.xvpics/closure2.png

DOCS/images/.xvpics/lsys-input.png

DOCS/images/.xvpics/lsys-render-2d.png

DOCS/images/.xvpics/tags

DOCS/images/2dfa-group.png

DOCS/images/2dfa-terminal.png

DOCS/images/LLparse.png

DOCS/images/LLtable.png

DOCS/images/LRgoto.png

DOCS/images/LRparse.png

DOCS/images/LRtable.png

DOCS/images/automaton.png

DOCS/images/brute.png

DOCS/images/closure.png

DOCS/images/fastrun-result.png

DOCS/images/fsa2grammar.png

DOCS/images/grammar.png

DOCS/images/hilbert3d.png

DOCS/images/lambda.png

DOCS/images/ll2pda.png

DOCS/images/lr2pda.png

DOCS/images/lsys-input.png

DOCS/images/lsys-render-2d.png

DOCS/images/minimize-dfa.png

DOCS/images/minimize-dfa2.png

DOCS/images/multipleruns.png

DOCS/images/multipleruns2.png

DOCS/images/new_window.png

DOCS/images/nfa2dfa.png

DOCS/images/nondeterminism.png

DOCS/images/re2nfa_and.gif

DOCS/images/re2nfa_or.gif

DOCS/images/re2nfa_star.gif

DOCS/images/tags

DOCS/images/turing-transition-edit.png

DOCS/images/fsa2re/1.png

DOCS/images/fsa2re/2.png

DOCS/images/fsa2re/3.png

DOCS/images/fsa2re/4.png

DOCS/images/fsa2re/collapse-state.png

DOCS/images/fsa2re/tags

DOCS/images/transform/chomsky.png

DOCS/images/transform/lambda.png

DOCS/images/transform/tags

DOCS/images/transform/unit.png

ICON/.xvpics/arrow.gif

ICON/.xvpics/collapse.gif

ICON/.xvpics/de-expressionify.gif

ICON/.xvpics/delete.gif

ICON/.xvpics/expand_group.gif

ICON/.xvpics/state.gif

ICON/.xvpics/state_collapse.gif

ICON/.xvpics/state_expander.gif

ICON/.xvpics/tags

ICON/.xvpics/transition.gif

ICON/Thumbs.db

ICON/arrow.gif

ICON/blockTransition.gif

ICON/blocks.gif

ICON/collapse.gif

ICON/de-expressionify.gif

ICON/default.gif

ICON/delete.gif

ICON/deletecursor.gif

ICON/expand_group.gif

ICON/question.gif

"Please don't kill me! I have a wife confirutation, and two children configurations!" Have Mercy They're Next Aren't you not sure you don't want nothing to do with not having this configuration not remain? Unsure Not Unsure

ICON/quote.gif

ICON/redo.jpg

ICON/state.gif

ICON/state_collapse.gif

ICON/state_expander.gif

ICON/tags

ICON/transition.gif

ICON/undo.jpg

ICON/undo2.jpg

ICON/x.gif

ICON/web/Thumbs.db

ICON/web/left.gif

ICON/web/right.gif

ICON/web/start.gif

ICON/web/tags

MEDIA/.xvpics/about.png

MEDIA/.xvpics/tags

MEDIA/JFLAP7.1_about.png

MEDIA/Thumbs.db

MEDIA/about_2008.png

MEDIA/tags

automata/Configuration.class

package automata;
public abstract synchronized class Configuration implements Cloneable {
    private boolean focused;
    private State myCurrentState;
    private Configuration parent;
    public void Configuration(State, Configuration);
    public State getCurrentState();
    public void setCurrentState(State);
    public String toString();
    public Configuration getParent();
    public abstract boolean isAccept();
    public boolean equals(Object);
    public int hashCode();
    private int primitiveHashCode();
    public boolean getFocused();
    public void setFocused(boolean);
    public void reset();
}

automata/LambdaTransitionChecker.class

package automata;
public abstract synchronized class LambdaTransitionChecker {
    protected String LAMBDA;
    protected String STAY;
    public void LambdaTransitionChecker();
    public abstract boolean isLambdaTransition(Transition);
}

automata/Note$1.class

package automata;
synchronized class Note$1 implements java.awt.event.MouseMotionListener {
    void Note$1(Note);
    public void mouseDragged(java.awt.event.MouseEvent);
    public void mouseMoved(java.awt.event.MouseEvent);
}

automata/Note$2.class

package automata;
synchronized class Note$2 implements java.awt.event.MouseListener {
    void Note$2(Note);
    public void mouseClicked(java.awt.event.MouseEvent);
    public void mousePressed(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
}

automata/Note.class

package automata;
public synchronized class Note extends javax.swing.JTextArea {
    private static final long serialVersionUID = 1;
    private java.awt.Point myAutoPoint;
    public boolean moving;
    protected java.awt.Point initialPointState;
    protected java.awt.Point initialPointClick;
    protected gui.viewer.AutomatonPane myView;
    public java.awt.Point myViewPoint;
    public void Note(java.awt.Point, String);
    public void Note(String);
    public void Note(java.awt.Point);
    public void setView(gui.viewer.AutomatonPane);
    public void initializeForView(gui.viewer.AutomatonPane);
    public java.awt.Point getAutoPoint();
    public gui.viewer.AutomatonPane getView();
    public void setLocationManually(java.awt.Point);
    public void setLocation(java.awt.Point);
    public void setLocation(int, int);
    public void updateView();
    public int specialHash();
}

automata/IncompatibleTransitionException.class

package automata;
public synchronized class IncompatibleTransitionException extends RuntimeException {
    private static final long serialVersionUID = 1;
    public void IncompatibleTransitionException();
}

automata/AutomatonSimulator.class

package automata;
public abstract synchronized class AutomatonSimulator {
    protected Automaton myAutomaton;
    protected java.util.Set myConfigurations;
    public void AutomatonSimulator(Automaton);
    public abstract Configuration[] getInitialConfigurations(String);
    public abstract java.util.ArrayList stepConfiguration(Configuration);
    public abstract boolean isAccepted();
    public abstract boolean simulateInput(String);
    public Automaton getAutomaton();
}

automata/AutomatonChecker.class

package automata;
public synchronized class AutomatonChecker {
    public void AutomatonChecker();
    public boolean isNFA(Automaton);
}

automata/ClosureTaker.class

package automata;
public synchronized class ClosureTaker {
    private void ClosureTaker();
    public static State[] getClosure(State, Automaton);
}

automata/AlphabetRetriever.class

package automata;
public abstract synchronized class AlphabetRetriever {
    public void AlphabetRetriever();
    public abstract String[] getAlphabet(Automaton);
}

automata/State.class

package automata;
public synchronized class State implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private Note myNote;
    String internalName;
    private java.awt.Point point;
    int id;
    String name;
    private static final char SS = 8320;
    private Automaton automaton;
    private String label;
    private String[] labels;
    private boolean selected;
    public void State(int, java.awt.Point, Automaton);
    public java.awt.Point getPoint();
    public void setAutomaton(Automaton);
    public Automaton getAutomaton();
    public void setPoint(java.awt.Point);
    public int getID();
    protected void setID(int);
    public String toString();
    public void setName(String);
    public String getName();
    private String digitizer(int);
    private String digitizer(int, int);
    public void setLabel(String);
    public String getLabel();
    public String[] getLabels();
    public int specialHash();
    public void setNote(Note);
    public void setSelect(boolean);
    public boolean isSelected();
}

automata/LambdaCheckerFactory.class

package automata;
public synchronized class LambdaCheckerFactory {
    public void LambdaCheckerFactory();
    public static LambdaTransitionChecker getLambdaChecker(Automaton);
}

automata/Node.class

package automata;
public synchronized class Node {
    protected String myColor;
    protected State myState;
    protected static final String WHITE = white;
    protected static final String GREY = grey;
    protected static final String BLACK = black;
    public void Node();
    public void Node(State);
    public void Node(State, String);
    public State getState();
    public String getColor();
    public void colorWhite();
    public void colorGrey();
    public void colorBlack();
    public boolean isWhite();
    public boolean isGrey();
    public boolean isBlack();
    public String toString();
}

automata/Transition.class

package automata;
public abstract synchronized class Transition implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = 1;
    protected State from;
    protected State to;
    private java.awt.Point myControlPoint;
    public boolean isSelected;
    public void Transition(State, State);
    public abstract Transition copy(State, State);
    public Object clone();
    public State getFromState();
    public State getToState();
    public void setFromState(State);
    public void setToState(State);
    public Automaton getAutomaton();
    public String getDescription();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
    public int specialHash();
    public java.awt.Point getControl();
    public void setControl(java.awt.Point);
}

automata/SimulatorFactory.class

package automata;
public synchronized class SimulatorFactory {
    public void SimulatorFactory();
    public static AutomatonSimulator getSimulator(Automaton);
}

automata/NondeterminismDetector.class

package automata;
public abstract synchronized class NondeterminismDetector {
    public void NondeterminismDetector();
    public abstract boolean areNondeterministic(Transition, Transition);
    public State[] getNondeterministicStates(Automaton);
}

automata/NondeterminismDetectorFactory.class

package automata;
public synchronized class NondeterminismDetectorFactory {
    public void NondeterminismDetectorFactory();
    public static NondeterminismDetector getDetector(Automaton);
}

automata/Automaton$1.class

package automata;
synchronized class Automaton$1 implements java.util.Comparator {
    void Automaton$1(Automaton);
    public int compare(Object, Object);
    public boolean equals(Object);
}

automata/Automaton.class

package automata;
public synchronized class Automaton implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = 1;
    private String fileName;
    private gui.environment.EnvironmentFrame myEnvFrame;
    public java.util.Set states;
    private State[] cachedStates;
    private Transition[] cachedTransitions;
    private State[] cachedFinalStates;
    public java.util.Set finalStates;
    protected State initialState;
    protected java.util.Set transitions;
    private java.util.HashMap transitionFromStateMap;
    private java.util.HashMap transitionToStateMap;
    private java.util.HashMap transitionArrayFromStateMap;
    private java.util.HashMap transitionArrayToStateMap;
    private java.util.ArrayList myNotes;
    public java.awt.Color myColor;
    private transient java.util.HashSet transitionListeners;
    private transient java.util.HashSet stateListeners;
    private transient java.util.HashSet noteListeners;
    public void Automaton();
    public Object clone();
    public static void become(Automaton, Automaton);
    public Transition[] getTransitionsFromState(State);
    public Transition[] getTransitionsToState(State);
    public Transition[] getTransitionsFromStateToState(State, State);
    public Transition[] getTransitions();
    public void addTransition(Transition);
    public void replaceTransition(Transition, Transition);
    public void removeTransition(Transition);
    public static java.util.List makeListFromArray(Object[]);
    public State createState(java.awt.Point);
    public final State createStateWithId(java.awt.Point, int);
    public final void addState(State);
    public void removeState(State);
    public State setInitialState(State);
    public State getInitialState();
    public State[] getStates();
    public void selectStatesWithinBounds(java.awt.Rectangle);
    public java.util.ArrayList getNotes();
    public void addNote(Note);
    public void deleteNote(Note);
    public void addFinalState(State);
    public void removeFinalState(State);
    public State[] getFinalStates();
    public boolean isFinalState(State);
    public boolean isInitialState(State);
    public State getStateWithID(int);
    public boolean isState(State);
    protected Class getTransitionClass();
    public String toString();
    public void addStateListener(event.AutomataStateListener);
    public void addTransitionListener(event.AutomataTransitionListener);
    public void addNoteListener(event.AutomataNoteListener);
    void distributeStateEvent(event.AutomataStateEvent);
    public void removeStateListener(event.AutomataStateListener);
    public void removeTransitionListener(event.AutomataTransitionListener);
    public void removeNoteListener(event.AutomataNoteListener);
    void distributeTransitionEvent(event.AutomataTransitionEvent);
    void distributeNoteEvent(event.AutomataNoteEvent);
    private void readObject(java.io.ObjectInputStream) throws java.io.IOException, ClassNotFoundException;
    private void writeObject(java.io.ObjectOutputStream) throws java.io.IOException;
    public gui.environment.EnvironmentFrame getEnvironmentFrame();
    public void setEnvironmentFrame(gui.environment.EnvironmentFrame);
    public void setFilePath(String);
    public String getFileName();
    public String getFilePath();
    public int hashCode();
    public void clear();
}

automata/StatePlacer.class

package automata;
public synchronized class StatePlacer {
    protected static final int X_MAX = 600;
    protected static final int Y_MAX = 600;
    public void StatePlacer();
    public java.awt.Point getPointForState(Automaton);
}

automata/StringChecker.class

package automata;
public synchronized class StringChecker {
    private void StringChecker();
    public static boolean isAlphanumeric(String);
}

automata/UselessStatesDetector.class

package automata;
public synchronized class UselessStatesDetector {
    private void UselessStatesDetector();
    public static Automaton cleanAutomaton(Automaton);
    public static java.util.Set getUselessStates(Automaton);
    private static java.util.Set findFinal(Automaton);
    private static java.util.Set findInitial(Automaton);
}

automata/StateRenamer.class

package automata;
public synchronized class StateRenamer {
    public void StateRenamer();
    public static void rename(Automaton);
}

automata/UnreachableStatesDetector.class

package automata;
public synchronized class UnreachableStatesDetector {
    protected Automaton myAutomaton;
    protected Node[] myNodes;
    public void UnreachableStatesDetector(Automaton);
    public void initializeNodes(State[]);
    public State[] getUnreachableStates();
    public Node getNodeForState(State);
    public void visit(Node);
}

automata/event/AutomataStateListener.class

package automata.event;
public abstract interface AutomataStateListener extends java.util.EventListener {
    public abstract void automataStateChange(AutomataStateEvent);
}

automata/event/AutomataNoteListener.class

package automata.event;
public abstract interface AutomataNoteListener extends java.util.EventListener {
    public abstract void automataNoteChange(AutomataNoteEvent);
}

automata/event/AutomataTransitionListener.class

package automata.event;
public abstract interface AutomataTransitionListener extends java.util.EventListener {
    public abstract void automataTransitionChange(AutomataTransitionEvent);
}

automata/event/AutomataNoteEvent.class

package automata.event;
public synchronized class AutomataNoteEvent extends java.util.EventObject {
    private static final long serialVersionUID = 1;
    private boolean myAdd;
    private automata.Note myNote;
    private boolean myChange;
    public void AutomataNoteEvent(automata.Automaton, automata.Note, boolean, boolean);
    public automata.Automaton getAutomaton();
    public automata.Note getNote();
    public boolean isAdd();
    public boolean isDelete();
    public boolean isChange();
}

automata/event/AutomataStateEvent.class

package automata.event;
public synchronized class AutomataStateEvent extends java.util.EventObject {
    private static final long serialVersionUID = 1;
    private boolean myAdd;
    private boolean myMove;
    public boolean myLabel;
    private automata.State myState;
    public void AutomataStateEvent(automata.Automaton, automata.State, boolean, boolean, boolean);
    public automata.Automaton getAutomaton();
    public automata.State getState();
    public boolean isAdd();
    public boolean isMove();
    public boolean isLabel();
    public boolean isDelete();
}

automata/event/AutomataTransitionEvent.class

package automata.event;
public synchronized class AutomataTransitionEvent extends java.util.EventObject {
    private static final long serialVersionUID = 1;
    private boolean myAdd;
    private automata.Transition myTransition;
    private boolean myChange;
    public void AutomataTransitionEvent(automata.Automaton, automata.Transition, boolean, boolean);
    public automata.Automaton getAutomaton();
    public automata.Transition getTransition();
    public boolean isAdd();
    public boolean isDelete();
    public boolean isChange();
}

automata/fsa/FiniteStateAutomaton.class

package automata.fsa;
public synchronized class FiniteStateAutomaton extends automata.Automaton {
    private static final long serialVersionUID = 1;
    public void FiniteStateAutomaton();
    protected Class getTransitionClass();
}

automata/fsa/NFAToDFA$1.class

package automata.fsa;
synchronized class NFAToDFA$1 implements java.util.Comparator {
    void NFAToDFA$1(NFAToDFA);
    public int compare(automata.State, automata.State);
}

automata/fsa/NFAToDFA$2.class

package automata.fsa;
synchronized class NFAToDFA$2 implements java.util.Comparator {
    void NFAToDFA$2(NFAToDFA);
    public int compare(automata.State, automata.State);
}

automata/fsa/NFAToDFA.class

package automata.fsa;
public synchronized class NFAToDFA {
    public void NFAToDFA();
    public automata.State createInitialState(automata.Automaton, automata.Automaton);
    public boolean hasFinalState(automata.State[], automata.Automaton);
    public automata.State[] getStatesForState(automata.State, automata.Automaton);
    public String getStringForStates(automata.State[]);
    public automata.State[] getStatesOnTerminal(String, automata.State[], automata.Automaton);
    private boolean containsState(automata.State, automata.State[]);
    public boolean containSameStates(automata.State[], automata.State[]);
    public automata.State getStateForStates(automata.State[], automata.Automaton, automata.Automaton);
    public java.util.ArrayList expandState(automata.State, automata.Automaton, automata.Automaton);
    public automata.State createStateWithStates(automata.Automaton, automata.State[], automata.Automaton);
    public FiniteStateAutomaton convertToDFA(automata.Automaton);
}

automata/fsa/MinimizeTreeNode.class

package automata.fsa;
public synchronized class MinimizeTreeNode extends javax.swing.tree.DefaultMutableTreeNode {
    private static final long serialVersionUID = 1;
    protected String myTerminal;
    public void MinimizeTreeNode(Object);
    public void MinimizeTreeNode(Object, String);
    public void setTerminal(String);
    public String getTerminal();
    public automata.State[] getStates();
}

automata/fsa/FSAConfiguration.class

package automata.fsa;
public synchronized class FSAConfiguration extends automata.Configuration {
    private String myInput;
    private String myUnprocessedInput;
    public void FSAConfiguration(automata.State, FSAConfiguration, String, String);
    public String getInput();
    public String getUnprocessedInput();
    public void setUnprocessedInput(String);
    public String toString();
    public boolean isAccept();
    public boolean equals(Object);
    public int hashCode();
}

automata/fsa/Minimizer.class

package automata.fsa;
public synchronized class Minimizer {
    protected java.util.HashMap MAP;
    protected automata.State TRAP_STATE;
    public void Minimizer();
    public void initializeMinimizer();
    public String getString(automata.State[]);
    public String getTerminalToSplit(automata.State[], automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public boolean isSplittableOnTerminal(automata.State[], String, automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public boolean isSplittable(automata.State[], automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public automata.State[] getDistinguishableGroup(automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public automata.State[] getGroupForState(automata.State, javax.swing.tree.DefaultTreeModel);
    public boolean stateGoesToGroupOnTerminal(automata.State, automata.State[], String, automata.Automaton);
    public java.util.ArrayList getGroupsFromGroupOnTerminal(automata.State[], String, automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public MinimizeTreeNode getTreeNodeForObject(javax.swing.tree.DefaultTreeModel, MinimizeTreeNode, automata.State[]);
    public java.util.ArrayList splitOnTerminal(automata.State[], String, automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public boolean isMinimized(automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public java.util.ArrayList split(automata.State[], automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public boolean isTransitionOnTerminal(automata.Transition[], String);
    public boolean needsTrapState(automata.Automaton);
    public void addTrapState(automata.Automaton);
    public automata.Automaton getMinimizeableAutomaton(automata.Automaton);
    public void printNode(MinimizeTreeNode);
    public void printTree(javax.swing.tree.DefaultTreeModel, MinimizeTreeNode);
    public javax.swing.tree.DefaultTreeModel getInitializedTree(automata.Automaton);
    public void addChildrenToParent(java.util.ArrayList, MinimizeTreeNode, javax.swing.tree.DefaultTreeModel);
    public javax.swing.tree.DefaultTreeModel getDistinguishableGroupsTree(automata.Automaton);
    public boolean hasFinalState(automata.State[], automata.Automaton);
    public boolean hasInitialState(automata.State[], automata.Automaton);
    public void mapStateToGroup(automata.State, automata.State[]);
    public automata.State[] getGroupMappedToState(automata.State);
    public void createStatesForMinimumDfa(automata.Automaton, automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public automata.State getStateMappedToGroup(automata.State[], automata.Automaton);
    public java.util.ArrayList getTransitionsForState(automata.State, automata.Automaton, automata.Automaton, javax.swing.tree.DefaultTreeModel);
    public java.util.ArrayList getLeaves(javax.swing.tree.DefaultTreeModel, MinimizeTreeNode);
    public boolean containsTrapState(automata.State[]);
    public FiniteStateAutomaton getMinimumDfa(automata.Automaton, javax.swing.tree.DefaultTreeModel);
}

automata/fsa/FSAStepByStateSimulator.class

package automata.fsa;
public synchronized class FSAStepByStateSimulator extends automata.AutomatonSimulator {
    public void FSAStepByStateSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
    public boolean isAccepted();
    public boolean simulateInput(String);
}

automata/fsa/FSANondeterminismDetector.class

package automata.fsa;
public synchronized class FSANondeterminismDetector extends automata.NondeterminismDetector {
    public void FSANondeterminismDetector();
    public boolean areNondeterministic(automata.Transition, automata.Transition);
}

automata/fsa/FSALabelHandler.class

package automata.fsa;
public synchronized class FSALabelHandler {
    private void FSALabelHandler();
    public static boolean hasMultipleCharacterLabels(automata.Automaton);
    public static void handleLabel(automata.Transition, automata.Automaton);
    public static void splitLabel(automata.Transition, automata.Automaton);
    public static FiniteStateAutomaton removeMultipleCharacterLabels(automata.Automaton);
    public static void removeMultipleCharacterLabelsFromAutomaton(automata.Automaton);
}

automata/fsa/FSATransition.class

package automata.fsa;
public synchronized class FSATransition extends automata.Transition {
    private static final long serialVersionUID = 1;
    protected String myLabel;
    public void FSATransition(automata.State, automata.State, String);
    public automata.Transition copy(automata.State, automata.State);
    public String getLabel();
    protected void setLabel(String);
    public String getDescription();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
}

automata/fsa/FSAToRegularExpressionConverter.class

package automata.fsa;
public synchronized class FSAToRegularExpressionConverter {
    public static final String EMPTY = ø;
    public static final String LAMBDA_DISPLAY;
    public static final String LAMBDA = ;
    public static final String KLEENE_STAR = *;
    public static final String OR = +;
    public static final String RIGHT_PAREN = );
    public static final String LEFT_PAREN = (;
    static void <clinit>();
    private void FSAToRegularExpressionConverter();
    public static boolean isConvertable(automata.Automaton);
    public static boolean areRemovableStates(automata.Automaton);
    public static boolean isRemovable(automata.State, automata.Automaton);
    public static automata.Transition getTransitionForExpression(int, int, String, automata.Automaton);
    public static String getExpressionBetweenStates(automata.State, automata.State, automata.Automaton);
    public static String getExpression(int, int, int, automata.Automaton);
    public static String concatenate(String, String);
    public static String star(String);
    public static String or(String, String);
    public static void removeState(automata.State, automata.Transition[], automata.Automaton);
    public static automata.Transition[] getTransitionsForRemoveState(automata.State, automata.Automaton);
    public static FSATransition addTransitionOnEmptySet(automata.State, automata.State, automata.Automaton);
    public static FSATransition combineToSingleTransition(automata.State, automata.State, automata.Transition[], automata.Automaton);
    public static void getSingleFinalState(automata.Automaton);
    public static void convertToSimpleAutomaton(automata.Automaton);
    public static void convertToGTG(automata.Automaton);
    public static boolean isSingleCharacter(String);
    public static boolean needsParens(String);
    public static String addParen(String);
    public static String getExp(String);
    public static String getFinalExpression(String, String, String, String);
    public static String getII(automata.Automaton);
    public static String getIJ(automata.Automaton);
    public static String getJJ(automata.Automaton);
    public static String getJI(automata.Automaton);
    public static String getExpressionFromGTG(automata.Automaton);
    public static String convertToRegularExpression(automata.Automaton);
}

automata/fsa/FSALambdaTransitionChecker.class

package automata.fsa;
public synchronized class FSALambdaTransitionChecker extends automata.LambdaTransitionChecker {
    public void FSALambdaTransitionChecker();
    public boolean isLambdaTransition(automata.Transition);
}

automata/fsa/FSAToRegularGrammarConverter$1.class

package automata.fsa;
synchronized class FSAToRegularGrammarConverter$1 implements java.util.Comparator {
    void FSAToRegularGrammarConverter$1(FSAToRegularGrammarConverter);
    public int compare(Object, Object);
    public boolean equals(Object);
}

automata/fsa/FSAToRegularGrammarConverter.class

package automata.fsa;
public synchronized class FSAToRegularGrammarConverter {
    protected java.util.HashMap MAP;
    protected static final String START_VARIABLE = S;
    protected static final String LAMBDA = ;
    protected java.util.LinkedList VARIABLE;
    public void FSAToRegularGrammarConverter();
    public void initializeConverter(automata.Automaton);
    public grammar.Production getProductionForTransition(automata.Transition);
    public grammar.Production getLambdaProductionForFinalState(automata.Automaton, automata.State);
    public grammar.reg.RegularGrammar convertToRegularGrammar(automata.Automaton);
    public String variableForState(automata.State);
}

automata/fsa/FSAAlphabetRetriever.class

package automata.fsa;
public synchronized class FSAAlphabetRetriever extends automata.AlphabetRetriever {
    public void FSAAlphabetRetriever();
    public String[] getAlphabet(automata.Automaton);
}

automata/fsa/FSAStepWithClosureSimulator.class

package automata.fsa;
public synchronized class FSAStepWithClosureSimulator extends FSAStepByStateSimulator {
    public void FSAStepWithClosureSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
}

automata/graph/LayoutAlgorithmFactory.class

package automata.graph;
public synchronized class LayoutAlgorithmFactory {
    private static final int NUM_ALGORITHMS = 7;
    public static final int RANDOM_CHOICE = -1;
    public static final int CIRCLE = 0;
    public static final int GEM = 1;
    public static final int RANDOM = 2;
    public static final int SPIRAL = 3;
    public static final int TREE_HIERARCHY = 4;
    public static final int TREE_DEGREE = 5;
    public static final int TWO_CIRCLE = 6;
    public void LayoutAlgorithmFactory();
    public static LayoutAlgorithm getRandomLayoutAlgorithm();
    public static LayoutAlgorithm getRandomLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public static LayoutAlgorithm getLayoutAlgorithm(int);
    public static LayoutAlgorithm getLayoutAlgorithm(int, java.awt.Dimension, java.awt.Dimension, double);
    public static AutomatonGraph getAutomatonGraph(int, automata.Automaton);
}

automata/graph/FSAEqualityChecker.class

package automata.graph;
public synchronized class FSAEqualityChecker {
    private static DFAEqualityChecker checker;
    private static automata.fsa.NFAToDFA nfaConverter;
    private static automata.fsa.Minimizer minimizer;
    static void <clinit>();
    public void FSAEqualityChecker();
    public boolean equals(automata.fsa.FiniteStateAutomaton, automata.fsa.FiniteStateAutomaton);
}

automata/graph/AutomatonGraph.class

package automata.graph;
public synchronized class AutomatonGraph extends Graph {
    public void AutomatonGraph(automata.Automaton);
    public void moveAutomatonStates();
}

automata/graph/DFAEqualityChecker.class

package automata.graph;
public synchronized class DFAEqualityChecker {
    public void DFAEqualityChecker();
    private boolean hypothesize(automata.State, automata.State, java.util.Map);
    public boolean equals(automata.fsa.FiniteStateAutomaton, automata.fsa.FiniteStateAutomaton);
}

automata/graph/LayoutAlgorithm.class

package automata.graph;
public abstract synchronized class LayoutAlgorithm {
    protected java.awt.Dimension size;
    protected java.awt.Dimension vertexDim;
    protected double vertexBuffer;
    public void LayoutAlgorithm();
    public void LayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public abstract void layout(Graph, java.util.Set);
    public static void shiftOntoScreen(Graph, java.awt.Dimension, java.awt.Dimension, boolean);
    public static java.util.ArrayList getMovableVertices(Graph, java.util.Set);
    public static void cartesianToPolar(Graph, java.util.ArrayList);
    public static void polarToCartesian(Graph, java.util.ArrayList);
}

automata/graph/DisjointSetsDetector.class

package automata.graph;
public synchronized class DisjointSetsDetector {
    protected java.util.ArrayList STATES_IN_A_SET;
    public void DisjointSetsDetector();
    private void accountForStates(java.util.HashSet);
    private boolean areDirectlyConnected(automata.State, automata.State, automata.Automaton);
    private java.util.ArrayList getStatesConnectedToState(automata.State, automata.Automaton);
    private void addAllNotInSetToList(java.util.ArrayList, java.util.HashSet, java.util.ArrayList);
    public java.util.HashSet getSetIncludingState(automata.State, automata.Automaton);
    private boolean isAccountedFor(automata.State);
    private boolean accountedForAllStates(automata.Automaton);
    public automata.State getUnaccountedForState(automata.Automaton);
    public java.util.HashSet[] getDisjointSets(automata.Automaton);
}

automata/graph/AutomatonDirectedGraph.class

package automata.graph;
public synchronized class AutomatonDirectedGraph extends AutomatonGraph {
    public void AutomatonDirectedGraph(automata.Automaton);
    public void addEdge(Object, Object);
    public void removeEdge(Object, Object);
    public int fromDegree(Object, boolean);
    public int toDegree(Object, boolean);
}

automata/graph/Graph.class

package automata.graph;
public synchronized class Graph {
    protected java.util.Map verticesToPoints;
    protected java.util.Map verticesToNeighbors;
    public void Graph();
    public void clear();
    public int degree(Object);
    public int numberOfVertices();
    public java.util.Set adjacent(Object);
    public void addEdge(Object, Object);
    public void removeEdge(Object, Object);
    public boolean hasEdge(Object, Object);
    public void addVertex(Object, java.awt.geom.Point2D);
    public void removeVertex(Object);
    public void moveVertex(Object, java.awt.geom.Point2D);
    public java.awt.geom.Point2D pointForVertex(Object);
    public Object[] vertices();
    public java.awt.geom.Point2D[] points();
    public void moveWithinFrame(java.awt.geom.Rectangle2D);
    public String toString();
}

automata/graph/layout/RandomLayoutAlgorithm$1.class

package automata.graph.layout;
synchronized class RandomLayoutAlgorithm$1 implements java.util.Comparator {
    void RandomLayoutAlgorithm$1(RandomLayoutAlgorithm);
    public int compare(Object, Object);
}

automata/graph/layout/RandomLayoutAlgorithm$2.class

package automata.graph.layout;
synchronized class RandomLayoutAlgorithm$2 implements java.util.Comparator {
    void RandomLayoutAlgorithm$2(RandomLayoutAlgorithm);
    public int compare(Object, Object);
}

automata/graph/layout/RandomLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class RandomLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    private java.util.ArrayList vertices;
    private java.util.ArrayList points;
    private VertexChain chain;
    public void RandomLayoutAlgorithm();
    public void RandomLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public void layout(automata.graph.Graph, java.util.Set);
    private void assignPointsAndVertices();
    private void lessenVertexOverlap();
    private void findCorrectPointOrder();
}

automata/graph/layout/TwoCircleLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class TwoCircleLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    public automata.graph.Graph graph;
    java.util.ArrayList vertices;
    java.util.ArrayList innerCircle;
    java.util.ArrayList outerCircle;
    CircleChain[] outerCircleChains;
    CircleChain innerCircleChain;
    public void TwoCircleLayoutAlgorithm();
    public void TwoCircleLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public void layout(automata.graph.Graph, java.util.Set);
    protected void assignToCircles();
    protected void createOuterCircleChains();
    protected void shuffleOuterChains();
    public static void main(String[]);
}

automata/graph/layout/CircleChain.class

package automata.graph.layout;
public synchronized class CircleChain extends VertexChain {
    protected double radius;
    protected java.awt.Dimension vertexDim;
    protected double vertexBuffer;
    public void CircleChain(automata.graph.Graph, java.awt.Dimension, double);
    public double getRadius();
    public void layoutInCircle();
    public void layout(double, double, double);
}

automata/graph/layout/GEMLayoutAlgorithm$Record.class

package automata.graph.layout;
public synchronized class GEMLayoutAlgorithm$Record {
    java.awt.geom.Point2D point;
    double[] lastImpulse;
    double temperature;
    double skew;
    public void GEMLayoutAlgorithm$Record();
}

automata/graph/layout/GEMLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class GEMLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    private static final java.util.Random RANDOM;
    private java.util.Map records;
    private static final java.util.Set EMPTY_SET;
    private static final double Tmax = 256.0;
    private static final double Tmin = 3.0;
    private static final double OPTIMAL_EDGE_LENGTH = 100.0;
    private static final double GRAVITATIONAL_CONSTANT = 0.0625;
    static void <clinit>();
    public void GEMLayoutAlgorithm();
    public void GEMLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public void layout(automata.graph.Graph, java.util.Set);
}

automata/graph/layout/VertexMover.class

package automata.graph.layout;
public synchronized class VertexMover extends automata.graph.LayoutAlgorithm {
    public static final int HORIZONTAL_CENTER = -10;
    public static final int VERTICAL_CENTER = -11;
    public static final int POSITIVE_SLOPE_DIAGONAL = -12;
    public static final int NEGATIVE_SLOPE_DIAGONAL = -13;
    public static final int ROTATE = -14;
    public static final int FILL = -15;
    private int command;
    public void VertexMover(int);
    public void VertexMover(java.awt.Dimension, java.awt.Dimension, double, int);
    public void layout(automata.graph.Graph, java.util.Set);
}

automata/graph/layout/TreeLayoutAlgorithm$1.class

package automata.graph.layout;
synchronized class TreeLayoutAlgorithm$1 implements java.util.Comparator {
    void TreeLayoutAlgorithm$1(TreeLayoutAlgorithm, automata.graph.AutomatonDirectedGraph);
    public int compare(Object, Object);
}

automata/graph/layout/TreeLayoutAlgorithm$2.class

package automata.graph.layout;
synchronized class TreeLayoutAlgorithm$2 implements java.util.Comparator {
    void TreeLayoutAlgorithm$2(TreeLayoutAlgorithm);
    public int compare(Object, Object);
}

automata/graph/layout/TreeLayoutAlgorithm$Level.class

package automata.graph.layout;
synchronized class TreeLayoutAlgorithm$Level {
    public java.util.ArrayList vertices;
    public TreeLayoutAlgorithm$Level nextLevel;
    public void TreeLayoutAlgorithm$Level(TreeLayoutAlgorithm);
    public void processChildren(java.util.ArrayList);
    public void layout(double);
}

automata/graph/layout/TreeLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class TreeLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    protected automata.graph.Graph graph;
    protected boolean hierarchical;
    public void TreeLayoutAlgorithm(boolean);
    public void TreeLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double, boolean);
    public void layout(automata.graph.Graph, java.util.Set);
}

automata/graph/layout/CircleLayoutAlgorithm$Box.class

package automata.graph.layout;
public synchronized class CircleLayoutAlgorithm$Box extends CircleChain {
    public java.awt.Dimension size;
    public CircleLayoutAlgorithm$Box down;
    public CircleLayoutAlgorithm$Box right;
    public java.awt.geom.Point2D upperLeft;
    public void CircleLayoutAlgorithm$Box(CircleLayoutAlgorithm, automata.graph.Graph, java.awt.Dimension, double);
    public void merge(CircleLayoutAlgorithm$Box);
    public void setUpperLeft(CircleLayoutAlgorithm$Box);
    public void layoutInCircleAndPack();
}

automata/graph/layout/CircleLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class CircleLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    private java.util.ArrayList boxes;
    public void CircleLayoutAlgorithm();
    public void CircleLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public void layout(automata.graph.Graph, java.util.Set);
    private boolean addToExistingBox(Object);
    private void mergeIfPossible(CircleLayoutAlgorithm$Box, int);
}

automata/graph/layout/SpiralLayoutAlgorithm$1.class

package automata.graph.layout;
synchronized class SpiralLayoutAlgorithm$1 implements java.util.Comparator {
    void SpiralLayoutAlgorithm$1(SpiralLayoutAlgorithm);
    public int compare(Object, Object);
}

automata/graph/layout/SpiralLayoutAlgorithm.class

package automata.graph.layout;
public synchronized class SpiralLayoutAlgorithm extends automata.graph.LayoutAlgorithm {
    private automata.graph.Graph graph;
    public void SpiralLayoutAlgorithm();
    public void SpiralLayoutAlgorithm(java.awt.Dimension, java.awt.Dimension, double);
    public void layout(automata.graph.Graph, java.util.Set);
}

automata/graph/layout/VertexChain.class

package automata.graph.layout;
public synchronized class VertexChain {
    java.util.ArrayList vertices;
    automata.graph.Graph graph;
    public void VertexChain(automata.graph.Graph);
    public Object get(int);
    public java.util.ArrayList getVertices();
    public int size();
    public boolean isEdgeToChainMember(Object);
    public int getDegreeInChain(Object);
    public void orientSubChain(int, int, int, int, boolean);
    public void addVertex(Object);
    public static void alignTwoChains(VertexChain, VertexChain, automata.graph.Graph);
}

automata/mealy/MooreStepByStateSimulator.class

package automata.mealy;
public synchronized class MooreStepByStateSimulator extends MealyStepByStateSimulator {
    public void MooreStepByStateSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
}

automata/mealy/MealyNondeterminismDetector.class

package automata.mealy;
public synchronized class MealyNondeterminismDetector extends automata.NondeterminismDetector {
    public void MealyNondeterminismDetector();
    public boolean areNondeterministic(automata.Transition, automata.Transition);
}

automata/mealy/MooreTransition.class

package automata.mealy;
public synchronized class MooreTransition extends MealyTransition {
    private static final long serialVersionUID = 1;
    public void MooreTransition(automata.State, automata.State, String, String);
    public void MooreTransition(automata.State, automata.State, String);
    public automata.Transition copy(automata.State, automata.State);
    public String getOutput();
    protected void setOutput(String);
    public String getDescription();
}

automata/mealy/MealyLambdaTransitionChecker.class

package automata.mealy;
public synchronized class MealyLambdaTransitionChecker extends automata.LambdaTransitionChecker {
    public void MealyLambdaTransitionChecker();
    public boolean isLambdaTransition(automata.Transition);
}

automata/mealy/MealyStepByStateSimulator.class

package automata.mealy;
public synchronized class MealyStepByStateSimulator extends automata.AutomatonSimulator {
    public void MealyStepByStateSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
    public boolean isAccepted();
    public boolean simulateInput(String);
}

automata/mealy/MealyTransition.class

package automata.mealy;
public synchronized class MealyTransition extends automata.Transition {
    private static final long serialVersionUID = 1;
    protected String myLabel;
    protected String myOutput;
    public void MealyTransition(automata.State, automata.State, String, String);
    public automata.Transition copy(automata.State, automata.State);
    protected void setLabel(String);
    protected void setOutput(String);
    public String getLabel();
    public String getOutput();
    public String getDescription();
    public String toString();
    public boolean equals(Object);
    public int hashCode();
}

automata/mealy/MooreMachine.class

package automata.mealy;
public synchronized class MooreMachine extends MealyMachine {
    private static final long serialVersionUID = 1;
    private java.util.Map myMap;
    public void MooreMachine();
    protected Class getTransitionClass();
    public void setOutput(automata.State, String);
    public String getOutput(automata.State);
    public String getStateDescription(automata.State);
}

automata/mealy/MealyConfiguration.class

package automata.mealy;
public synchronized class MealyConfiguration extends automata.Configuration {
    private String myInput;
    private String myUnprocessedInput;
    private String myOutput;
    public void MealyConfiguration(automata.State, MealyConfiguration, String, String, String);
    public String getInput();
    public String getUnprocessedInput();
    public String getOutput();
    public void setUnprocessedInput(String);
    public String toString();
    public boolean isAccept();
    public boolean equals(Object);
    public int hashCode();
}

automata/mealy/MealyMachine.class

package automata.mealy;
public synchronized class MealyMachine extends automata.Automaton {
    private static final long serialVersionUID = 1;
    public void MealyMachine();
    protected Class getTransitionClass();
}

automata/pda/PushdownAutomaton.class

package automata.pda;
public synchronized class PushdownAutomaton extends automata.Automaton {
    private static final long serialVersionUID = 1;
    public boolean singleInputPDA;
    public void PushdownAutomaton(boolean);
    public void PushdownAutomaton();
    protected Class getTransitionClass();
}

automata/pda/PDALambdaTransitionChecker.class

package automata.pda;
public synchronized class PDALambdaTransitionChecker extends automata.LambdaTransitionChecker {
    public void PDALambdaTransitionChecker();
    public boolean isLambdaTransition(automata.Transition);
}

automata/pda/PDAStepWithClosureSimulator.class

package automata.pda;
public synchronized class PDAStepWithClosureSimulator extends PDAStepByStateSimulator {
    public void PDAStepWithClosureSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
}

automata/pda/PDANondeterminismDetector.class

package automata.pda;
public synchronized class PDANondeterminismDetector extends automata.NondeterminismDetector {
    public void PDANondeterminismDetector();
    public boolean arePrefixesOfEachOther(String, String);
    public boolean areNondeterministic(automata.Transition, automata.Transition);
}

automata/pda/CharacterStack.class

package automata.pda;
public synchronized class CharacterStack implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private StringBuffer buffer;
    private int cachedHash;
    public void CharacterStack();
    public void CharacterStack(CharacterStack);
    public void push(char);
    public void push(String);
    public void clear();
    public int height();
    public char pop();
    public String pop(int);
    public String toString();
    public boolean equals(Object);
    public int hashCode();
}

automata/pda/PDATransition.class

package automata.pda;
public synchronized class PDATransition extends automata.Transition {
    private static final long serialVersionUID = 1;
    protected String myInputToRead;
    protected String myStringToPop;
    protected String myStringToPush;
    public void PDATransition(automata.State, automata.State, String, String, String);
    public automata.Transition copy(automata.State, automata.State);
    public String getInputToRead();
    protected void setInputToRead(String);
    public String getStringToPop();
    protected void setStringToPop(String);
    public String getStringToPush();
    protected void setStringToPush(String);
    public String getDescription();
    public int hashCode();
    public boolean equals(Object);
    public String toString();
}

automata/pda/PDAStepByStateSimulator.class

package automata.pda;
public synchronized class PDAStepByStateSimulator extends automata.AutomatonSimulator {
    protected int myAcceptance;
    protected static final int EMPTY_STACK = 0;
    protected static final int FINAL_STATE = 1;
    public void PDAStepByStateSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
    public void setAcceptByFinalState();
    public void setAcceptByEmptyStack();
    public boolean isAccepted();
    public boolean simulateInput(String);
}

automata/pda/PDAToCFGConverter.class

package automata.pda;
public synchronized class PDAToCFGConverter {
    protected static final String START_SYMBOL = S;
    protected int UNIQUE_ID;
    protected java.util.HashMap MAP;
    protected static final String LEFT_PAREN = (;
    protected static final String RIGHT_PAREN = );
    protected static final String BOTTOM_OF_STACK = Z;
    public void PDAToCFGConverter();
    public void initializeConverter();
    public boolean hasSingleFinalState(automata.Automaton);
    public boolean hasTransitionsInCorrectForm(automata.Automaton);
    public boolean isInCorrectFormForConversion(automata.Automaton);
    public boolean isPushTwoTransition(automata.Transition);
    public boolean isPushLambdaTransition(automata.Transition);
    private String getUniqueVariable();
    public boolean isStartSymbol(String, automata.Automaton);
    public java.util.ArrayList getProductionsForPushTwoTransition(automata.Transition, automata.Automaton);
    public java.util.ArrayList getProductionsForPushLambdaTransition(automata.Transition, automata.Automaton);
    public java.util.ArrayList createProductionsForTransition(automata.Transition, automata.Automaton);
    public grammar.Production getSimplifiedProduction(grammar.Production);
    public int numberVariables();
    public grammar.cfg.ContextFreeGrammar convertToContextFreeGrammar(automata.Automaton);
    private void purgeProductionsHelper(String, grammar.Production[], java.util.HashSet, int[]);
    public void purgeProductions(automata.Automaton, gui.grammar.GrammarTableModel);
}

automata/pda/PDAConfiguration.class

package automata.pda;
public synchronized class PDAConfiguration extends automata.Configuration {
    protected int myAcceptance;
    protected static final int EMPTY_STACK = 0;
    protected static final int FINAL_STATE = 1;
    protected String myInput;
    protected String myUnprocessedInput;
    protected CharacterStack myStack;
    public void PDAConfiguration(automata.State, PDAConfiguration, String, String, CharacterStack, int);
    public String getInput();
    public String getUnprocessedInput();
    public void setUnprocessedInput(String);
    public CharacterStack getStack();
    public String toString();
    public boolean isAccept();
    public boolean equals(Object);
    public int hashCode();
}

automata/turing/TuringMachine.class

package automata.turing;
public synchronized class TuringMachine extends automata.Automaton {
    private static final long serialVersionUID = 1;
    public int tapes;
    public boolean isOuterMost;
    private TMState parent;
    static void <clinit>();
    public void TuringMachine();
    public void TuringMachine(int);
    protected Class getTransitionClass();
    public void addTransition(automata.Transition);
    public int tapes();
    public automata.State createState(java.awt.Point);
    public Object clone();
    public TMState createBlock(java.awt.Point);
    private TMState getAutomatonFromFile(int, java.awt.Point);
    public TMState createTMStateWithID(java.awt.Point, int);
    public TMState createTMState(java.awt.Point);
    public TMState createInnerTM(java.awt.Point, java.io.Serializable, String, int);
    public static void become(TuringMachine, TuringMachine);
    public java.util.Map getBlockMap();
    public void setParent(TMState);
    public TMState getParent();
}

automata/turing/TMSimulator$1.class

package automata.turing;
synchronized class TMSimulator$1 implements java.util.Comparator {
    void TMSimulator$1(TMSimulator);
    public int compare(automata.Transition, automata.Transition);
}

automata/turing/TMSimulator.class

package automata.turing;
public synchronized class TMSimulator extends automata.AutomatonSimulator {
    private String[] inputStrings;
    private java.util.Map varToChar;
    private AcceptanceFilter[] myFilters;
    static void <clinit>();
    public void TMSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public automata.Configuration[] getInitialConfigurations(String[]);
    private boolean matches(Tape[], TMTransition);
    public java.util.List stepBlock(TMConfiguration);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
    public boolean isAccepted();
    public boolean simulateInput(String);
    public String[] getInputStrings();
}

automata/turing/TMTransition.class

package automata.turing;
public synchronized class TMTransition extends automata.Transition {
    private static final long serialVersionUID = 1;
    private int tapes;
    private boolean blockTransition;
    private java.util.List toRead;
    private java.util.List toWrite;
    private java.util.List direction;
    public static final String BLANK = □;
    public void TMTransition(automata.State, automata.State, String, String, String);
    public void TMTransition(automata.State, automata.State, String[], String[], String[]);
    public int getTapeLength();
    public automata.Transition copy(automata.State, automata.State);
    public String getRead(int);
    public void setRead(int, String);
    public void setWrite(int, String);
    protected void setRead(String, int);
    public String getWrite(int);
    protected void setWrite(String, int);
    public String getDirection(int);
    protected void setDirection(String, int);
    public int tapes();
    public String getDescription();
    public String toString();
    public int hashCode();
    public boolean equals(Object);
    public boolean isBlockTransition();
    public void setBlockTransition(boolean);
}

automata/turing/TMConfiguration.class

package automata.turing;
public synchronized class TMConfiguration extends automata.Configuration implements Cloneable {
    protected Tape[] myTapes;
    private AcceptanceFilter[] myFilters;
    private boolean isHalted;
    public void TMConfiguration(automata.State, TMConfiguration, Tape[], AcceptanceFilter[]);
    public Tape[] getTapes();
    public String toString();
    public boolean isAccept();
    public boolean equals(Object);
    public int hashCode();
    public boolean isHalted();
    public void setHalted(boolean);
    public Object clone();
}

automata/turing/TMLambdaTransitionChecker.class

package automata.turing;
public synchronized class TMLambdaTransitionChecker extends automata.LambdaTransitionChecker {
    public void TMLambdaTransitionChecker();
    public boolean isLambdaTransition(automata.Transition);
}

automata/turing/TMState.class

package automata.turing;
public synchronized class TMState extends automata.State {
    private static final long serialVersionUID = 1;
    private TuringMachineBuildingBlocks myInnerTuringMachine;
    public String myInternalName;
    static void <clinit>();
    public void TMState(int, java.awt.Point, automata.Automaton);
    public void TMState(TMState);
    public void setInnerTM(TuringMachineBuildingBlocks);
    public TuringMachineBuildingBlocks getInnerTM();
    public String getInternalName();
    public void setInternalName(String);
}

automata/turing/NDTMSimulator.class

package automata.turing;
public synchronized class NDTMSimulator extends automata.AutomatonSimulator {
    private AcceptanceFilter[] myFilters;
    private String[] inputStrings;
    public void NDTMSimulator(automata.Automaton);
    public automata.Configuration[] getInitialConfigurations(String);
    public automata.Configuration[] getInitialConfigurations(String[]);
    public java.util.ArrayList stepConfiguration(automata.Configuration);
    public boolean isAccepted();
    public boolean simulateInput(String);
    public java.util.List stepBlock(TMConfiguration);
    public String[] getInputStrings();
}

automata/turing/AcceptanceFilter.class

package automata.turing;
public abstract interface AcceptanceFilter {
    public abstract boolean accept(TMConfiguration);
    public abstract String getName();
}

automata/turing/Tape.class

package automata.turing;
public synchronized class Tape implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private StringBuffer buffer;
    private int tapeHead;
    private int cachedHash;
    public static final char BLANK = 9633;
    public void Tape();
    public void Tape(String);
    public void Tape(Tape);
    public void writeChar(char);
    public void write(String);
    public char readChar();
    public String read();
    public void moveHead(String);
    public String getContents();
    public String getOutput();
    public int getTapeHead();
    public String toString();
    private void nonTrivial(int[]);
    public boolean equals(Object);
    public int hashCode();
}

automata/turing/TuringToGrammarConverter.class

package automata.turing;
public synchronized class TuringToGrammarConverter {
    private static final String SQUARE_SYMBOL = □;
    private static final String SQUARE = =;
    private static final String VAR_START = V(;
    private static final String VAR_END = );
    private java.util.HashSet myAllReadableString;
    private java.util.HashSet myAllWritableString;
    public void TuringToGrammarConverter();
    public grammar.Production[] createProductionsForInit(automata.State, automata.Transition[]);
    public grammar.Production[] createProductionsForTransition(automata.Transition, automata.State[]);
}

automata/turing/TMNondeterminismDetector.class

package automata.turing;
public synchronized class TMNondeterminismDetector extends automata.NondeterminismDetector {
    public void TMNondeterminismDetector();
    public boolean areNondeterministic(automata.Transition, automata.Transition);
}

automata/turing/AcceptByFinalStateFilter.class

package automata.turing;
public synchronized class AcceptByFinalStateFilter implements AcceptanceFilter {
    public void AcceptByFinalStateFilter();
    public boolean accept(TMConfiguration);
    public String getName();
}

automata/turing/AcceptByHaltingFilter.class

package automata.turing;
public synchronized class AcceptByHaltingFilter implements AcceptanceFilter {
    public void AcceptByHaltingFilter();
    public boolean accept(TMConfiguration);
    public String getName();
}

automata/turing/AcceptanceEnum.class

package automata.turing;
public final synchronized enum AcceptanceEnum {
    public static final AcceptanceEnum ACCEPT;
    public static final AcceptanceEnum REJECT;
    public static final AcceptanceEnum CONTINUE;
    static void <clinit>();
    private void AcceptanceEnum(String, int);
    public static AcceptanceEnum[] values();
    public static AcceptanceEnum valueOf(String);
}

automata/turing/TuringTrimmingTester.class

package automata.turing;
public synchronized class TuringTrimmingTester {
    private grammar.Production[] prods;
    public void TuringTrimmingTester(String);
    private void trim();
    public static void main(String[]);
}

automata/turing/TuringMachineBuildingBlocks.class

package automata.turing;
public synchronized class TuringMachineBuildingBlocks extends TuringMachine {
    private static final long serialVersionUID = 1;
    public int tapes;
    public boolean isOuterMost;
    private TMState parent;
    static void <clinit>();
    public void TuringMachineBuildingBlocks();
    public void TuringMachineBuildingBlocks(int);
    protected Class getTransitionClass();
    public void addTransition(automata.Transition);
    public int tapes();
    public automata.State createState(java.awt.Point);
    public Object clone();
    public final TMState createBlock(java.awt.Point);
    private TMState getAutomatonFromFile(int, java.awt.Point);
    public final TMState createTMStateWithID(java.awt.Point, int);
    public final TMState createTMState(java.awt.Point);
    public TMState createInnerTM(java.awt.Point, java.io.Serializable, String, int);
    public static void become(TuringMachineBuildingBlocks, TuringMachineBuildingBlocks);
    public java.util.Map getTMBBBlockMap();
    public void setParent(TMState);
    public TMState getParent();
}

automata/vdg/VDGTransition.class

package automata.vdg;
public synchronized class VDGTransition extends automata.Transition {
    private static final long serialVersionUID = 1;
    public void VDGTransition(automata.State, automata.State);
    public automata.Transition copy(automata.State, automata.State);
    public String toString();
}

automata/vdg/VariableDependencyGraph.class

package automata.vdg;
public synchronized class VariableDependencyGraph extends automata.Automaton {
    private static final long serialVersionUID = 1;
    public void VariableDependencyGraph();
    protected Class getTransitionClass();
}

debug/EDebug.class

package debug;
public synchronized class EDebug {
    public static boolean setFind;
    static void <clinit>();
    public void EDebug();
    private static String getFileName();
    private static String getClassName();
    private static String getMethodName();
    private static int getLineNumber();
    public static void print(Object);
}

file/CodecRegistry.class

package file;
public synchronized class CodecRegistry {
    private java.util.List encoders;
    private java.util.List decoders;
    public void CodecRegistry();
    public void add(Codec);
    private void addEncoder(Encoder);
    private void addDecoder(Decoder);
    public java.util.List getEncoders(java.io.Serializable);
    public java.util.List getDecoders();
}

file/LenoreSystemsCodec.class

package file;
public synchronized class LenoreSystemsCodec extends Codec {
    public void LenoreSystemsCodec();
    public java.io.Serializable decode(java.io.File, java.util.Map);
    public java.io.File encode(java.io.Serializable, java.io.File, java.util.Map);
    public boolean canEncode(java.io.Serializable);
    public String getDescription();
}

file/XMLCodec.class

package file;
public synchronized class XMLCodec extends Codec {
    public static final String SUFFIX = .jff;
    public void XMLCodec();
    public boolean accept(java.io.File);
    public java.io.Serializable decode(java.io.File, java.util.Map);
    public java.io.File encode(java.io.Serializable, java.io.File, java.util.Map);
    public boolean canEncode(java.io.Serializable);
    public String getDescription();
    public String proposeFilename(String, java.io.Serializable);
}

file/ParseException.class

package file;
public synchronized class ParseException extends RuntimeException {
    private static final long serialVersionUID = 1;
    public void ParseException();
    public void ParseException(String);
}

file/EncodeException.class

package file;
public synchronized class EncodeException extends RuntimeException {
    private static final long serialVersionUID = 1;
    public void EncodeException();
    public void EncodeException(String);
}

file/Codec.class

package file;
public abstract synchronized class Codec extends javax.swing.filechooser.FileFilter implements Encoder, Decoder {
    public void Codec();
    public boolean accept(java.io.File);
    public String proposeFilename(String, java.io.Serializable);
    public Encoder correspondingEncoder();
    public String rootFilename(String, java.io.Serializable);
}

file/Decoder.class

package file;
public abstract interface Decoder {
    public abstract java.io.Serializable decode(java.io.File, java.util.Map);
    public abstract Encoder correspondingEncoder();
}

file/DataException.class

package file;
public synchronized class DataException extends RuntimeException {
    private static final long serialVersionUID = 1;
    public void DataException();
    public void DataException(String);
}

file/Encoder.class

package file;
public abstract interface Encoder {
    public abstract java.io.File encode(java.io.Serializable, java.io.File, java.util.Map);
    public abstract boolean canEncode(java.io.Serializable);
    public abstract String proposeFilename(String, java.io.Serializable);
}

file/JFLAP3Codec.class

package file;
public synchronized class JFLAP3Codec extends Codec {
    public static final String FINITE_AUTOMATON_SUFFIX = .FA;
    public static final String PUSHDOWN_AUTOMATON_SUFFIX = .PDA;
    public static final String TURING_MACHINE_SUFFIX = .TM;
    public static final String TWO_TAPE_TURING_MACHINE_SUFFIX = .TTM;
    public static final String GRAMMAR_SUFFIX = .GRM;
    public static final String REGULAR_EXPRESSION_SUFFIX = .REX;
    private static final String FINITE_AUTOMATON_CODE = One-Way-FSA;
    private static final String PUSHDOWN_AUTOMATON_CODE = PDAP;
    private static final String TURING_MACHINE_CODE = REGTM;
    public void JFLAP3Codec();
    public java.io.Serializable decode(java.io.File, java.util.Map);
    private regular.RegularExpression readRE(java.io.File);
    private grammar.Grammar readGrammar(java.io.File);
    private automata.Automaton readAutomaton(java.io.File);
    private automata.fsa.FiniteStateAutomaton readFA(java.io.BufferedReader) throws java.io.IOException;
    private automata.pda.PushdownAutomaton readPDA(java.io.BufferedReader) throws java.io.IOException;
    private automata.turing.TuringMachine readTM(java.io.BufferedReader) throws java.io.IOException;
    private automata.State[] readStateCreate(automata.Automaton, java.io.BufferedReader) throws java.io.IOException;
    private void readStateMove(automata.State[], java.io.BufferedReader) throws java.io.IOException;
    private String[][][] readTransitionGroups(int, int, int, java.io.BufferedReader) throws java.io.IOException;
    public java.io.File encode(java.io.Serializable, java.io.File, java.util.Map);
    public boolean canEncode(java.io.Serializable);
    public String getDescription();
}

file/SerializedCodec.class

package file;
public synchronized class SerializedCodec extends Codec {
    private XMLCodec xmlcodec;
    public void SerializedCodec(XMLCodec);
    public java.io.Serializable decode(java.io.File, java.util.Map);
    public java.io.File encode(java.io.Serializable, java.io.File, java.util.Map);
    public boolean canEncode(java.io.Serializable);
    public String getDescription();
    public Encoder correspondingEncoder();
}

file/xml/AbstractTransducer.class

package file.xml;
public abstract synchronized class AbstractTransducer implements Transducer {
    private static javax.xml.parsers.DocumentBuilder docBuilder;
    static void <clinit>();
    public void AbstractTransducer();
    protected org.w3c.dom.Document newEmptyDocument();
    protected static String containedText(org.w3c.dom.Node);
    protected static java.util.Map elementsToText(org.w3c.dom.Node);
    protected static org.w3c.dom.Comment createComment(org.w3c.dom.Document, String);
    protected static org.w3c.dom.Element createElement(org.w3c.dom.Document, String, java.util.Map, String);
}

file/xml/GrammarTransducer.class

package file.xml;
public synchronized class GrammarTransducer extends AbstractTransducer {
    public static final String PRODUCTION_NAME = production;
    public static final String PRODUCTION_LEFT_NAME = left;
    public static final String PRODUCTION_RIGHT_NAME = right;
    private static final String COMMENT_PRODUCTIONS = The list of productions.;
    public void GrammarTransducer();
    public String getType();
    public static grammar.Production createProduction(org.w3c.dom.Node);
    public static org.w3c.dom.Element createProductionElement(org.w3c.dom.Document, grammar.Production);
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
}

file/xml/AutomatonTransducer$1.class

package file.xml;
synchronized class AutomatonTransducer$1 implements java.util.Comparator {
    void AutomatonTransducer$1(AutomatonTransducer);
    public int compare(Object, Object);
}

file/xml/AutomatonTransducer$2.class

package file.xml;
synchronized class AutomatonTransducer$2 implements java.util.Comparator {
    void AutomatonTransducer$2(AutomatonTransducer);
    public int compare(Object, Object);
}

file/xml/AutomatonTransducer.class

package file.xml;
public abstract synchronized class AutomatonTransducer extends AbstractTransducer {
    private java.util.Map automatonMap;
    private automata.Automaton originalAutomaton;
    private static final String AUTOMATON_NAME = automaton;
    private static final String COMMENT_AUTOMATA = The list of automata;
    private static final String FILE_NAME = tag;
    public static final String BLOCK_NAME = block;
    public static final String STATE_NAME = state;
    public static final String STATE_ID_NAME = id;
    public static final String STATE_X_COORD_NAME = x;
    public static final String STATE_Y_COORD_NAME = y;
    public static final String STATE_LABEL_NAME = label;
    public static final String STATE_NAME_NAME = name;
    public static final String STATE_FINAL_NAME = final;
    public static final String STATE_INITIAL_NAME = initial;
    public static final String TRANSITION_NAME = transition;
    public static final String TRANSITION_FROM_NAME = from;
    public static final String TRANSITION_TO_NAME = to;
    public static final String TRANSITION_CONTROL_X = controlx;
    public static final String TRANSITION_CONTROL_Y = controly;
    private static final String COMMENT_STATES = The list of states.;
    private static final String COMMENT_TRANSITIONS = The list of transitions.;
    public static final String NOTE_NAME = note;
    public static final String NOTE_TEXT_NAME = text;
    private static final String IS_BLOCK = block;
    static void <clinit>();
    public void AutomatonTransducer();
    protected abstract automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected java.util.Map readStates(org.w3c.dom.Node, automata.Automaton, java.util.Set, org.w3c.dom.Document);
    protected void createState(java.util.ArrayList, java.util.Map, automata.Automaton, java.util.Set, java.util.Map, boolean, org.w3c.dom.Document);
    protected void addBlocks(org.w3c.dom.Node, automata.Automaton, java.util.Set, java.util.Map, org.w3c.dom.Document);
    protected abstract automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected void readTransitions(org.w3c.dom.Node, automata.Automaton, java.util.Map);
    protected static Integer parseID(String);
    private void performLayout(automata.Automaton, java.util.Set);
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    public java.io.Serializable readAutomaton(org.w3c.dom.Node, org.w3c.dom.Document);
    private void readnotes(org.w3c.dom.Node, automata.Automaton, org.w3c.dom.Document);
    private void readBlocks(org.w3c.dom.Node, automata.Automaton, java.util.Set, org.w3c.dom.Document);
    protected org.w3c.dom.Element createStateElement(org.w3c.dom.Document, automata.State, automata.Automaton);
    protected org.w3c.dom.Element createTMStateElement(org.w3c.dom.Document, automata.turing.TMState, automata.Automaton);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    protected org.w3c.dom.Element createBlockElement(org.w3c.dom.Document, automata.turing.TMState, automata.Automaton);
    protected org.w3c.dom.Element createAutomatonElement(org.w3c.dom.Document, automata.Automaton, String);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
    private org.w3c.dom.Element writeFields(org.w3c.dom.Document, automata.Automaton, org.w3c.dom.Element);
    private org.w3c.dom.Node createNoteElement(org.w3c.dom.Document, automata.Note);
}

file/xml/TMTransducer.class

package file.xml;
public synchronized class TMTransducer extends AutomatonTransducer {
    public static final String TURING_TAPES_NAME = tapes;
    public static final String TRANSITION_TAPE_NAME = tape;
    public static final String TRANSITION_READ_NAME = read;
    public static final String TRANSITION_WRITE_NAME = write;
    public static final String TRANSITION_MOVE_NAME = move;
    public static final String IS_BLOCK = block;
    public void TMTransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    public String getType();
    public org.w3c.dom.Document toDOM(java.io.Serializable);
}

file/xml/LSystemTransducer.class

package file.xml;
public synchronized class LSystemTransducer extends AbstractTransducer {
    public static final String AXIOM_NAME = axiom;
    public static final String RULE_NAME = production;
    public static final String RULE_LEFT_NAME = left;
    public static final String RULE_RIGHT_NAME = right;
    public static final String PARAMETER_NAME = parameter;
    public static final String PARAMETER_NAME_NAME = name;
    public static final String PARAMETER_VALUE_NAME = value;
    private static final String COMMENT_AXIOM = The L-system axiom.;
    private static final String COMMENT_RULE = The rewriting rules.;
    private static final String COMMENT_PARAMETER = The drawing parameters.;
    public void LSystemTransducer();
    public String getType();
    private static String listAsString(java.util.List);
    private static grammar.Production[] createRules(org.w3c.dom.Node);
    public static org.w3c.dom.Element createRuleElement(org.w3c.dom.Document, grammar.lsystem.LSystem, String);
    private String readAxiom(org.w3c.dom.Document);
    private grammar.Grammar readGrammar(org.w3c.dom.Document);
    private java.util.Map readParameters(org.w3c.dom.Document);
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
}

file/xml/TransducerFactory.class

package file.xml;
public synchronized class TransducerFactory {
    private static java.util.Map typeToTransducer;
    private static java.util.Map classToTransducer;
    static void <clinit>();
    public void TransducerFactory();
    public static Transducer getTransducer(org.w3c.dom.Document);
    public static Transducer getTransducer(java.io.Serializable);
    private static Transducer instantiate(Object);
    private static void add(String, Class, Object);
}

file/xml/MooreTransducer.class

package file.xml;
public synchronized class MooreTransducer extends MealyTransducer {
    public static final String STATE_OUTPUT_NAME = output;
    public void MooreTransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    public String getType();
    protected org.w3c.dom.Element createStateElement(org.w3c.dom.Document, automata.State, automata.Automaton);
}

file/xml/CFPumpingLemmaTransducer.class

package file.xml;
public synchronized class CFPumpingLemmaTransducer extends PumpingLemmaTransducer {
    public static String TYPE;
    public static String U_NAME;
    public static String V_NAME;
    public static String X_NAME;
    public static String Y_NAME;
    public static String CASE_NAME;
    public static String CASE_I_NAME;
    public static String CASE_U_NAME;
    public static String CASE_V_NAME;
    public static String CASE_X_NAME;
    public static String CASE_Y_NAME;
    static void <clinit>();
    public void CFPumpingLemmaTransducer();
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    protected void readCases(org.w3c.dom.Document, pumping.ContextFreePumpingLemma);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
    protected org.w3c.dom.Element createCaseElement(org.w3c.dom.Document, pumping.Case);
    public String getType();
}

file/xml/Transducer.class

package file.xml;
public abstract interface Transducer {
    public static final String STRUCTURE_NAME = structure;
    public static final String STRUCTURE_TYPE_NAME = type;
    public abstract java.io.Serializable fromDOM(org.w3c.dom.Document);
    public abstract org.w3c.dom.Document toDOM(java.io.Serializable);
    public abstract String getType();
}

file/xml/TMBBTransducer.class

package file.xml;
public synchronized class TMBBTransducer extends AutomatonTransducer {
    public static final String TURING_TAPES_NAME = tapes;
    public static final String TRANSITION_TAPE_NAME = tape;
    public static final String TRANSITION_READ_NAME = read;
    public static final String TRANSITION_WRITE_NAME = write;
    public static final String TRANSITION_MOVE_NAME = move;
    public static final String IS_BLOCK = block;
    public void TMBBTransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    public String getType();
    public org.w3c.dom.Document toDOM(java.io.Serializable);
}

file/xml/DOMPrettier.class

package file.xml;
public synchronized class DOMPrettier {
    public static final String INDENT = 	;
    public void DOMPrettier();
    private static boolean makePretty(org.w3c.dom.Document, String, org.w3c.dom.Node);
    public static void makePretty(org.w3c.dom.Document);
}

file/xml/RETransducer.class

package file.xml;
public synchronized class RETransducer extends AbstractTransducer {
    public static final String EXPRESSION_NAME = expression;
    private static final String COMMENT_EXPRESSION = The regular expression.;
    public void RETransducer();
    public String getType();
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
}

file/xml/PumpingLemmaFactory.class

package file.xml;
public synchronized class PumpingLemmaFactory {
    public void PumpingLemmaFactory();
    public static pumping.PumpingLemma createPumpingLemma(String, String);
}

file/xml/FSATransducer.class

package file.xml;
public synchronized class FSATransducer extends AutomatonTransducer {
    public static final String TRANSITION_READ_NAME = read;
    public void FSATransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    public String getType();
}

file/xml/MealyTransducer.class

package file.xml;
public synchronized class MealyTransducer extends AutomatonTransducer {
    public static final String TRANSITION_READ_NAME = read;
    public static final String TRANSITION_OUTPUT_NAME = transout;
    public void MealyTransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    public String getType();
}

file/xml/RegPumpingLemmaTransducer.class

package file.xml;
public synchronized class RegPumpingLemmaTransducer extends PumpingLemmaTransducer {
    public static String TYPE;
    public static String X_NAME;
    public static String Y_NAME;
    static void <clinit>();
    public void RegPumpingLemmaTransducer();
    public java.io.Serializable fromDOM(org.w3c.dom.Document);
    public org.w3c.dom.Document toDOM(java.io.Serializable);
    public String getType();
}

file/xml/PumpingLemmaTransducer.class

package file.xml;
public abstract synchronized class PumpingLemmaTransducer extends AbstractTransducer {
    public static String LEMMA_NAME;
    public static String FIRST_PLAYER;
    public static String M_NAME;
    public static String W_NAME;
    public static String I_NAME;
    public static String ATTEMPT;
    public static String COMMENT_M;
    public static String COMMENT_I;
    static void <clinit>();
    public void PumpingLemmaTransducer();
}

file/xml/PDATransducer.class

package file.xml;
public synchronized class PDATransducer extends AutomatonTransducer {
    public static final String TRANSITION_READ_NAME = read;
    public static final String TRANSITION_POP_NAME = pop;
    public static final String TRANSITION_PUSH_NAME = push;
    public void PDATransducer();
    protected automata.Automaton createEmptyAutomaton(org.w3c.dom.Document);
    protected automata.Transition createTransition(automata.State, automata.State, org.w3c.dom.Node, java.util.Map, boolean);
    protected org.w3c.dom.Element createTransitionElement(org.w3c.dom.Document, automata.Transition);
    public String getType();
}

grammar/ConvertedUnrestrictedGrammar.class

package grammar;
public synchronized class ConvertedUnrestrictedGrammar extends Grammar {
    private static final long serialVersionUID = 1;
    private boolean myTuringBool;
    public void ConvertedUnrestrictedGrammar();
    public void checkProduction(Production);
    public void addProduction(Production);
    public boolean isConverted();
}

grammar/UnitProductionRemover.class

package grammar;
public synchronized class UnitProductionRemover {
    public void UnitProductionRemover();
    public automata.vdg.VariableDependencyGraph getVariableDependencyGraph(Grammar);
    public Production[] getUnitProductions(Grammar);
    public Production[] getNonUnitProductions(Grammar);
    public void initializeDependencyGraph(automata.vdg.VariableDependencyGraph, Grammar);
    public automata.State getStateForVariable(String, automata.vdg.VariableDependencyGraph);
    public automata.Transition getTransitionForUnitProduction(Production, automata.vdg.VariableDependencyGraph);
    public void addAllNonUnitProductionsToGrammar(Grammar, Grammar);
    public boolean isDependentOn(String, String, automata.vdg.VariableDependencyGraph);
    public String[] getDependencies(String, Grammar, automata.vdg.VariableDependencyGraph);
    public Production[] getNewProductions(String, Production[]);
    public void addAllNewProductionsToGrammar(Grammar, Grammar, automata.vdg.VariableDependencyGraph);
    public Grammar getUnitProductionlessGrammar(Grammar, automata.vdg.VariableDependencyGraph);
}

grammar/ProductionChecker.class

package grammar;
public synchronized class ProductionChecker {
    public void ProductionChecker();
    public static boolean isLinear(Production);
    public static boolean isRightLinear(Production);
    public static boolean isLeftLinear(Production);
    public static boolean isLeftLinearProductionWithVariable(Production);
    public static boolean isRightLinearProductionWithVariable(Production);
    public static boolean isLinearProductionWithNoVariable(Production);
    public static boolean isUnitProduction(Production);
    public static boolean isLambdaProduction(Production);
    public static boolean isRestrictedOnLHS(Production);
    public static boolean isVariableInProduction(String, Production);
    public static boolean isTerminalInProduction(String, Production);
    public static boolean areTerminalsOnRHS(Production);
    public static boolean isVariable(char);
    public static boolean isTerminal(char);
    public static boolean isVariableOnRHS(Production, String);
}

grammar/TuringChecker.class

package grammar;
public final synchronized class TuringChecker {
    private static final String[] LHS_DEFAULT;
    private static final String[] RHS_DEFAULT;
    static void <clinit>();
    public void TuringChecker();
    public static boolean check(java.io.Serializable);
}

grammar/GrammarChecker.class

package grammar;
public synchronized class GrammarChecker {
    public void GrammarChecker();
    public static boolean isRegularGrammar(Grammar);
    public static boolean isRightLinearGrammar(Grammar);
    public static boolean isLeftLinearGrammar(Grammar);
    public static boolean isContextFreeGrammar(Grammar);
    public static boolean isVariableInProductions(Grammar, String);
    public static boolean isTerminalInProductions(Grammar, String);
    public static Production[] getProductionsOnVariable(String, Grammar);
    public static Production[] getNonUnitProductionsOnVariable(String, Grammar);
    public static boolean isProductionInGrammar(Production, Grammar);
    public static Production[] getProductionsWithVariable(String, Grammar);
    public static Production[] getProductionsWithVariableOnRHS(String, Grammar);
    public static String[] getUnresolvedVariables(Grammar);
}

grammar/UselessProductionRemover.class

package grammar;
public synchronized class UselessProductionRemover {
    protected static String START_SYMBOL;
    static void <clinit>();
    public void UselessProductionRemover();
    public static java.util.Set getCompleteUsefulVariableSet(Grammar);
    private static java.util.Set getNewUsefulVariableSet();
    public static void addToUsefulVariableSet(String, java.util.Set);
    public static java.util.Set getTerminalProductions(Grammar);
    public static Grammar getTerminalGrammar(Grammar);
    public static String getVariableThatBelongsInUsefulVariableSet(Grammar, java.util.Set);
    private static boolean isInUsefulVariableSet(char, java.util.Set);
    private static boolean isUsefulProduction(Production, java.util.Set);
    public static boolean isValidProduction(Production, java.util.Set);
    public static boolean belongsInUsefulVariableSet(String, Grammar, java.util.Set);
    public static boolean areMoreVariablesThatBelongInUsefulVariableSet(Grammar, java.util.Set);
    public static java.util.Set getCompleteProductionWithUsefulVariableSet(Grammar, java.util.Set);
    public static java.util.Set getNewProductionWithUsefulVariableSet();
    public static boolean belongsInProductionWithUsefulVariableSet(Production, java.util.Set);
    public static void addToProductionWithUsefulVariableSet(Production, java.util.Set);
    public static void initializeVariableDependencyGraph(automata.vdg.VariableDependencyGraph, Grammar);
    public static boolean isDependentOn(String, String, Grammar);
    public static automata.Transition getTransition(String, String, automata.vdg.VariableDependencyGraph);
    public static automata.State getStateForVariable(String, automata.vdg.VariableDependencyGraph);
    public static automata.vdg.VariableDependencyGraph getVariableDependencyGraph(Grammar);
    public static automata.Transition[] getTransitionsForProduction(Production, automata.vdg.VariableDependencyGraph);
    public static String[] getUselessVariables(Grammar, automata.vdg.VariableDependencyGraph);
    public static void removeProductionsForVariable(String, Grammar);
    private static Grammar getGrammarWithNoVariablesThatCantDeriveStrings(java.util.Set);
    public static Grammar getUselessProductionlessGrammar(Grammar);
}

grammar/CNFConverter$ProductionDirectory.class

package grammar;
synchronized class CNFConverter$ProductionDirectory {
    private java.util.List productions;
    private java.util.Map lhsToRhs;
    private java.util.Map rhsToLhs;
    public void CNFConverter$ProductionDirectory(CNFConverter, Grammar);
    public void add(Production);
    public String[] getRight(String);
    public String getLeft(String);
}

grammar/CNFConverter.class

package grammar;
public synchronized class CNFConverter {
    private boolean leftAdded;
    private int numVariables;
    private ProductionComparator productionComparator;
    private CNFConverter$ProductionDirectory productionDirectory;
    private Grammar grammar;
    public void CNFConverter(Grammar);
    public static String[] separateString(String);
    private String getLeft(String);
    public static Production[] convert(Production[]);
    public Production[] replacements(Production);
    public boolean isChomsky(Production);
    public Production[] determinalize(Production);
}

grammar/LambdaProductionRemover.class

package grammar;
public synchronized class LambdaProductionRemover {
    protected String ZERO;
    protected char ONE_CHAR;
    public void LambdaProductionRemover();
    public java.util.HashSet getNewLambdaSet();
    public void addVariableToLambdaSet(String, java.util.Set);
    public boolean isVariableWithLambdaProduction(String, Grammar);
    public boolean areMoreVariablesWithLambdaProductions(Grammar, java.util.Set);
    public String getNewVariableWithLambdaProduction(Grammar, java.util.Set);
    public void addVariablesWithLambdaProductions(Grammar, java.util.Set);
    public boolean isInLambdaSet(String, java.util.Set);
    public boolean isReducableToLambdaProduction(Production, java.util.Set);
    public boolean belongsInLambdaSet(String, Grammar, java.util.Set);
    public boolean areMoreVariablesToAddToLambdaSet(Grammar, java.util.Set);
    public String getNewVariableThatBelongsInLambdaSet(Grammar, java.util.Set);
    public java.util.HashSet getCompleteLambdaSet(Grammar);
    public Production[] getProductionsToAddForProduction(Production, java.util.Set);
    public Production[] getProductionsToAddToGrammar(Grammar, java.util.Set);
    public Production[] getNonLambdaProductions(Grammar);
    public Grammar getLambdaProductionlessGrammar(Grammar, java.util.Set);
    private boolean isNotReplacedByLambda(char, String);
    private Production getProductionForCombination(Production, String);
    private String getRepresentation(String, String[]);
    private String pad(String, int);
    private String[] getCombinations(String[]);
}

grammar/UnboundGrammar.class

package grammar;
public synchronized class UnboundGrammar extends Grammar {
    private static final long serialVersionUID = 1;
    public void UnboundGrammar();
    public void checkProduction(Production);
    public boolean isConverted();
}

grammar/ProductionComparator.class

package grammar;
public synchronized class ProductionComparator implements java.util.Comparator {
    private String start;
    public void ProductionComparator(Grammar);
    public void ProductionComparator(String);
    public int compare(Object, Object);
    public String getStartVariable();
    public int hashCode();
    public boolean equals(Object);
}

grammar/UnrestrictedGrammar.class

package grammar;
public synchronized class UnrestrictedGrammar extends Grammar {
    private static final long serialVersionUID = 1;
    private boolean myTuringBool;
    public void UnrestrictedGrammar();
    public void checkProduction(Production);
    public void addProduction(Production);
    public boolean isConverted();
}

grammar/Grammar.class

package grammar;
public abstract synchronized class Grammar implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = 1;
    private gui.environment.EnvironmentFrame myEnvFrame;
    private String fileName;
    protected java.util.Set myVariables;
    protected java.util.Set myTerminals;
    protected String myStartVariable;
    protected java.util.List myProductions;
    public void Grammar();
    public abstract boolean isConverted();
    public Object clone();
    public void setStartVariable(String);
    public String getStartVariable();
    public boolean isValidProduction(Production);
    public abstract void checkProduction(Production);
    public void addProduction(Production);
    public void addProductions(Production[]);
    public void removeProduction(Production);
    public Production[] getProductions();
    private void addTerminal(String);
    private void removeTerminal(String);
    public String[] getTerminals();
    private void addVariable(String);
    private void removeVariable(String);
    public String[] getVariables();
    public boolean isProduction(Production);
    public boolean isTerminal(String);
    public boolean isVariable(String);
    public String toString();
    public void setEnvironmentFrame(gui.environment.EnvironmentFrame);
    public gui.environment.EnvironmentFrame getEnvironmentFrame();
    public void setFilePath(String);
    public String getFileName();
    public String getFilePath();
}

grammar/GrammarToAutomatonConverter.class

package grammar;
public abstract synchronized class GrammarToAutomatonConverter {
    protected java.util.HashMap MAP;
    protected String BOTTOM_OF_STACK;
    public void GrammarToAutomatonConverter();
    public void initialize();
    public automata.State getStateForVariable(String);
    public void mapStateToVariable(automata.State, String);
    public abstract automata.Transition getTransitionForProduction(Production);
    public automata.Automaton convertToAutomaton(Grammar);
    public abstract void createStatesForConversion(Grammar, automata.Automaton);
}

grammar/Production.class

package grammar;
public synchronized class Production implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    protected String myLHS;
    protected String myRHS;
    public void Production(String, String);
    public void setRHS(String);
    public void setLHS(String);
    public String getLHS();
    public String getRHS();
    public String[] getSymbols();
    public String[] getVariables();
    public String[] getVariablesOnLHS();
    public String[] getVariablesOnRHS();
    public String[] getTerminals();
    public String[] getTerminalsOnRHS();
    public boolean equals(Object);
    public int hashCode();
    public String[] getTerminalsOnLHS();
    public String toString();
    public String[] getSymbolsOnRHS();
}

grammar/cfg/CFGToPDALLConverter.class

package grammar.cfg;
public synchronized class CFGToPDALLConverter extends grammar.GrammarToAutomatonConverter {
    protected automata.State INTERMEDIATE_STATE;
    public void CFGToPDALLConverter();
    public automata.Transition getTransitionForProduction(grammar.Production);
    public void createStatesForConversion(grammar.Grammar, automata.Automaton);
}

grammar/cfg/CFGToPDALRConverter.class

package grammar.cfg;
public synchronized class CFGToPDALRConverter extends grammar.GrammarToAutomatonConverter {
    protected automata.State START_STATE;
    public void CFGToPDALRConverter();
    private String getReverse(String);
    public automata.Transition getTransitionForProduction(grammar.Production);
    public void createStatesForConversion(grammar.Grammar, automata.Automaton);
}

grammar/cfg/ContextFreeGrammar.class

package grammar.cfg;
public synchronized class ContextFreeGrammar extends grammar.Grammar {
    private static final long serialVersionUID = 1;
    public void ContextFreeGrammar();
    public void checkProduction(grammar.Production);
    public boolean isConverted();
}

grammar/lsystem/LSystem.class

package grammar.lsystem;
public synchronized class LSystem implements java.io.Serializable {
    private static final long serialVersionUID = 1;
    private java.util.Map symbolToReplacements;
    private java.util.Map values;
    private java.util.List axiom;
    private boolean nondeterministic;
    private static final java.util.List[] EMPTY_LIST;
    static void <clinit>();
    public void LSystem();
    public void LSystem(String, grammar.Grammar, java.util.Map);
    public static java.util.List tokenify(String);
    private void initReplacements(grammar.Grammar);
    public java.util.List getAxiom();
    public java.util.List[] getReplacements(String);
    public java.util.Set getSymbolsWithReplacements();
    public java.util.Map getValues();
    public boolean nondeterministic();
}

grammar/lsystem/Expander$Context.class

package grammar.lsystem;
synchronized class Expander$Context {
    protected java.util.List tokens;
    protected int center;
    protected java.util.List[] results;
    public void Expander$Context(Expander, java.util.List, int, java.util.List[]);
    public java.util.List[] matches(java.util.List, int);
    public String toString();
}

grammar/lsystem/Expander.class

package grammar.lsystem;
public synchronized class Expander {
    private LSystem lsystem;
    private java.util.Random stochiastic;
    private java.util.List cachedExpansions;
    private static final java.util.Random RANDOM;
    private Expander$Context[] contexts;
    protected static final java.util.List[] EMPTY_ARRAY;
    static void <clinit>();
    public void Expander(LSystem);
    public void Expander(LSystem, long);
    public java.util.List expansionForLevel(int);
    private java.util.List expand(java.util.List);
    private java.util.List expandNoContext(java.util.List);
    private java.util.List expandContext(java.util.List);
    private final void initializeContexts();
}

grammar/parse/CYKTracerTester.class

package grammar.parse;
public synchronized class CYKTracerTester {
    public void CYKTracerTester();
    public static void main(String[]);
}

grammar/parse/RestrictedUserParser.class

package grammar.parse;
public synchronized class RestrictedUserParser extends UserParser {
    public void RestrictedUserParser(grammar.Grammar, String);
    public boolean isPossibleDerivation(String);
}

grammar/parse/UnrestrictedUserParser.class

package grammar.parse;
public synchronized class UnrestrictedUserParser extends UserParser {
    public void UnrestrictedUserParser(grammar.Grammar, String);
}

grammar/parse/CYKTester.class

package grammar.parse;
public synchronized class CYKTester {
    public void CYKTester();
    public static void main(String[]);
}

grammar/parse/CYKParser.class

package grammar.parse;
public synchronized class CYKParser {
    private grammar.Production[] myProductions;
    private static String START_VARIABLE;
    private int myTargetLength;
    private java.util.ArrayList myAnswerProductions;
    private java.util.HashMap myMap;
    private String myTarget;
    private OrderCorrectly myOrderComparator;
    public void CYKParser(grammar.Grammar);
    public boolean solve(String);
    private void checkProductions(int, int);
    public java.util.ArrayList getTrace();
    private void getMoreProductions(String, String);
}

grammar/parse/OrderCorrectly.class

package grammar.parse;
final synchronized class OrderCorrectly implements java.util.Comparator {
    void OrderCorrectly();
    public int compare(Object, Object);
}

grammar/parse/UserParser.class

package grammar.parse;
public abstract synchronized class UserParser {
    private static final grammar.Production[] P;
    private static final int[] S;
    private static final ParseNode E;
    protected grammar.Grammar myGrammar;
    protected grammar.Production[] myProductions;
    protected String myTarget;
    private boolean isDone;
    private ParseNode myAnswer;
    protected java.util.Set mySmallerSet;
    private grammar.Production myCurrentProduction;
    private int myCount;
    private java.util.LinkedList myQueue;
    static void <clinit>();
    public void UserParser(grammar.Grammar, String);
    private void initialize(grammar.Grammar, String);
    public static UserParser get(grammar.Grammar, String);
    public int checkValidAndParse(int);
    private ParseNode getNextResult(String, int);
    public boolean isPossibleDerivation(String);
    public synchronized void parse(int);
    public synchronized boolean start();
    public synchronized boolean isFinished();
    public synchronized ParseNode getAnswer();
    public synchronized ParseNode getPreviousAnswer();
    public String getLHSForProduction(int);
    public void subsitute(int[]);
    private ParseNode getNextSubstitution(String, int[]);
    public boolean isStringTerminal(String);
}

grammar/parse/LLParseTable.class

package grammar.parse;
public synchronized class LLParseTable extends javax.swing.table.AbstractTableModel implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = 1;
    private String[] terminals;
    private String[] variables;
    private java.util.SortedSet[][] entries;
    private boolean frozen;
    public void LLParseTable(grammar.Grammar);
    public void LLParseTable(LLParseTable);
    public Object clone();
    public boolean equals(Object);
    public int hashCode();
    private int[] getLocation(String, String);
    public int getRow(String);
    public int getColumn(String);
    public String[][] getDifferences(LLParseTable);
    public int addEntry(String, String, String);
    public boolean removeEntry(String, String, String);
    public void clear();
    public void clear(String, String);
    public java.util.SortedSet get(String, String);
    public void set(java.util.Set, String, String);
    public int getRowCount();
    public int getColumnCount();
    public String getColumnName(int);
    private String spaceSet(java.util.Set);
    private int despaceSet(String, java.util.Set);
    public Object getValueAt(int, int);
    public void setValueAt(Object, int, int);
    public boolean isCellEditable(int, int);
    public void setEditable(boolean);
}

grammar/parse/RestrictedBruteParser.class

package grammar.parse;
public synchronized class RestrictedBruteParser extends BruteParser {
    public void RestrictedBruteParser(grammar.Grammar, String);
    public boolean isPossibleDerivation(String);
}

grammar/parse/BruteParserListener.class

package grammar.parse;
public abstract interface BruteParserListener extends java.util.EventListener {
    public abstract void bruteParserStateChange(BruteParserEvent);
}

grammar/parse/BruteParserEvent.class

package grammar.parse;
public synchronized class BruteParserEvent extends java.util.EventObject {
    private static final long serialVersionUID = 1;
    private int type;
    public static final int START = 0;
    public static final int PAUSE = 1;
    public static final int ACCEPT = 2;
    public static final int REJECT = 3;
    public void BruteParserEvent(BruteParser, int);
    public BruteParser getParser();
    public boolean isStart();
    public boolean isPause();
    public boolean isAccept();
    public boolean isReject();
    public int getType();
}

grammar/parse/CYKTracer.class

package grammar.parse;
public synchronized class CYKTracer {
    private grammar.Grammar myOriginalGrammar;
    private java.util.ArrayList myTrace;
    private java.util.ArrayList myAnswer;
    private grammar.Production[] myOriginalProductions;
    private java.util.HashMap myLambdaStepMap;
    private java.util.HashMap myUnitStepMap;
    private java.util.ArrayList myTempCNF;
    private java.util.HashMap myCNFMap;
    public void CYKTracer(grammar.Grammar, java.util.ArrayList);
    private void initializeLambdaStepMap();
    private void intializeUnitStepMap(grammar.Grammar);
    private void removeUseless(grammar.Grammar);
    private void initializeChomskyMap(grammar.Grammar);
    private void finalizeCNFMap(java.util.HashMap);
    private void convertToCNF(grammar.CNFConverter, grammar.Production);
    private java.util.ArrayList getDifferentVariable(String, String);
    public void traceBack();
    private void backTrackToCNF();
    private int[] searchForRest(java.util.ArrayList, grammar.Production, int[]);
    private void backTrackToUnit();
    private void backTrackToLambda();
    public grammar.Production[] getAnswer();
    private void reportError();
}

grammar/parse/ParseNode.class

package grammar.parse;
public synchronized class ParseNode extends javax.swing.tree.DefaultMutableTreeNode {
    private static final long serialVersionUID = 1;
    private String derivation;
    private grammar.Production[] productions;
    private int[] subs;
    public void ParseNode(String, grammar.Production[], int[]);
    public void ParseNode(ParseNode);
    public String getDerivation();
    public grammar.Production[] getProductions();
    public int[] getSubstitutions();
    public String toString();
}

grammar/parse/LRParseTableGenerator$1.class

package grammar.parse;
synchronized class LRParseTableGenerator$1 extends LRParseTable {
    private static final long serialVersionUID = 1;
    void LRParseTableGenerator$1(grammar.Grammar, automata.fsa.FiniteStateAutomaton);
    public boolean isCellEditable(int, int);
}

grammar/parse/LRParseTableGenerator.class

package grammar.parse;
public abstract synchronized class LRParseTableGenerator {
    public void LRParseTableGenerator();
    public static LRParseTable generate(grammar.Grammar, automata.fsa.FiniteStateAutomaton, java.util.Map, java.util.Map, java.util.Map);
}

grammar/parse/UnrestrictedBruteParser.class

package grammar.parse;
public synchronized class UnrestrictedBruteParser extends BruteParser {
    public void UnrestrictedBruteParser(grammar.Grammar, String);
}

grammar/parse/LRParser$IntStack.class

package grammar.parse;
synchronized class LRParser$IntStack extends java.util.Stack {
    private static final long serialVersionUID = 1;
    private void LRParser$IntStack();
    int push(int);
    int popInt();
    int peekInt();
}

grammar/parse/LRParser.class

package grammar.parse;
public abstract synchronized class LRParser {
    public void LRParser();
    public static void parse(String, grammar.Grammar, LRParseTable);
    public static javax.swing.tree.TreeModel parseTree(String, grammar.Grammar, LRParseTable);
}

grammar/parse/Unrestricted.class

package grammar.parse;
public synchronized class Unrestricted {
    private void Unrestricted();
    public static int minimumLength(String, java.util.Set);
    private static int count(String, char);
    public static java.util.Set smallerSymbols(grammar.Grammar);
    public static boolean isUnrestricted(grammar.Grammar);
    public static grammar.UnrestrictedGrammar optimize(grammar.Grammar);
}

grammar/parse/Operations.class

package grammar.parse;
public synchronized class Operations {
    private static java.util.WeakHashMap CACHED_FIRST;
    private static java.util.WeakHashMap CACHED_FOLLOW;
    private static java.util.WeakHashMap CACHED_VPMAP;
    public static final char ITEM_POSITION = 183;
    static void <clinit>();
    private void Operations();
    private static java.util.Set setForKey(java.util.Map, Object);
    public static java.util.Map first(grammar.Grammar);
    public static java.util.Set first(java.util.Map, String);
    public static java.util.Map follow(grammar.Grammar);
    public static boolean isLL1(grammar.Grammar);
    public static grammar.Grammar getAugmentedGrammar(grammar.Grammar);
    public static java.util.Set closure(grammar.Grammar, java.util.Set);
    public static java.util.Set goTo(grammar.Grammar, java.util.Set, String);
    public static java.util.Map getVariableProductionMap(grammar.Grammar);
    public static grammar.Production[] getItems(grammar.Production);
    public static String[] getCanGoto(java.util.Set);
}

grammar/parse/LLParseTableGenerator.class

package grammar.parse;
public synchronized class LLParseTableGenerator {
    private void LLParseTableGenerator();
    public static LLParseTable generate(grammar.Grammar);
}

grammar/parse/BruteParser$1.class

package grammar.parse;
synchronized class BruteParser$1 extends Thread {
    void BruteParser$1(BruteParser);
    public void run();
}

grammar/parse/BruteParser.class

package grammar.parse;
public abstract synchronized class BruteParser {
    private static final grammar.Production[] P;
    private static final int[] S;
    private static final ParseNode E;
    protected java.util.Set listeners;
    protected grammar.Grammar grammar;
    protected grammar.Production[] productions;
    protected String target;
    private boolean isDone;
    private Thread parseThread;
    private java.util.Set alreadyAdded;
    private java.util.Map prederived;
    protected java.util.LinkedList queue;
    private int consideredNodes;
    private int beingConsideredNodes;
    private int deletedNodes;
    private ParseNode answer;
    protected java.util.Set smaller;
    static void <clinit>();
    protected void BruteParser();
    public void BruteParser(grammar.Grammar, String);
    public static BruteParser get(grammar.Grammar, String);
    protected void init(grammar.Grammar, String);
    public synchronized boolean start();
    public synchronized void pause();
    public synchronized boolean isActive();
    public synchronized boolean isFinished();
    public synchronized ParseNode getAnswer();
    private java.util.List getPossibilities(String);
    private void removeFutility(ParseNode);
    public int getCurrentNodeCount();
    public int getTotalNodeCount();
    public int getConsiderationNodeCount();
    public boolean isPossibleDerivation(String);
    private synchronized void parse();
    public void addBruteParserListener(BruteParserListener);
    public void removeBruteParserListener(BruteParserListener);
    protected void distributeEvent(BruteParserEvent);
}

grammar/parse/LRParseTable.class

package grammar.parse;
public synchronized class LRParseTable extends javax.swing.table.AbstractTableModel implements java.io.Serializable, Cloneable {
    private static final long serialVersionUID = 1;
    private String[] variables;
    private String[] terminals;
    private String[][] entries;
    private grammar.Grammar grammar;
    private java.util.Map symbolsToColumn;
    public void LRParseTable(grammar.Grammar, automata.fsa.FiniteStateAutomaton);
    public void LRParseTable(LRParseTable);
    public Object clone();
    public void setValueAt(String, int, String);
    public String getValueAt(int, String);
    public java.util.SortedSet getSetAt(int, String);
    public void appendValueAt(String, int, String);
    public int columnForSymbol(String);
    public int getRowCount();
    public int getColumnCount();
    private String parseValue(String, int);
    private String[] parseValues(String, int);
    public String getColumnName(int);
    public void setValueAt(Object, int, int);
    public void appendValueAt(String, int, int);
    public Object getValueAt(int, int);
    public java.util.SortedSet getSetAt(int, int);
    public boolean isCellEditable(int, int);
    private String getContentDescription(String);
    public String getContentDescription(int, int);
}

grammar/reg/RightLinearGrammar.class

package grammar.reg;
public synchronized class RightLinearGrammar extends RegularGrammar {
    private static final long serialVersionUID = 1;
    private static grammar.ProductionChecker PC;
    static void <clinit>();
    public void RightLinearGrammar();
    public void checkProduction(grammar.Production);
}

grammar/reg/RightLinearGrammarToFSAConverter.class

package grammar.reg;
public synchronized class RightLinearGrammarToFSAConverter extends grammar.GrammarToAutomatonConverter {
    protected String FINAL_STATE;
    public void RightLinearGrammarToFSAConverter();
    public automata.Transition getTransitionForProduction(grammar.Production);
    public void createStatesForConversion(grammar.Grammar, automata.Automaton);
}

grammar/reg/RegularGrammar.class

package grammar.reg;
public synchronized class RegularGrammar extends grammar.Grammar {
    private static final long serialVersionUID = 1;
    protected int myLinearity;
    protected static final int LEFT_LINEAR = 0;
    protected static final int RIGHT_LINEAR = 1;
    private static final grammar.ProductionChecker PC;
    static void <clinit>();
    public void RegularGrammar();
    private void setLinearity(int);
    private int getLinearity();
    public void checkProduction(grammar.Production);
    public void addProduction(grammar.Production);
    public boolean isConverted();
}

gui/AboutBox$BoxDismisser.class

package gui;
synchronized class AboutBox$BoxDismisser extends java.awt.event.MouseAdapter {
    private void AboutBox$BoxDismisser(AboutBox);
    public void mouseClicked(java.awt.event.MouseEvent);
}

gui/AboutBox.class

package gui;
public synchronized class AboutBox extends javax.swing.JWindow {
    private static final long serialVersionUID = 1;
    private static Object OBJECT;
    private static java.awt.Image IMAGE;
    public static final String VERSION = 7.1;
    static void <clinit>();
    public void AboutBox(java.awt.Frame);
    private static javax.swing.JLabel getLabel(String);
    public void AboutBox();
    public void displayBox();
    public void dismissBox();
    public static void main(String[]);
}

gui/GrowableTableModel.class

package gui;
public abstract synchronized class GrowableTableModel extends javax.swing.table.AbstractTableModel implements Cloneable {
    private static final long serialVersionUID = 1;
    protected int columns;
    protected java.util.List data;
    public void GrowableTableModel(int);
    public void GrowableTableModel(GrowableTableModel);
    public void clear();
    public void copy(GrowableTableModel);
    protected Object[] initializeRow(int);
    public final int getColumnCount();
    public final int getRowCount();
    public boolean deleteRow(int);
    public void insertRow(Object[], int);
    public Object getValueAt(int, int);
    public void setValueAt(Object, int, int);
}

gui/ImageDisplayComponent.class

package gui;
public synchronized class ImageDisplayComponent extends javax.swing.JComponent implements javax.swing.Scrollable {
    private static final long serialVersionUID = 1;
    private java.awt.Image myImage;
    private java.awt.Point myOrigin;
    private static final java.awt.Point ZERO_ORIGIN;
    static void <clinit>();
    public void ImageDisplayComponent();
    public void ImageDisplayComponent(java.awt.Image);
    public void ImageDisplayComponent(java.net.URL);
    public void ImageDisplayComponent(String);
    public java.awt.Image getImage();
    public void setImage(java.awt.Image, java.awt.Point);
    public void setImage(java.awt.Image);
    private java.awt.Image getBaseImage(String);
    private java.awt.Image getBaseImage(java.net.URL);
    private boolean trackImage(java.awt.Image);
    private void redefineSize();
    public void paintComponent(java.awt.Graphics);
    public java.awt.Dimension getPreferredScrollableViewportSize();
    public int getScrollableBlockIncrement(java.awt.Rectangle, int, int);
    public int getScrollableUnitIncrement(java.awt.Rectangle, int, int);
    public boolean getScrollableTracksViewportWidth();
    public boolean getScrollableTracksViewportHeight();
}

gui/ColorComparator.class

package gui;
public synchronized class ColorComparator implements java.util.Comparator {
    public void ColorComparator();
    public int compare(Object, Object);
    private int compareFloat(float, float);
    public boolean equals(Object);
    public static void main(String[]);
}

gui/WebFrame$BackAction.class

package gui;
synchronized class WebFrame$BackAction implements java.awt.event.ActionListener {
    private void WebFrame$BackAction(WebFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/WebFrame$ForwardAction.class

package gui;
synchronized class WebFrame$ForwardAction implements java.awt.event.ActionListener {
    private void WebFrame$ForwardAction(WebFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/WebFrame$HomeAction.class

package gui;
synchronized class WebFrame$HomeAction implements java.awt.event.ActionListener {
    private void WebFrame$HomeAction(WebFrame);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/WebFrame$Hyperactive.class

package gui;
public synchronized class WebFrame$Hyperactive implements javax.swing.event.HyperlinkListener {
    public void WebFrame$Hyperactive(WebFrame);
    public void hyperlinkUpdate(javax.swing.event.HyperlinkEvent);
}

gui/WebFrame.class

package gui;
public synchronized class WebFrame extends javax.swing.JFrame {
    private static final long serialVersionUID = 1;
    private javax.swing.JEditorPane myBrowserDisplay;
    private java.util.ArrayList myURLHistory;
    private int myCurrentPosition;
    private javax.swing.JButton myBackButton;
    private javax.swing.JButton myForwardButton;
    private javax.swing.JButton myStartButton;
    public void WebFrame(String);
    public void gotoURL(String);
    private javax.swing.JToolBar getToolBar();
    private javax.swing.JButton makeButton(String, String, java.awt.event.ActionListener, String);
    private void goBack();
    private void goHome();
    private void goForward();
    private void setDisplay(String);
    private void setDisplay(java.net.URL);
    private void goNew(String);
    private void setEnabledStates();
}

gui/HighlightTable$1.class

package gui;
synchronized class HighlightTable$1 implements HighlightTable$TableHighlighterRendererGenerator {
    private javax.swing.table.DefaultTableCellRenderer renderer;
    void HighlightTable$1();
    public javax.swing.table.TableCellRenderer getRenderer(int, int);
}

gui/HighlightTable$TableHighlighterRendererGenerator.class

package gui;
public abstract interface HighlightTable$TableHighlighterRendererGenerator {
    public abstract javax.swing.table.TableCellRenderer getRenderer(int, int);
}

gui/HighlightTable.class

package gui;
public synchronized class HighlightTable extends javax.swing.JTable {
    private static final long serialVersionUID = 1;
    private static HighlightTable$TableHighlighterRendererGenerator THRG;
    private java.util.Map highlightRenderers;
    static void <clinit>();
    public void HighlightTable();
    public void HighlightTable(javax.swing.table.TableModel);
    public void highlight(int, int);
    private static int singleIndex(int, int);
    public void dehighlight(int, int);
    public void highlight(int[][], HighlightTable$TableHighlighterRendererGenerator);
    public void highlight(int, int, HighlightTable$TableHighlighterRendererGenerator);
    public void dehighlight();
    public javax.swing.table.TableCellRenderer getCellRenderer(int, int);
}

gui/SuperMouseAdapter.class

package gui;
public abstract synchronized class SuperMouseAdapter implements java.awt.event.MouseListener, java.awt.event.MouseMotionListener {
    public void SuperMouseAdapter();
    public void mouseClicked(java.awt.event.MouseEvent);
    public void mouseEntered(java.awt.event.MouseEvent);
    public void mouseExited(java.awt.event.MouseEvent);
    public void mousePressed(java.awt.event.MouseEvent);
    public void mouseReleased(java.awt.event.MouseEvent);
    public void mouseDragged(java.awt.event.MouseEvent);
    public void mouseMoved(java.awt.event.MouseEvent);
}

gui/Main.class

package gui;
public synchronized class Main {
    private static boolean dontQuit;
    public void Main();
    public static boolean getDontQuit();
    public static void main(String[]);
    private static void loadPreferences();
}

gui/TableTextSizeSlider$SliderListener.class

package gui;
synchronized class TableTextSizeSlider$SliderListener implements javax.swing.event.ChangeListener {
    void TableTextSizeSlider$SliderListener(TableTextSizeSlider);
    public void stateChanged(javax.swing.event.ChangeEvent);
}

gui/TableTextSizeSlider.class

package gui;
public synchronized class TableTextSizeSlider extends javax.swing.JSlider {
    private static final long serialVersionUID = 1;
    static final int FONT_SIZE_MIN = 1;
    static final int FONT_SIZE_MAX = 600;
    static final int FONT_SIZE_INIT = 200;
    static String TABLE_SIZE_TITLE;
    javax.swing.JTable myTable;
    static void <clinit>();
    public void TableTextSizeSlider(javax.swing.JTable, int);
}

gui/JTableExtender.class

package gui;
public synchronized class JTableExtender extends javax.swing.JTable {
    private static final long serialVersionUID = 1;
    private action.MultipleSimulateAction myMultSimAct;
    public void JTableExtender(javax.swing.table.TableModel, action.MultipleSimulateAction);
    public void JTableExtender(javax.swing.table.TableModel, action.BatchMultipleSimulateAction);
    public void changeSelection(int, int, boolean, boolean);
}

gui/ThrowableCatcher.class

package gui;
public synchronized class ThrowableCatcher {
    private static final String ERROR_LOCATION = /DOCS/error.html;
    public void ThrowableCatcher();
    public void handle(Throwable);
}

gui/PanelTextSizeSlider$SliderListener.class

package gui;
synchronized class PanelTextSizeSlider$SliderListener implements javax.swing.event.ChangeListener {
    void PanelTextSizeSlider$SliderListener(PanelTextSizeSlider);
    public void stateChanged(javax.swing.event.ChangeEvent);
}

gui/PanelTextSizeSlider.class

package gui;
public synchronized class PanelTextSizeSlider extends javax.swing.JSlider {
    private static final long serialVersionUID = 1;
    static final int FONT_SIZE_MIN = 1;
    static final int FONT_SIZE_MAX = 600;
    static final int FONT_SIZE_INIT = 200;
    static final String PANEL_SIZE_TITLE = Panel Text Size;
    javax.swing.JPanel myPanel;
    public void PanelTextSizeSlider(javax.swing.JPanel);
}

gui/SplitPaneFactory.class

package gui;
public synchronized class SplitPaneFactory {
    private void SplitPaneFactory();
    public static javax.swing.JSplitPane createSplit(environment.Environment, boolean, double, java.awt.Component, java.awt.Component);
}

gui/TransformFitter.class

package gui;
public abstract synchronized class TransformFitter {
    public void TransformFitter();
    public static java.awt.geom.AffineTransform fit(java.awt.Rectangle, java.awt.Rectangle);
}

gui/InputBox.class

package gui;
public synchronized class InputBox extends javax.swing.JFrame {
    private static final long serialVersionUID = 1;
    private String myInputString;
    private final java.awt.Component myComponent;
    private String myTitle;
    private automata.AutomatonSimulator mySimulator;
    private action.SimulateAction myAction;
    private boolean myIsTuringMachine;
    private automata.Automaton myAutomaton;
    public void InputBox(action.SimulateAction, java.awt.Component, String);
    public String getInputString();
    public void exit();
    public void addSimulator(automata.Automaton, automata.AutomatonSimulator, boolean);
    public static void main(String[]);
}

gui/TooltipAction.class

package gui;
public abstract synchronized class TooltipAction extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    public void TooltipAction(String, String);
    public void setTip(String);
    public String getTip();
}

gui/TextFieldSizeSlider$SliderListener.class

package gui;
synchronized class TextFieldSizeSlider$SliderListener implements javax.swing.event.ChangeListener {
    void TextFieldSizeSlider$SliderListener(TextFieldSizeSlider);
    public void stateChanged(javax.swing.event.ChangeEvent);
}

gui/TextFieldSizeSlider.class

package gui;
public synchronized class TextFieldSizeSlider extends javax.swing.JSlider {
    private static final long serialVersionUID = 1;
    static final int FONT_SIZE_MIN = 1;
    static final int FONT_SIZE_MAX = 600;
    static final int FONT_SIZE_INIT = 300;
    static String TEXTFIELD_SIZE_TITLE;
    javax.swing.JTextField myField;
    static void <clinit>();
    public void TextFieldSizeSlider(javax.swing.JTextField, int, String);
}

gui/JMultiLineToolTip.class

package gui;
public synchronized class JMultiLineToolTip extends javax.swing.JToolTip {
    private static final long serialVersionUID = 1;
    private static final String uiClassID = ToolTipUI;
    String tipText;
    javax.swing.JComponent component;
    protected int columns;
    protected int fixedwidth;
    public void JMultiLineToolTip();
    public void updateUI();
    public void setColumns(int);
    public int getColumns();
    public void setFixedWidth(int);
    public int getFixedWidth();
}

gui/MultiLineToolTipUI.class

package gui;
synchronized class MultiLineToolTipUI extends javax.swing.plaf.basic.BasicToolTipUI {
    static MultiLineToolTipUI sharedInstance;
    java.awt.Font smallFont;
    static javax.swing.JToolTip tip;
    protected javax.swing.CellRendererPane rendererPane;
    private static javax.swing.JTextArea textArea;
    static void <clinit>();
    public static javax.swing.plaf.ComponentUI createUI(javax.swing.JComponent);
    public void MultiLineToolTipUI();
    public void installUI(javax.swing.JComponent);
    public void uninstallUI(javax.swing.JComponent);
    public void paint(java.awt.Graphics, javax.swing.JComponent);
    public java.awt.Dimension getPreferredSize(javax.swing.JComponent);
    public java.awt.Dimension getMinimumSize(javax.swing.JComponent);
    public java.awt.Dimension getMaximumSize(javax.swing.JComponent);
}

gui/LambdaCellRenderer.class

package gui;
public synchronized class LambdaCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
    private static final long serialVersionUID = 1;
    private String toSubstitute;
    public void LambdaCellRenderer(String);
    public void LambdaCellRenderer();
    public final String getEmpty();
    public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}

gui/LeftTable.class

package gui;
public synchronized class LeftTable extends HighlightTable {
    private static final long serialVersionUID = 1;
    public void LeftTable();
    public void LeftTable(javax.swing.table.TableModel);
    private void initView();
}

gui/TripleTextFieldSizeSlider$SliderListener.class

package gui;
synchronized class TripleTextFieldSizeSlider$SliderListener implements javax.swing.event.ChangeListener {
    void TripleTextFieldSizeSlider$SliderListener(TripleTextFieldSizeSlider);
    public void stateChanged(javax.swing.event.ChangeEvent);
}

gui/TripleTextFieldSizeSlider.class

package gui;
public synchronized class TripleTextFieldSizeSlider extends javax.swing.JSlider {
    private static final long serialVersionUID = 1;
    static final int FONT_SIZE_MIN = 1;
    static final int FONT_SIZE_MAX = 600;
    static final int FONT_SIZE_INIT = 300;
    static String TEXTFIELD_SIZE_TITLE;
    javax.swing.JTextField myField1;
    javax.swing.JTextField myField2;
    javax.swing.JTextField myField3;
    static void <clinit>();
    public void TripleTextFieldSizeSlider(javax.swing.JTextField, javax.swing.JTextField, javax.swing.JTextField, int, String);
}

gui/action/BruteParseAction$1.class

package gui.action;
synchronized class BruteParseAction$1 implements gui.environment.tag.CriticalTag {
    void BruteParseAction$1(BruteParseAction);
}

gui/action/BruteParseAction.class

package gui.action;
public synchronized class BruteParseAction extends GrammarAction {
    private static final long serialVersionUID = 1;
    private gui.environment.GrammarEnvironment environment;
    private gui.environment.EnvironmentFrame frame;
    public void BruteParseAction(gui.environment.GrammarEnvironment);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/DFAEqualityAction.class

package gui.action;
public synchronized class DFAEqualityAction extends FSAAction {
    private static final long serialVersionUID = 1;
    private gui.environment.Environment environment;
    private static automata.graph.FSAEqualityChecker checker;
    static void <clinit>();
    public void DFAEqualityAction(automata.fsa.FiniteStateAutomaton, gui.environment.Environment);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/ConvertPDAToGrammarAction.class

package gui.action;
public synchronized class ConvertPDAToGrammarAction extends ConvertAutomatonToGrammarAction {
    private static final long serialVersionUID = 1;
    private gui.environment.AutomatonEnvironment environment;
    private automata.pda.PushdownAutomaton automaton;
    private automata.pda.PDAToCFGConverter converter;
    public void ConvertPDAToGrammarAction(gui.environment.AutomatonEnvironment);
    protected boolean checkAutomaton();
    public static boolean isApplicable(Object);
    protected gui.grammar.automata.ConvertController initializeController(gui.grammar.automata.ConvertPane, gui.viewer.SelectionDrawer, automata.Automaton);
}

gui/action/FSAAction.class

package gui.action;
public abstract synchronized class FSAAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    public void FSAAction(String, javax.swing.Icon);
    public static boolean isApplicable(Object);
}

gui/action/TuringTestAction.class

package gui.action;
public synchronized class TuringTestAction extends TestAction {
    private static final long serialVersionUID = 1;
    public void TuringTestAction();
    protected void displayMultipleRunPane(gui.environment.Environment);
}

gui/action/RegularAction.class

package gui.action;
public abstract synchronized class RegularAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    private gui.environment.RegularEnvironment environment;
    public void RegularAction(String, javax.swing.Icon, gui.environment.RegularEnvironment);
    public static boolean isApplicable(Object);
    protected gui.environment.RegularEnvironment getEnvironment();
    protected regular.RegularExpression getExpression();
}

gui/action/TuringBruteParseAction$1.class

package gui.action;
synchronized class TuringBruteParseAction$1 implements gui.environment.tag.CriticalTag {
    void TuringBruteParseAction$1(TuringBruteParseAction);
}

gui/action/TuringBruteParseAction.class

package gui.action;
public synchronized class TuringBruteParseAction extends GrammarAction {
    private static final long serialVersionUID = 1;
    private gui.environment.GrammarEnvironment environment;
    private gui.environment.EnvironmentFrame frame;
    private java.util.HashMap myVariableMap;
    public void TuringBruteParseAction(gui.environment.GrammarEnvironment);
    public void actionPerformed(java.awt.event.ActionEvent);
    private grammar.Grammar trim(grammar.Production[]);
}

gui/action/OpenURLAction.class

package gui.action;
public synchronized class OpenURLAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    public void OpenURLAction();
    public boolean isEnabled();
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/TuringToUnrestrictGrammarAction.class

package gui.action;
public synchronized class TuringToUnrestrictGrammarAction extends ConvertAutomatonToGrammarAction {
    private static final long serialVersionUID = 1;
    public void TuringToUnrestrictGrammarAction(gui.environment.AutomatonEnvironment);
    protected boolean checkAutomaton();
    protected gui.grammar.automata.ConvertController initializeController(gui.grammar.automata.ConvertPane, gui.viewer.SelectionDrawer, automata.Automaton);
    public static boolean isApplicable(Object);
}

gui/action/MultipleOutputSimulateAction.class

package gui.action;
public synchronized class MultipleOutputSimulateAction extends MultipleSimulateAction {
    private static final long serialVersionUID = 1;
    public void MultipleOutputSimulateAction(automata.Automaton, gui.environment.Environment);
    public String getComponentTitle();
    protected gui.JTableExtender initializeTable(Object);
    public static boolean isApplicable(Object);
}

gui/action/ConvertFSAToGrammarAction.class

package gui.action;
public synchronized class ConvertFSAToGrammarAction extends ConvertAutomatonToGrammarAction {
    private static final long serialVersionUID = 1;
    public void ConvertFSAToGrammarAction(gui.environment.AutomatonEnvironment);
    protected boolean checkAutomaton();
    protected gui.grammar.automata.ConvertController initializeController(gui.grammar.automata.ConvertPane, gui.viewer.SelectionDrawer, automata.Automaton);
    public static boolean isApplicable(Object);
}

gui/action/ConvertAutomatonToGrammarAction$1.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$1 extends java.awt.event.MouseAdapter {
    private gui.viewer.SelectionDrawer drawer;
    void ConvertAutomatonToGrammarAction$1(ConvertAutomatonToGrammarAction, gui.grammar.automata.ConvertPane, gui.grammar.automata.ConvertController);
    public void mouseClicked(java.awt.event.MouseEvent);
}

gui/action/ConvertAutomatonToGrammarAction$2.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$2 implements gui.environment.tag.CriticalTag {
    void ConvertAutomatonToGrammarAction$2(ConvertAutomatonToGrammarAction);
}

gui/action/ConvertAutomatonToGrammarAction$3.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$3 extends gui.TooltipAction {
    private static final long serialVersionUID = 1;
    void ConvertAutomatonToGrammarAction$3(ConvertAutomatonToGrammarAction, String, String, gui.grammar.automata.ConvertController);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/ConvertAutomatonToGrammarAction$4.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$4 extends gui.TooltipAction {
    private static final long serialVersionUID = 1;
    void ConvertAutomatonToGrammarAction$4(ConvertAutomatonToGrammarAction, String, String, gui.grammar.automata.ConvertController);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/ConvertAutomatonToGrammarAction$5.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$5 extends gui.TooltipAction {
    private static final long serialVersionUID = 1;
    void ConvertAutomatonToGrammarAction$5(ConvertAutomatonToGrammarAction, String, String, gui.grammar.automata.ConvertController);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/ConvertAutomatonToGrammarAction$6.class

package gui.action;
synchronized class ConvertAutomatonToGrammarAction$6 extends gui.TooltipAction {
    private static final long serialVersionUID = 1;
    void ConvertAutomatonToGrammarAction$6(ConvertAutomatonToGrammarAction, String, String, gui.grammar.automata.ConvertController);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/ConvertAutomatonToGrammarAction.class

package gui.action;
public abstract synchronized class ConvertAutomatonToGrammarAction extends AutomatonAction {
    private static final long serialVersionUID = 1;
    private gui.environment.AutomatonEnvironment environment;
    private automata.Automaton automaton;
    private gui.grammar.automata.ConvertController controller;
    public void ConvertAutomatonToGrammarAction(gui.environment.AutomatonEnvironment);
    public void ConvertAutomatonToGrammarAction(String, gui.environment.AutomatonEnvironment);
    public void actionPerformed(java.awt.event.ActionEvent);
    private javax.swing.JToolBar initToolbar(gui.grammar.automata.ConvertController);
    protected abstract boolean checkAutomaton();
    protected abstract gui.grammar.automata.ConvertController initializeController(gui.grammar.automata.ConvertPane, gui.viewer.SelectionDrawer, automata.Automaton);
    protected automata.Automaton getAutomaton();
    protected gui.environment.AutomatonEnvironment getEnvironment();
}

gui/action/LayoutAlgorithmAction.class

package gui.action;
public synchronized class LayoutAlgorithmAction extends AutomatonAction {
    private static final long serialVersionUID = 1;
    private final java.awt.Dimension assumedUsedSpace;
    private automata.Automaton automaton;
    private gui.environment.Environment environment;
    private int algorithm;
    public void LayoutAlgorithmAction(String, automata.Automaton, gui.environment.Environment, int);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/RestrictedAction.class

package gui.action;
public abstract synchronized class RestrictedAction extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    protected static int MAIN_MENU_MASK;
    static void <clinit>();
    public void RestrictedAction(String, javax.swing.Icon);
    public static boolean isApplicable(Object);
}

gui/action/CloseAction$1.class

package gui.action;
synchronized class CloseAction$1 implements javax.swing.event.ChangeListener {
    void CloseAction$1(CloseAction);
    public void stateChanged(javax.swing.event.ChangeEvent);
}

gui/action/CloseAction.class

package gui.action;
public synchronized class CloseAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    private gui.environment.Environment environment;
    public void CloseAction(gui.environment.Environment);
    public void actionPerformed(java.awt.event.ActionEvent);
    private void checkEnabled();
}

gui/action/GrammarTypeTestAction.class

package gui.action;
public synchronized class GrammarTypeTestAction extends GrammarAction {
    private static final long serialVersionUID = 1;
    private gui.environment.GrammarEnvironment environment;
    private gui.environment.EnvironmentFrame frame;
    public void GrammarTypeTestAction(gui.environment.GrammarEnvironment);
    public void actionPerformed(java.awt.event.ActionEvent);
    private void checkForSpecialUnrestrictedGrammar(grammar.Production[]);
    private boolean isContextFreeGrammar(grammar.Production[], grammar.Grammar);
    private boolean checkforLinearity(grammar.Production[]);
}

gui/action/ExportAction.class

package gui.action;
public synchronized class ExportAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    private gui.environment.Environment environment;
    public void ExportAction(gui.environment.Environment);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/QuitAction.class

package gui.action;
public synchronized class QuitAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    public void QuitAction();
    public static void beginQuit();
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/GIFFileFilter.class

package gui.action;
synchronized class GIFFileFilter extends javax.swing.filechooser.FileFilter {
    void GIFFileFilter();
    public boolean accept(java.io.File);
    public String getDescription();
}

gui/action/SaveGraphGIFAction.class

package gui.action;
public synchronized class SaveGraphGIFAction extends RestrictedAction {
    private static final long serialVersionUID = 1;
    protected gui.environment.Environment environment;
    protected javax.swing.JMenu myMenu;
    public void SaveGraphGIFAction(gui.environment.Environment, javax.swing.JMenu);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$1.class

package gui.action;
synchronized class MultipleCYKSimulateAction$1 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$1(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$10.class

package gui.action;
synchronized class MultipleCYKSimulateAction$10 implements gui.environment.tag.CriticalTag {
    void MultipleCYKSimulateAction$10(MultipleCYKSimulateAction);
}

gui/action/MultipleCYKSimulateAction$11.class

package gui.action;
synchronized class MultipleCYKSimulateAction$11 implements gui.environment.tag.CriticalTag {
    void MultipleCYKSimulateAction$11(MultipleCYKSimulateAction);
}

gui/action/MultipleCYKSimulateAction$12.class

package gui.action;
synchronized class MultipleCYKSimulateAction$12 implements gui.environment.tag.CriticalTag {
    void MultipleCYKSimulateAction$12(MultipleCYKSimulateAction);
}

gui/action/MultipleCYKSimulateAction$2.class

package gui.action;
synchronized class MultipleCYKSimulateAction$2 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$2(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$3.class

package gui.action;
synchronized class MultipleCYKSimulateAction$3 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$3(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$4.class

package gui.action;
synchronized class MultipleCYKSimulateAction$4 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$4(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$5$1.class

package gui.action;
synchronized class MultipleCYKSimulateAction$5$1 implements gui.environment.tag.CriticalTag {
    void MultipleCYKSimulateAction$5$1(MultipleCYKSimulateAction$5);
}

gui/action/MultipleCYKSimulateAction$5.class

package gui.action;
synchronized class MultipleCYKSimulateAction$5 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$5(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$6.class

package gui.action;
synchronized class MultipleCYKSimulateAction$6 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$6(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$7.class

package gui.action;
synchronized class MultipleCYKSimulateAction$7 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$7(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$8.class

package gui.action;
synchronized class MultipleCYKSimulateAction$8 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$8(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$9$1.class

package gui.action;
synchronized class MultipleCYKSimulateAction$9$1 implements java.awt.event.ActionListener {
    void MultipleCYKSimulateAction$9$1(MultipleCYKSimulateAction$9);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$9$2.class

package gui.action;
synchronized class MultipleCYKSimulateAction$9$2 implements java.awt.event.ActionListener {
    void MultipleCYKSimulateAction$9$2(MultipleCYKSimulateAction$9);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$9$3.class

package gui.action;
synchronized class MultipleCYKSimulateAction$9$3 implements java.awt.event.ActionListener {
    void MultipleCYKSimulateAction$9$3(MultipleCYKSimulateAction$9, javax.swing.JFrame, javax.swing.JRadioButton);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$9.class

package gui.action;
synchronized class MultipleCYKSimulateAction$9 extends javax.swing.AbstractAction {
    private static final long serialVersionUID = 1;
    void MultipleCYKSimulateAction$9(MultipleCYKSimulateAction, String);
    public void actionPerformed(java.awt.event.ActionEvent);
}

gui/action/MultipleCYKSimulateAction$MultiplePane.class

package gui.action;
public synchronized class MultipleCYKSimulateAction$MultiplePane extends javax.swing.JPanel {
    private static final long serialVersionUID = 1;
    public javax.swing.JSplitPane mySplit;
    public void MultipleCYKSimulateAction$MultiplePane(MultipleCYKSimulateAction, javax.swing.JSplitPane);
}