Uni IDE
Stephen Walter
Revised 2/13/08
Uni IDE
Description:
Uni IDE stands for Unverisal Integrated Development Environment. This is a
program idea built around the Back—Naur Form (BNF) which provides a code editor to
any computer language. Most highend IDEs are built specific to one or few standard
languages, so this software fills in that gap using only the BNF language definition.
There are some similar editors that handle multiple languages, but they lack the features
from the more prestige editors. Uni-IDE supports these features, including tools to
markup keywords of other languages, and parsing required for checking for all grammar.
The target audience is for any small size programming group that uses a non-standard
language for a specific problem. It will help cut development time wasted on bad
compiles as well as nitpicking through code.
The software will act as a tool for writing code for any language provided it is
given a Backus—Naur Form grammar in the form of a text file. The software will use
the BNF to construct the language’s grammar. This will then be applied to the code to
scan for mistakes while the user is typing it out. It should also be to identify user created
variables and the type associated with it. The IDE can act as a strongly typed parser,
even if the language does not support strongly typed objects. The grammar should also
support auto completion feature that provides matches that will fit the grammar and type.
Image of how the editor looks
Features:
- Multitab editor
At the very heart, Uni IDE is your coding editor. It comes with all the standard
word processing features. A multi-tab window for all code files is at the center of the
program. This allows quick access between several files without having to deal with
cluttered windows across the screen. All tabs may be quickly closed and saved at once.
In addition, Uni IDE remembers which files were last open and will launch them the next
time you run the program. The frames may also be used in a split view to allow viewing
of a single code file in two positions.
- Abstract grammar
BNF grammar is the main feature of Uni IDE. Using just a simple text document,
Uni IDE understands the grammar of the language. This allows the program to scan
through code files to ensure that code follows proper grammar. When any illegal
definition is found, Uni IDE will mark the line with red to indicate that the code will not
compile at that point. By mousing over the area, a tool tip provides reasoning for the
error. A full scale grammar view of the code may be accessed by menu, which will
remove the user defined text and display in a tree fashion.
- User defined values
By studying the user written code with its grammar, Uni IDE may also pick up
user-defined functions and variables. This enables the editor to show a list of the
currently declared functions and variables in a side panel. The program tracks the types
that objects are declared as. The editor may then issue warnings about incorrect usage of
these values. For languages with weak type, Uni IDE attempts to determine the first use
of the variable where the operation is limited to a particular class.
- Autocompletion
While writing code, Uni IDE can produce a list of possible auto completions.
These auto completions use the grammar and user variables to determine what code could
possibly fill out the end of the line of code. This feature is offered in a menu that appears
on the side, as to not block view of the code.
Example from part of the language Lua’s BNF:
chunk ::= {stat [`;´]} [laststat [`;´]]
block ::= chunk
stat ::=
varlist `=´ explist |
functioncall |
do block end |
while exp do block end |
repeat block until exp |
if exp then block {elseif exp then block} [else block]
end |
for Name `=´ exp `,´ exp [`,´ exp] do block end |
for namelist in explist do block end |
function funcname funcbody |
local function Name funcbody |
local namelist [`=´ explist]
laststat ::= return [explist] | break
funcname ::= Name {`.´ Name} [`:´ Name]
varlist ::= var {`,´ var}
var ::=
Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name
namelist ::= Name {`,´ Name}
explist ::= {exp `,´} exp
exp ::=
nil | false | true | Number | String | `...´ | function
|
prefixexp | tableconstructor | exp binop exp | unop exp
binop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ |
`<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ |
and | or
unop ::= `-´ | not | `#´
Source: Lua 5.1 Reference Manual Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes.
2008. <http://www.lua.org/manual/5.1/manual.html>
Implementation:
The program is written using Java, using several of the pre-existing classes to
handle the GUI elements for Uni IDE. The program is structured according to the
Model-View-Controller (MVC).
- Model
There are three elements in the model of the program. The first is the BNF
document. The user provides a text file using the standard context-free-grammar to
describe with the first definition as the starting root of the language. The BNF stored in a
class object containing its name, definition(s), and connection to other definitions. The
second model holds the actual code documents that the user will be editing. This object
is mostly handled through java API for reading and writing to a buffered file. The final
object is the parsing of the user code. This stores a tree of the grammar names, which
definition was used, variables local in the branch, and a reference to all the other names it
used.
- View
The view puts into the java GUI into its working format. The core frame of the
GUI consists of its menu bar on top, the multi-tab editing frame in the center, variable
and functions as a list on the sidebar, and a lower text status area for the responses. The
menu consists of standard bars like File, Edit, View, and Options. File will open, save,
close, and print files. Also includes save all, close all, and open recent. Edit will host the
cut, copy, paste, find, and replace features. View will aid in selecting tabs and showing
the abstract tree of the code. Options will allow the change of visual preferences, such as
font, and allow the loading languages.
The editor frame is a mutli-tab frame. The tab contains the file name and a close
button, whereas the interior holds the stylized text window. The text window uses the
Java API for tracking undoes and formatting. File size and cursor position are shown in
labels at the bottom of the frame. Variable list to the left sidebar is a simple list structure
in a frame. The bottom area for status is a simple multi-line text box.
- Event
The event class handles all the gui events. The menu commands to their relative
file operations, as well as the text editing changes to the documents in the edit frame.
The edit events parse through the code of user document (either fully or partially) and
attempt to create the model of the code. Any failure will prompt for a stylized text
modification to show the error and print the results on the status bar below.
Project Budget:
The budget will require spending on a computer and its own developing tools,
which should come out to around 9000. The office space for a small place at around $20
per square foot should come to about 2000 per month. Salaries for a single developer
using an 40 hour week at $87 per hour comes to 14000 a month. Utilities to cover
electric, plumping, and internet should be around 300.
Project Budget for 3 months
9000
Equipment
6000
Office
42000
Salaries
300
Utilities
57300
Total
Timeline:
Week 1: Design development with working basic text editor
Week 2: BNF parser
Week 3-4: Editor parser for BNF data
Week 5: UI development and formatting of text editor
Week 6: Variable/function tracking, strong type support
Week 7-8: Testing and twinking