Z z z FutureBASIC

An industrial strength BASIC built for Macintosh

By Dave Kelly, MacTech Magazine Regular Contributing Author

Look! Up in the sky! It’s a bird, it’s a plane, no it’s FutureBASIC. Never before seen on this planet, FutureBASIC goes where no other BASIC has gone before. FutureBASIC (version 1.01) is not simply an upgrade of ZBasic. Although ZBasic programs can still be run with FutureBASIC, there are plenty of enhancements to interest any programmer, with any level of experience. I’ll refer to FutureBASIC as FB for the remainder of this article.

If you’re new to programming the Macintosh, FB now provides the easiest and quickest way to produce real Macintosh applications. Zedcor has put a lot of work into producing a set of manuals that not only provides documentation for the FB language, but also teaches structured programming methods. When getting started with FB you’ll want to start with the “Getting Started” manual. In this manual, you take a walk through three sample programs. You won’t even have to open any of the other manuals to start seeing results.

The “Getting Started” section emphasizes the importance of organizing and structuring your programs. Structure is something that doesn’t come natural to BASIC, but the FB manuals show you a consistent way to structure your programs. Programs are divided into sections split by remarks (see the example at the end of this article). A typical structured program will have a Constants section, Global variables section, Functions section and Main section. Zedcor, who has always promoted these programming practices, has done a great job in maintaining these structured practices.

After you go though the “Getting Started” manual, you’ll want to look at the FB “Handbook”. The Handbook will help you learn how to program the Macintosh. This manual isn’t just for beginners; there is information here that applies to all programmers. In particular, there are sections on writing INITs, cdevs, and Desk Accessories (yes, you can now create INIT, CDEV, DRVR and CODE resources), HyperCard XCMDs and XFCNs, how memory is organized, and Debugging (using FB’s Debugger and MacsBug). Beginners probably won’t start out writing INITs, but the manual includes everything you need to do it. The strength of the handbook is that it ties together the information that is in Inside Macintosh with the FB Reference manual. The Handbook is organized by subject (Windows, Menus, File Handling, Resources, QuickDraw, Etc.).

The “Reference” manual covers each FB command similar to the old ZBasic manual, but completely rewritten. It’s not like the Microsoft manuals that spend the first half of the manual explaining the programming environments (how the editor works, how to compile a program). Only the first 28 pages are dedicated to explaining the FB application, the remaining 375+ pages (plus appendixes) are strictly for reference. Each command is presented with a short example.

If you’re a Pascal, C, or Assembly language programmer (or any other language for that matter), FB will interest you too. First and foremost, FB is fast! It’s nearly as fast as Pascal and C. In benchmark tests that I performed, I was pleased with its performance in every test case I tried. The tests that I ran were derived from tests that I’ve run in the past. I’m not including those results here since there isn’t any close competition with FB anyway.

Experienced programmers will like the professional look and feel of the FB compiler. Some examples of this:

Resources are included in an FB program by including a one line statement such as:

RESOURCES “Resource File.rsrc”

The resource file can include any resources that you’re used to using in C or Pascal.

CALLs to assembled CODE resources - you can include any assembled code in your program.

In-line assembly language code: FB allows you to enter assembly language mnemonics directly into your program (THINK Pascal won’t let you do that!). Standard M68000 family statements and functions are fully supported.

APPL, INIT, cdev, DRVR, WDEF, CDEF, MDEF, CODE resource types can be created. This is what really makes FB a big league player. There are two different runtime packages that can get included at compile time when creating applications. You can choose the Standard-runtime package that takes up over 40K of space or the Mini-runtime version that is less than 5K. The difference is that the Mini-runtime must use Macintosh Toolbox routines for handling events. The reference manual distinguishes between the commands that are supported by the Mini vs. the Standard runtimes by putting a lower case m next to the command name. The extra memory saved may be worth it in some situations, but the expanded command set makes life much easier. Most of you will still want to compile with the Standard-runtime package. The RESOURCES statement at the beginning of the program tells the compiler which type of resource to compile.

Project Manager tool: FB’s Project Manager automatically keeps track of source code files used in a project. A project consists of all the files in a particular folder. The Project Manager makes it easy to open source code files and mark the files that need to be compiled. You can compile and run all related files in a project. So, if you have separated your various routines into separate files, then you can run the main program by selecting it in the Project Manager window and any files that are included (using the INCLUDE statement).

Cross Reference tool: The Cross Reference tool displays an alphabetical list of functions, labels, variables, or constants that are used in the current Editor window. You can search for an item by clicking on it.

Editing is completely new for this version of FB. The ZBasic editor was never as stable as this one. Most notable is that keywords are recognized and indentation is applied to the source code automatically. You can adjust the spacing for indented lines using the preferences dialog. Full Search and Replace capability can search in both directions. When an error occurs in your program, the cursor points to the line where the error occurred.

The Help system provides a ready reference to all FB commands. An additional bonus is that sample source code is included with the information in the Help file that you can paste into your program. You can even add your own stuff to the Help file.

Page Layout can be customized to print source code with header, footer, date, Program Name, page numbers, boldface keywords, and automatic indentation.

LOCAL FN is a new statement that lets you pass a list of parameters to a subroutine that will only be used locally. That means that variables used in LOCAL FN routines are only defined within the subroutine. You can now use libraries of LOCAL FN routines and not have to worry if there is a conflict between your program’s variables and the subroutine’s variables. LOCAL FN is a very powerful statement that can also be used recursively. LOCAL FN virtually makes using GOSUB and LONG FN obsolete (GOTO was obsolete along time ago). FB still supports GOSUB, GOTO, and LONG FN, but you are strongly advised against their use because of the great benefits of LOCAL FN.

Constants are now presented in a consistent manner. In older versions of BASIC only numbers could be used for constants. In FB you can assign integer and long integer constants a name to make them easier to remember and more understandable. You can tell a constant because it always starts with an underline character. Besides the fact that you can define your own constants, FB comes with hundreds of predefined named constants. Many of them correspond to constants in Inside Macintosh.

Record types are defined using the DIM RECORD statement. Any record type in Inside Macintosh can be defined with this statement. Records can be passed between functions by passing the record’s address.

QuickTime™ movie calls are included for playing QuickTime movies.

Balloon and Apple Event calls are part of the extensive Macintosh Toolbox support. However, the manuals show you how to create your own calls just in case Apple adds a new one.

Word Solution Engine™ functions are build in to FB as USR functions. Word Solution Engine is NOT included with FB. You can use these routines to access Word Solution Engine (if you have it) to create a professional looking word processor.

Debugger: FB’s own debugger is great. If you like the debugger in THINK Pascal, you’ll like this one too. You can set break points and step through a program. You can follow variable changes as they happen.

There are simply thousands of features packed into FB. I’d love to be able to show you a sample of each, but Zedcor has done a great job of that on the example files included with FB. I will include one here that can give you a sense of what FB can do. In particular, the ability to create cdevs is one of FB’s new features. The following code is an example of a cdev (from Zedcor).

‘CDEV example     7/07/92
RESOURCES “FB CDEV.rsrc”,”cdevhack”,”cdev”,-4064,”FutureBasic™ CDEV”,_resPurgeable%
OUTPUT FILE “myCDEV”

‘--------------- Globals ------------------
BYEBYE = _false
END GLOBALS

‘--------------- Functions -----------------
LOCAL FN doKeys (theEvent&)
  ‘first, get the character
  message&   = [theEvent&+_evtMessage]  
  ‘then see if the command key was down
  modifiers% = {theEvent&+_evtMeta}     
  tempChar$  = CHR$(message& AND &FF)  ‘mask for character
  LONG IF modifiers% AND 256           ‘test for command key
    %theEvent&,_nullEvt
    SELECT tempChar$         ‘set appropriate message
      CASE “X”,”x”             ‘cut?
        message% = _cutDev     ‘pass menu event back to cdev
      CASE “C”,”c”             ‘copy?
        message% = _copyDev    ‘pass menu event back to cdev
      CASE “V”,”v”             ‘paste?
        message% = _pasteDev   ‘pass menu event back to cdev
      CASE “Z”,”z”             ‘undo?
        message% = _undoDev    ‘pass menu event back to cdev
      CASE “W”,”w”             ‘close window?
        BYEBYE = _true         ‘pass menu event back to cdev
    END SELECT                  
  END IF
END FN

‘is it time to go bye bye?
LOCAL FN checkBYEBYE(cdevStorage&)
  LONG IF BYEBYE                       
    LONG IF cdevStorage&             ‘valid handle?
      mErr= FN DISPOSHANDLE (cdevStorage&) ’dump it
      IF mErr THEN BEEP:BEEP:BEEP
    END IF
    END
  END IF   
END FN          

LOCAL
DIM rect;0, T,L,B,R
LOCAL FN showMsg (msg$)
  CALL SETRECT (rect,110,110,220,160)
  CALL ERASERECT(rect)              ‘erase last message
  PRINT%(L+(R-L)/2-24,T+(B-T)/2+4);
  PRINT msg$;                       
END FN                    

‘---------------- Main ------------------
ENTERPROC%(message%,item%,numItems%,CPanelID%,
  theEvent&,cdevStorage&,CPDialog&)
  ‘softmask =&0000 and hardmask = &FFFF
  LONG IF message% = _macDev  
    returnVal& = 1               ‘works on every machine
    lastPass& = cdevStorage&
  XELSE
    LONG IF cdevStorage& <> lastPass&   ‘
      SELECT cdevStorage&  ‘check for errors when the 
        CASE _cdevGenErr   ‘Control Panel sends them to you.
        CASE _cdevMemErr
          ‘do an error message
        CASE _cdevResErr
          ‘do an error message
        CASE _cdevUnset
          ‘ignore this
      END SELECT
    END IF
    LONG IF cdevStorage&       ‘inialize storage for cdev
      lastPass& = cdevStorage&
      SELECT message%
        CASE _initDev          ‘initialize cdev
          ’create private storage
          cdevStorage& = FN NEWHANDLE(2)
          ‘we work on every machine
          returnVal& = cdevStorage&  
        CASE _hitDev          ‘button or text field clicked
          ’subtract Control Pan items
          msg$= “_hitDev item=”+STR$(item%-numItems%) 
          FN showMsg (msg$)
        CASE _closeDev        ‘close down the cdev now
          BYEBYE = _true                  
          FN showMsg (“BYE!”)
          BEEP :DELAY 1000
        CASE _nulDev                 ‘do null events here
        CASE _updateDev              ‘update your stuff
          FN showMsg (“_updateDev”)
        CASE _activDev               ‘activate controls 
                                     ‘deactivated below
          FN showMsg (“_activDev”)
        CASE _deActivDev             ‘deactivate controls
          FN showMsg (“_deActivDev”)
        CASE _keyEvtDev              ‘respond to key down
          FN doKeys (theEvent&)
          FN showMsg (“_keyEvtDev”)
        CASE _undoDev,_cutDev,_copyDev,_pasteDev,_clearDev
          FN showMsg (“__someEditDev??”)
        CASE _cursorDev              ‘cursor over cdev area
      END SELECT
    END IF
  END IF
EXITPROC% = returnVal&
FN checkBYEBYE(cdevStorage&)
RETURN

For More information

Contact Zedcor, 4500 E. Speedway, Suite 22, Tucson, AZ 85712. Voice: 602/881-8101, Fax: 602/881-1841, Applelink: ZEDCOR.