 |
http://unicon.org/utr/utr12.html Department of Computer Science University of Idaho Moscow, ID 83844 |
Clinton L. Jeffery, Hani Bani-Salameh, Sean Harris,
Benjamin L. Jeffery, Shea Newton, and Serendel Macphereson
May 22, 2015
Unicon Technical Report #12a
Abstract
|
http://unicon.org/utr/utr12.html Department of Computer Science University of Idaho Moscow, ID 83844 |
Even Ui's very "simple" goals are complicated by the fact that the tool needs to run on any machine where Unicon runs with graphics facilities enabled. At this time, this primarily consists of UNIX-based systems that run the X Window System, such as Linux, Solaris, Mac OS X, and Microsoft Windows-based machines. There is a practical minimal screen resolution limit, probably around 800x600 for this tool.
Ui is a product of the Unicon Project and is a standard part of the
Unicon programming language distribution, developed under the GPL, hosted on
Source Forge, and downloaded from http://unicon.org.
If you are not already familiar with Unicon you may wish to consult
other technical reports from that site, such as UTR #7[2], along with
this one.
Windows Unicon and the Ui environment are based on
the volunteer work of many people; final responsibility for this release
rests with Clinton Jeffery of University of Idaho.
Send requests, and bug reports to
jeffery@cs.uidaho.edu.
2. Editing, Compiling, and Executing Programs
Double-click the Windows Unicon icon to launch Ui, the Unicon IDE
(integrated development environment). Ui is written in Unicon and
allows you to edit, compile, and execute programs from a graphic user
interface. Ui is designed to run the same on UNIX and Linux as it does on
Windows. Ui's documentation (this file) may be accessed on-line through
its Help menu.
To start, you must select the name of a file to edit, in following dialog:
You can easily select an existing Unicon source file, or name a new one.
If you click "Open" without choosing a name, you will be given the default
name of "noname.icn". Unicon source files generally must use the extension
.icn and should be plain text files without line numbers or
other extraneous information. Editing your program occurs within the main
Ui window, which might look like this:
The top area shows program source code, while the bottom portion shows messages such as compiler errors. You can change the font and the number of lines used to show messages from the Edit menu.
When you are done editing your program, you can save it, compile it, or just "make" (save, compile and link an executable) and run your program with menu options. The Arguments command in the Run... menu let's you specify any command-line arguments the program should be given when it is executed.
 |
|
The search text-field is bracketed by two buttons: a find button on the far right edge which initiates a search, and a direction toggle button to the left of the search text-field that changes the direction of the search.
For more substantial search tasks, the Find & Replace dialog accessed from the Edit menu supports case-insensitive, backwards, and regular expression searching.
Run-time errors also result in a message for which the source line is
highlighted. The message for a run-time error includes Unicon's standard
traceback of procedures from main() to the procedure in which
the error occurred. When the error messages get long, you can either
increase the number of lines for the message window (as was done here) or
scroll through the message window's entire text using the scrollbar.
Ui works on programs comprised of one or more source files. A project is Ui's abstraction of a program, consisting of the program name, working directory in which it is built, and set of source files and their dependencies on other files. By default, Ui takes it that it is working on single file project consisting of the current source file. If you are working on a single-file project, and you open a new .icn source file, Ui switches the editor and compile and link commands to work on this new program.
Ui project files are Makefiles, given the extension .Makefile. The format of Makefiles is described in documentation for one of the widely used "make" programs such as GNU make (see for example www.gnu.org/software/make/). You can write your makefiles by hand, but in order for Ui to keep things straight, you had better stick closely to the format that it generates for you when you create a New Project. The dialog for creating a project let's you specify the set of source files and their dependencies for a Unicon program.
When you open a project file, Ui goes into "project mode", and adds the source files and their dependencies to your Class Browser allowing you to switch easily between files relevant to your project. If you subsequently open a source file not in the project, Ui asks if you want to add that source file to the project, or edit that file as a separate program. In general, project files allow you to "make" large projects efficiently. Underneath the covers, Ui invokes the other Unicon program executables to do the work of compiling and running programs, described below.
When Ui "makes" a program executable, it recompiles those modules listed in the project file whose modified time is newer than their corresponding object files. Ui does not present consider link declarations embedded in source files, which generally are used for library modules; recompilation will not be triggered by such dependencies. When you use Ui, you should generally use link directives for library files (such as Unicon Program Library modules), and use explicit project file entries for all of your own source files. Files detailed in the .Makefile must not also be referenced in a link statement; linking the same module twice causes link errors. For projects, the executable that is produced and the project itself are named after the first program in the project file unless otherwise specified.
Additionally, if it is not a word, or it is not a known function, a popup menu briefly decribes the right-click functionality. Currently this feature is limited to exact name variables. An instance of a class or function name would not be recognized as a known function e.g.
x := foo()Future work may include expanding the range of known functions to include these additional instances. Other possible additions may be an extension of the tooltip class to include a subclass for right-click events which would be utilized here in place of the descriptive popup menu. This would allow for a more detailed description. Having the word under the cursor defined allows for the possible addition of a highlighting feature or a "find all usage" feature.
The IDE supports the ability to modify the desired font and make changes to the Ui layout and color scheme. The visible view-ports can be adjusted by selecting Window from the View menu; furthermore the tool bar can be displayed/hidden by choosing the appropriate option from within same View menu. The font settings and the Ui preferences can be accessed from the Config menu by selecting Font and Preferences respectively.
From the Preferences dialogue, parentheses matching can be disabled and various colors can be adjusted for a desired look.
Once a desired look and layout have been achieved, the above mentioned settings, as well as the position of the Ui and the window width/height can be saved under the Config menu. These settings may manually be specified in a file called _uirc that is read when the IDE starts up. The _uirc resides in the current Ui directory, unless a specified HOME or LOCALAPPDATA environment variable is set, in which case it is taken to be the path-name of the initialization file that Ui is to use. An example _uirc file follows:
position=105,23 width=1770 height=1050 window_setup=view_window_all toolbar_status=show msglines=7 font=Comic Sans MS,24,italic,bold linebreak=LF val_background_color=white linenumber_highlight_color=white default_text_color=black cursor_highlight_color=black cursor_text_color=white syntax_text_color=dark-blue-green glob_text_color=dark-green procedure_text_color=purple quote_text_color=light-brown comment_text_color=blue linenumber_text_color=grey text_highlight_color=light-grey error_text_color=red parentheses_match=1
Many Bothan spies died to bring us this information. -- Mon MothmaIn the early 1990's, a prominent member of the Icon community (Bob Goldberg, if I recall correctly) did a rough prototype IDE for Icon on Windows, which whetted our appetite for this category of tool. An M.S. student at UTSA, Steve Schiavo, did a second prototype IDE in Borland Delphi. These efforts featured basic editing, compiling, and executing but were not feature complete and never released.
Clint Jeffery ported Icon's graphics facilities to Windows at UTSA, as part of his agreed contribution for the book "Graphics Programming in Icon"[3]. An IDE (along with a setup.exe installer) was considered essential for the Windows Icon distribution. In order to minimize external language- and compiler-dependencies, and in order to test and demonstrate the functionality of Windows Icon, Jeffery implemented an IDE similar to Steve Schiavo's in Icon as a program called Wi (Windows icon). In order to provide an attractive, native-looking GUI, Windows95 native dialogs (the Win* functions) were added to the language specifically for use in Wi. The Wi program was modified slightly to form Wu (Windows unicon) when that language was invented.
Although the Wu program was nice, it was limited to only run on Windows, and made extensive use of Windows-only native GUI functions. Even on Windows it had some nasty limitations, such as a 32kb file size limit imposed by the classic native windows text editor widget. After Robert Parlett contributed his wonderful GUI class library, which supported fonts and colors, it became ever more desirable to build a Unicon IDE that would run on all Unicon platforms. Bryan Ross's RUDE (Ross' Unicon Development Environment) was an attempt to address the multi-platform requirement in prototype form.
Finally, the Ui program was developed by Clint Jeffery, using Parlett's IVIB interface builder and adapting code from Wu. Unfortunately, various elements of Wu were not replicated immediately in Ui, and it has only gradually progressed towards a complete or usable feature set. Its toolbar was added by Nolan Clayton, who also made various improvements to its visual appearance. Syntax coloring was added by Luis Alvidrez. Hani bani Salameh ported it to version 2 of the GUI classes. It is by now the work of several people, and remains very small and lacks features compared with mainstream IDE's. However, it continues to evolve.
The contextual help on right-click feature was added by defining the word under the cursor, creating tables for known functions, searching the tables for a word, incorporating jump-to methods and a popupmenu on right-click.
The following is the framework for the use case of this functionality
The first thing that happens after a user right-clicks within the Ui Editor is the text under the cursor is compared against the definition of a word. A word is defined as a set of characters not containing a specific character: whitespace, tab, period, etc. It expands its collection of characters in both directions, starting with the character directly under the cursor, and continues until it finds one of those characters.
The code which collects the word under the cursor is described here:
editBuffer := ide.CurrentEditBox().get_contents()
line := editBuffer[ide.CurrentEditBox().cursor_y] | []
x := ide.CurrentEditBox().cursor_x | []
non_whitespace := &cset -- ' \t' -- '(' -- '.'
if any(non_whitespace,line,x) then {
while x > 1 & any(non_whitespace,line,x-1) do {
x -:= 1
}
end_of_word := many(non_whitespace,line,x)
the_word := line[x:end_of_word]
}
The function returns the word or a -1 if it was not a word.
The known functions are defined in two tables. The built-in functions are loaded into a table from a list of function names. The user defined functions are loaded into a table by means of a recursive call to the classbrowser tree which contains the function names and line numbers of that project file. The call to the recursive function is here:
method treeRecursion(N)
local t
every t := 0 to *N.subnodes do {
treeRecursion(N.subnodes[t])
}
if not (N.label[-4:0] == ".icn") then {
if not member(usr_func_table, N.label) then
insert(usr_func_table,N.label, N.lineno)
}
end
Once a word is defined, it is looked for in the known function tables. If it is a match it is sent to a jump-to function.
Depending other whether the function name was a user defined or a built-in, it will call a jump-to method for that respective type.
The built-in jump-to function utilizes a method which opens a browser at a specified web address. In this case it opens the unicon technical report 8, which contains definitions of all the built-in functions and their uses. Each function name contains an anchor which will allow the browser method to open the web page at the correct location.
If no internet connection is available, it loads up the UTR8 from the source file on the computer.
If it is a user defined function it moves the cursor to the line number where the function is defined, if it is located within the current project file.
2. Clinton Jeffery, Version 11 of Unicon for Microsoft Windows, http://unicon.org/utr/utr7.html, 2006.
3. Gregg M. Townsend, Ralph E. Griswold, and Clinton L. Jeffery, Graphics Facilities for the Unicon Programming Language Version 9.3, The Univ. of Arizona Icon Project Document IPD281, 1996.