Wars and Windows
|Column Tag:||Basic School
Basic Wars and True Windows
By Dave Kelly, Editorial Board
Basic Wars Revisited
I promised more information about True Basic. First I would like you to refer back to MacTutor August 1986, February 1987 and March 1987 for the previous episodes of Basic Wars. The following table gives True Basic (Version 2.0) data for most of the benchmarks used to compare ZBasic and MS Basic 2.0 the last time I ran the benchmark. Please be aware that the math operations were corrected in the March 1987 issue. From a comparison of the benchmarks we can draw a few conclusions. First, True Basic appears to be faster for all math operations even though True Basic is not truly compiled. Only Microsoft Basic (binary) is comparable in math speed, but does not include the accuracy of True Basic. Graphic operations are slower than the MS Basic interpreter. Array look up was comparable to compiled speeds for MS Basic or ZBasic. String handling approaches ZBasic compiled speeds. True Basic ran the Sieve in less time than the MS Interpreter, but slower than any of the compiled Basics.
Still keep in mind that benchmarks are not the only way to determine the strengths of a language. These results show that True Basic performs very well considering that it is not truly compiled to native machine code. It would be much more of a speed competitor if it was compiled. True Basics strengths are in other areas which cannot be measured only by benchmarks. To some people the other capabilities of True Basic are not enough to justify the slow speed. If the only thing you are looking for in a language is speed then youll probably be disappointed.
True Basic Benchmark: System 6.0
BENCHMARK Macintosh Plus Macintosh II
FOR Loop 1.6 sec. .388 sec.
Array Lookup 20.67 sec 5.25 sec.
Addition 22.15 sec. 3.8 sec.
Subtraction 23.23 sec. 3.55 sec.
Multiply 25.55 sec. 3.8 sec.
Divide 39.15 sec. 3.78 sec.
Concatenation 10.3167 sec. 2.35 sec.
Matching 12.15 sec. 3.12 sec.
61.25 sec. 15.33 sec.
Horizontal line 38.867 sec. 12.3 sec.
Circle 13.4667 sec. 6.63 sec.
Set Pixel (PLOT) 119.3 sec. 37.83 sec.
File I/O (Floppy disk)
Random READ 24.5 sec. 8.2 sec.
Random WRITE 43.48 sec. 13.7667 sec.
Sequential PRINT #17.0667 sec. 4.3 sec.
Sequential INPUT 17.45 sec. 4.533 sec.
Sieve (1980 primes) 118.917 sec. 29.0333 sec
Answer: 503.543802149746 503.5438021499906
.88333 sec. .166667 sec.
Some of True Basics strength comes from the structured nature of the ANSI committee standard which it closely follows. Rather than go through a blow by blow account of what each command in True Basic does (you can always read the manual to find out that), Ill tell you whats new since version 1.0 was released. Mostly True Basic is the same very structured, capable language as before. From a scientific, engineering and educational standpoint True Basic offers the best learning environment. It has all the advanced structures of the latest Basics available such as SELECT CASE, DO/LOOP with WHILE and UNTIL, and multi-line IF/ELSE IF/END IF. True Basic is modular in that you can define your own modules which can be loaded as required. Local and global variables are supported. As discussed last month, True Basic has a full set of matrix algebra statements. Arrays are dynamic and resizable. Line numbers are now optional. Recursion is supported. Optional variables may be declared in CALLs.
The built-in editor works very well (unlike the ZBasic editor). It is not the best editor in the world, but is adequate. You have search and replace (Find and Change) and Include (which inserts a file from disk at the cursor point). The annoying little stop light (version 1.0) has been removed. You may select breakpoints in your program where you want to suspend execution to examine variables or do debugging. There are three windows that are used in the interpreter environment. The source window contains the source code, the output window lets you save output from several runs of the program if you want, and the command window lets you type commands specific to managing the interpreter (Actually, True Basic is compiled to b-code for extra speed, but since it is not true native machine code I hesitate to call it a compiler). You can use almost any True Basic statement in direct mode, that is, directly typed into the command window. A simple help system is available, but I feel that unless you are a beginner, the help system is next to useless.
Script files and DO programs can be set up to configure True Basic or to automate actions. Its sort of like having a a set of exec files that can be executed as short cuts. Since there may be several folders containing library files used, you will want to configure your disk with a TBStartup file containing an ALIAS statement which references all of the places you want True Basic to look for library files. This is a very awkward way to do things, but once it gets set up you just declare your library and True Basic takes care of things for you. (Sort of reminds me of what I dont like about MSDOS). DO programs are used for things such as formatting the source code, getting a cross reference list of variables, or tracing a programs variables. Since you can always write your own DO program you can set it up however you wish.
True Basic supports the 68881 coprocessor which speeds up calculations quite a bit. Weve already seen samples of True Basic color capabilities in previous issues of MacTutor.
Macintosh people want their applications to look right and feel right for the Macintosh user. True Basic provides a library MacTools* which contains most of the simple graphics calls:
call MacPenSize (width, height)
call MacPenMode (mode)
call MacTextFont (font)
call MacTextFace (style$)
call MacTextMode (mode)
call MacTextSize (size)
call MacTextBox (left, right, bottom, top, s$, just$)
call MacSpaceExtra (extra)
let n = MacStringWidth (s$)
call MacGetFontInfo (ascent, descent,widmax, leading)
call MacInvertRect (left,right,bottom,top)
call MacPaintOval (left,right,bottom,top)
call MacInvertOval (left,right,bottom,top)
call MacFrameRoundRect (left,right,bottom,top,x,y)
call MacPaintRoundRect (left,right,bottom,top,x,y)
call MacInvertRoundRect (left,right,bottom,top,x,y)
call MacSysBeep (duration)
call copy_pictfile (filename$) supports PICT2 format
These are basically the same sort of commands available to MS Basic users as built in statements. Other statements for printer control are also included in MacTools* library. True Basic file handling is done using the file names with colons separating the volume names. If the more preferred method of using volume numbers is desired then you should plan on using Mac ROM calls.
The Macintosh Developers ToolKit supplies the rest of the Macintosh interface. The libraries included in the ToolKit include:
TrueWindows* True Windows
ExecLib* Semi-portable system routines
HexLib* Integer arithmetic aids
System* Low-level interface to System
MacLib* Trap interfaces for other libraries
DataLib* Data conversion for ToolKit routines
ColorLib* Color manager
PickerLib* Color picker package
ControlLib* Control manager
DeskLib* Desk accessory manager
DialogLib* Dialog manager
DiskLib* Disk driver
DiskInitLib* Disk initialization package
EventLib* Toolbox/System event managers
FileLib* File manager
FontLib* Font manager
ListLib* List manager
MenuLib* Menu manager
PackageLib* Package manager
PaletteLib* Palette manager
ResourceLib* Resource manager
ScrapLib* Scrap manager
SFPlib* Standard file package
SoundLib* Sound manager
SystemLib* System utilities
TextEditLib* Text edit
ToolboxLib* Toolbox utilities
WindowLib* Window manager
As in version 1.0, some calls cannot be mixed with some True Basic commands (especially graphics) very easily. However, this is really not to bad considering the problems weve run into with ZBasic and keeping Macintosh events separate from ZBasic events. Also, the Developers ToolKit now provides some easy menu and window statements for simple applications. They call this set of routines, TrueWindows.
INTRODUCING TRUE WINDOWS
At first it doesnt seem to make a lot of sense to even have the TRUE WINDOWS library available, but in a pinch when you need a quick and dirty application (what Basic is used for the most often), it is good to not have to set up the GetNextEvent Loop. True Windows gives you access to menu, dialog and alert, event handling and window routines. An example using True Windows is included with this column.
True Windows menu statements are set up with DATA statements. The MAT statement makes it easy to read in the entire menu in one statement. The array containing the menu is dimensioned as DIM menu$(0:menus, 0:items) where menus is the number of menus and items is the max number of menu items in any one menu. This set up is fairly simple and easy to use.
A set of 5-6 types of dialog/alert boxes are available. You can also set a timeout for the dialog box so that if there is no user response the program will continue. Using that function is not recommended by the Macintosh user interface guidelines because it allows something to happen which the user has no control over and does not expect to happen.
A True Windows event handler returns menu,refresh, window selection, close box events, window move events, window resize events, up, down, left, right, pageup, pagedown, pageleft, pageright, vscroll, hscroll, single click, double click, triple click and mouse down events as only as often as you ask for them. True Windows or True Basic does not go out and do a GetNextEvent just for the fun of it which in turn messes up your own event handling.
While it is true that True Windows does not do everything, it is a way to get Macintosh looking interfaces without a lot of extra work. If it doesnt handle the job then the rest of the Developers Toolkit is sufficient to handle any other jobs that might come up that require the Mac ROM routines. And if Apple comes out with a new call some day it is very simple to go in and add the call yourself just by examining the source code for the Toolkit libraries. The copy of Developers Toolkit that I have is a prerelease copy, but it appears to be complete in every way.
The hardest thing about using any library is to know the routines that need to be declared in the DECLARE DEF statement so that they can be used in your program. All external functions must be declared. However, the LOAD statement could be used to make the library become a part of the Basic language and thus the DECLARE statement would not be necessary.
Ok, so we know that True Basic can do all this stuff, should I use it for my development project? The answer to this has to be answered yourself, but you should ask your self the following questions:
1. Does my program need to run fast? True Basic speed is satisfactory for many needs, but there are some things that must run faster.
2. Do I care if my application program is greater than 73K? The runtime package uses 73K of disk space. About 35 K of that is in the resource fork of the file and may be shared by more than one application by cutting the resources from the application and pasting into the system file. This is not the preferred method, but could be done if necessary.
3. Do I have a lot of math operations to perform? True Basic is extremely strong in its math support. This is especially true on the Mac II which also includes 68881 math coprocessor support.
4. Do I want full access to the entire Macintosh ROM routines? The Developers Toolkit does a great job of supporting all of the ROM routines in a way that can be understood. It is easy to add new ROM calls as they are added in the future. You wont have to wait for True Basics next upgrade to have support of the new features. It would be nice if the ROM support was built into True Basic, but by loading the Library into memory it can become a part of True Basic. Besides, even Lightspeed Pascal requires that Libraries be declared (in the project window) in order to use them.
In my opinion, True Basic has come a long ways by including the runtime package with the Basic system. I would like to see the Developers Toolkit bundled with the language system, though the price would certainly be near the same price anyway. Currently, the True Basic language system, including Runtime is $99.95. True Basic libraries are $69.95. This makes the combined package cost $169.90. There are only two areas that I wish could be improved upon with True Basic. One would be to have a true compiler that produces real machine code instead of the b-code stuff. I realize that the b-code is designed to be able to transfer applications in True Basic to other computers. As a matter of fact, True Windows routines are supposed to be transferable to other computers such as the Amiga (gasp) which use a window approach. The other area that could improve is in the code size of the runtime package. Some of the size problem could be eliminated if a true compiler were available, that is if it compiled the code efficiently.
!Color Picker Demo
!Demonstrates True Basics True Windows and
!illustrates use of the Color Picker routine
!By Dave Kelly
LIBRARY datalib*, maclib*, system*
DECLARE DEF H,V,GetColor$,UnpackEnvirons$,RGB$
! Color isnt supported yet, but Im ready for it!
! Find out what kind of computer this is
CALL UnpackEnvirons(sysEnvRec$,envversion,machine,sysversion, processor,
IF hasColorQD<>1 then
! we gotta quit, this isnt a Mac II
CALL tw_dwarn(3,Color Quickdraw is not available!
Sorry, but you cant run this !,OK,1,result)
IF done<> true then
MAT READ menu$
DATA ,About MacTutor Picker Demo...,
DATA File,Get Picker...,Quit
CALL tw_menu_set(menu$) ! Set up the menu
SELECT CASE type$
SELECT CASE menunumber
LOOP Until Done=true
! Get rid of the menus
! clean up all the TrueWindows stuff
! Set up the About dialog box.
CALL tw_dwarn(0,MacTutor Picker Demo|©1988 MacTutor|By Dave Kelly,OK,1,Result)
SELECT CASE menuitem
! Set up the upper corner of picker dialog
! do picker dialog
CALL GetColor(point$,Pick a color, just for fun!,inrgb$,outrgb$,okflag)
! select the color
IF okflag=1 then LET inrgb$=outrgb$
LET string$=Color selected was:|r=&str$(r)&|g=&str$(g)&|b=&str$(b)
! Display the color in rgb coordinates