Symantec C++ v8.0 is Here!

New Native Power Mac & 68K Development Environments

By Rich Parker, Modesto, CA

The New, Native Symantec C++

The new Symantec v8.0 product is a complete, native Power Macintosh and 68K development suite. While 68K development still uses the THINK Project Manager (TPM) development environment, the environment for native Power Macintosh development is completely new and improved. The Symantec Project Manager (SPM) has been completely rewritten for the Power Macintosh. It supports multiple, nested projects, gets rid of the ugly segmentation issues that prevail in 68K development environments, and provides very fast compilation and linking. The new SPM provides a full set of options that allow you to specify the settings for building suites of applications, with multiple, nested projects, as well as static or shared libraries. The two environments (SPM and TPM) share the same source libraries and TCL.

In addition to the new native Power Macintosh development tools, the Symantec C++ v8.0 product also includes a complete 68K development environment and associated compilers, source level debugger, and other tools. However, the remainder of this article focuses on the native Power Macintosh tools.

Figure 1. The Project Manager Window

The New Project Window

The project window for the new Power Macintosh development environment is shown in Figure 1. This illustrates a view that includes individual folders in which the various sets of source files are listed. When you create a new project, the SPM places the relevant files for the type of project you’ve chosen into various folders. The figure shows part of the organization for a TCL project.

Each of the folders has a control that when clicked toggles the list of files (or other folders) it contains from being shown or hidden. Being able to hide all of the extraneous files is a big help, particularly when you’re developing an application that contains many of its own files. Folders can be nested to any depth, so you can group your own source files into various categories and then open only the ones whose contents you wish to see at any particular moment. For example, the entire THINK Class Library is held in a folder with nested folders for the various categories of source files.

In addition to organizing files within folders, the SPM includes “Project Window” options that show whether individual files need to be recompiled, as indicated in Figure 1. The diamond indicator at the left of each file name is filled in when a file needs to be recompiled. The SPM is very intelligent about tracking dependencies. If you change a header file that various other files depend upon, then all of the affected files will have filled diamonds next to their names.

The right side of the project window, immediately to the left of the vertical line, shows the debug status of the individual files, if this option is chosen from the “Project Window” options. If you wish for debugging information to be kept for a file, you can click on the diamond to its right and cause the compiler to save that information for later use.

The project window can display a number of different types of information at its right side. Each new set of information is assigned a column. Figure 1 shows only the code size, but you can also display additional information by checking the various checkboxes in the “Project Window” options, as shown in Figure 2.

Figure 2. Project Window Options

The Project Options dialog shown in Figure 2 also allows adjustments to quite a number of other options, including the project type, linker option, file extensions, and individual options for the C and C++ translators, and the Symantec Rez tool.

The New Built-in Editor

The built-in editor is improved significantly. It supports syntax coloring - keywords, comments, character constants, string literals and preprocessor directives may be styled individually, both in their font, size, and style, and also using colors you choose. An example of what’s available is shown in Figure 3.

Figure 3. Syntax Coloring in the Editor

The figure above illustrates coloring of language keywords in boldface type, comments in green Geneva 9-point type, and a string constant in the standard typeface, colored red.

Figure 3 also shows “split bars” for splitting the editor window, either horizontally or vertically, into as many panes as you desire. This feature is very helpful when you want to look at something in the file while editing another portion of that same file.

There are three sets of editor preferences, as shown in Figures 4 - 6. These are General Settings, Syntax Formatting, and Marker Settings.

Figure 4. General Editor Settings

Figure 5. Syntax Formatting Editor Settings

Figure 6. Marker Pop-up Editor Settings

As Figure 6 shows, the editor window sports a marker pop up menu (as well as a Headers pop up menu). You can choose to select how classes, functions, enums, typedefs, etc., are marked and in which type style they are displayed in the menu. The choices shown in the figures are the factory defaults, but they can all be changed to suit your preferences. The Editor preferences are selected by choosing Preferences from the SPM’s Edit menu.

In addition to all of the above, the editor supports custom key bindings for controlling its various features. There are an extensive number of keyboard shortcuts that you can customize to suit you. The key binding facility is not documented in the User’s Guide, but the feature is fully described in the Key Bindings sub folder of the Goodies folder, in the CD-ROM version of the product.

The Online Database

Symantec has offered the THINK Reference product for quite some time; however, previous versions that were included in the C++ product have offered only the databases that document the standard library functions that are common to ANSI C applications. The new Symantec C++ v8.0 product offers the entire THINK Reference set of databases, including the newly added THINK Class Library (TCL) database. This set of reference material includes almost all of the current Macintosh toolbox calls, as well as complete documentation for the TCL, its classes and all of its member functions.

Figure 7. THINK Reference Example

The TCL documentation includes information to help you implement various new features in your applications, including extensive documentation of Apple events and Object I/O. Figure 7 shows an example of the AccessObject function documentation in the CAppleEventObject class of the TCL. I found that the THINK Reference product was missing a description of the AEResolve function, which is a fairly recent addition to the Macintosh OS, in support of the Object Model features for Apple events. I suspect that some other recently added toolbox functions may also be missing from the documentation. However, as it stands, the THINK Reference is a godsend to all Macintosh software developers and the addition of the TCL database is just frosting on the cake.

For those of you who are not familiar with the THINK Reference product, each of the underlined words in an entry (see Figure 7) is a hypertext link that, when clicked, takes you to a description of the function, class, structure, or whatever else you select. The Go Back button at the top of the window allows you to either go back to the immediately previous item, or to select from the pop up menu that appears if you hold down the mouse button.

The THINK Reference database is accessible directly from the editor, by highlighting a word (function, constant, or structure name) and then choosing the Find in Doc Server command from the Search menu. Of course, you can also use the Command-hyphen keyboard shortcut (or create your own keyboard binding) to use this feature.

The Class Browser

The Symantec C++ v8.0 product has dispensed with the graphical browser that was first introduced in version 5.0 of the product. Instead, they now offer a browser that is infinitely more useful. It shows the class names for built projects in one pane-either in alphabetic or hierarchical order-the member functions for a selected class in a second pane, the member variables for that class in a third pane, and then provides a listing of the selected member function, class header, or member variable definition.

Figure 8. New Class Browser

The new class browser is shown in Figure 8. The figure illustrates the hierarchical class view in its left pane, the member functions for that class in the middle pane, the member variables in the right pane, and the source code for the MakeNewWindow (selected function) in the bottom pane. The source code can be modified using the same features as the standard editor, and it also displays the same type of syntax formatting as the standard source code editor. I have found that the new browser is much more useful than the graphical browser provided with earlier versions of the product.

The New Debugger

In addition to a new development environment, new editor, and new class browser, the version 8.0 product has a new debugger. For several years, people who have used the THINK Pascal debugger and loved its ability to display the stack when you breakpoint into a procedure, have pleaded with Symantec to provide this same type of display for their THINK C and then the Symantec C++ products. Well, with version 8.0 of the Symantec C++ product this facility is finally available. The new debugger displays the source code, but also provides a full stack crawl, with symbolic names of variables and objects, and it allows you to expand or collapse the listing with a simple twist of a control. Figure 9 illustrates a view of the debugger when it has stopped at a breakpoint, with the context of the current member function shown in the stack crawl window.

Figure 9. New Debugger With Stack Crawl Shown

Figure 9 shows the debugger stopped in the DoCmdOpenSettings function in the bottom pane of the debugger window. The top pane provides the symbolic names of variables (or objects) in its left side and the values associated with these in its right side. The individual panes can be resized to suit your needs.

In addition to the debugger’s main window, Figure 9 shows the floating Control palette above the main window. You can position this palette wherever you like, and it lets you control running, stepping, stopping, stepping into or around functions, or tracing until a function is called. The palette can be hidden by clicking in its close box, and you can issue debug commands by choosing them from the Debug menu or by using their Command-key equivalents.

The debugger also offers a Data window, which evaluates and displays the results of expressions you type in. That window is very much like the Data window in the TPM debugger environment. You can also open multiple debug browser windows. This allows you to look at several different contexts at the same time, which is handy if you want to look at several levels of the stack and compare the values of various arguments, for example.

There is no doubt that the new debugger offers many of features that we have requested from Symantec. They are definitely listening.

The Visual Architect

The Visual Architect (VA) lets you create a graphic user interface and then it generates skeleton code to implement that interface. The VA can be used only with THINK Class Library projects, but aside from that limitation, it’s a marvelous application development tool. The VA remains virtually the same as what is offered in the previous version of the Symantec C++ product. There have been numerous changes to the code generation templates and fixes to the VA itself, but the product is basically the same. Compatible versions for both 68K and Power Macintosh development are offered in the Symantec C++ v8.0 product. The TCL is also shared by both versions of the VA.

Additional Features

The new product also offers a major subset of the “Standard Template Library” developed by Hewlett Packard. In addition, you can create shared library versions of your projects, which will enable you to create a single version of the THINK Class Library and share it with multiple projects. Although Symantec has offered the ability to include libraries into projects for quite a long time, you have never been able to debug the library source code in previous versions of the product. By creating a VA application with shared TCL, you can include a compiled, shared-library version of the TCL into your projects and also debug the TCL at the source code level. This is a major new feature that should really help reduce the disk bloat resulting from keeping many big project files current.

Cross-Platform Development

The new version of Symantec C++ v8.0 supports cross-platform development by providing two separate development environments. The previous version of this product, Symantec C++ v7.0, has been revised, bugs have been fixed, and the THINK Project Manager (TPM), its compilers, linker, and built-in editor are included along with the new Power Macintosh (SPM) development environment. The Visual Architect, THINK Class Library, and other library sources are common to both the TPM and SPM development environments.

Development of two versions of an application-one for 68K users and another for PPC users-requires that the developer create two separate projects-one for the TPM and another for the SPM. This is a problem that Symantec intends to relieve by providing new versions of the compilers, linker, and debugger that will execute in the SPM environment, on either 68K or PPC platforms, and generate and debug 68K target code. At the present time, both the SPM and TPM execute on either platform, but the generated code is targeted for either the 68K (with the TPM) or the PPC (with the SPM) environment.

Figure 10. Merging a 68K Built Application

Fat applications-those that run on either the 68K or PPC platforms-are built rather easily once a 68K version of the application has been built. Figure 10 shows the Project Options dialog in the SPM, for the Project Type settings, with the Merge 680x0 Application checkbox checked, and the Select Application button being pressed. When that button is pressed, a Standard File dialog opens, allowing the developer to choose the built 68K application whose code resources are to be merged into the current SPM project. When the application associated with the current project is built, then the 68K code resources are merged into the final binary, automatically.

It is important to point out that only fat applications can be built with the Merge option in the SPM environment. It is not possible to build fat code resources of any kind. I believe that this is a sensible restriction. Control panels, extensions, and other “system” components should be built especially for the environment in which they will run.

Some Remaining Problems

As good as the new Symantec C++ v8.0 product is, it still has a few flaws. Many of these have already been corrected within Symantec’s development organization and an update to the Symantec v8.0 product is expected to be available by the time this article appears. The update version will be 8.0.1. Some of the problems that have been reported and fixed, or for which workarounds exist are as follows:

In some cases, the debugger will crash either when it is first opened or when it is closed. These crashes are almost always caused by problems in the debugger’s storage of breakpoint and expression data from run to run. If a crash occurs when the debugger is first opened (i.e., you choose Run with Debugger from the Project menu), then you should launch the debugger the next time by holding down the Option key when you choose Run with Debugger until the Source window appears. This will cause all of the breakpoint and expressions to be disposed, but should eliminate the crash. If the debugger crashes when you quit the application being debugged, then the work around is to throw away the “Symantec Debugger Prefs” file in the Preferences folder of your System Folder. This will cause the saved window locations and other preferences information to be disposed, but by performing this step, the debugger should exit normally when you quit the application.

There are a few incompatibilities between the Symantec Debugger in the SPM environment and Apple’s System 7.5.1 update. These should be fixed by the version 8.0.1 update.

In a few cases, keying in an expression into the debugger’s Data window will result in the display of an Alert that indicates an “Internal Error.” There is no published date for the correction of this problem. All I can say is don’t enter that expression into the Data window. Perhaps Symantec will be encouraged to fix this problem shortly. The problem occurs only rarely and should affect only a few users, in special circumstances.

Some templates defined in typedef statements aren’t accepted by the current PPC C++ compiler. This problem is fixed in the version 8.0.1 update. This update is available at ftp.info.apple.com, devtools.symantec.com, and www.symantec.com.

A few problems related to the generation of incorrect optimized code by the PPC C++ compiler have been reported. Most of these have been fixed and the correct code for these will be generated by the updated v8.0.1 compiler.

What About Documentation?

The Symantec C++ v8.0 product ships with only two manuals. One is the “User’s Guide” and the other is the “Compiler Guide.” The THINK Class Library reference book is not provided, mainly because all of that documentation is available in the THINK Reference online hypertext database. In addition to the manuals, Symantec provides quite a bit of documentation in the form of electronic files. For some, the loss of the TCL manual will be severe. I thought that I would miss it, but I found that the TCL documentation in THINK Reference was so accessible that I really don’t miss the paper documentation.

The Bottom Line

I found the new Symantec C++ v8.0 development environment to be very efficient and full of helpful tools. In the course of developing code for my new book, I used the class browser, the THINK Reference database, and the debugger a great deal. I was constantly creating new Visual Architect projects and recompiling. In so doing, I found that the compilers and linker were extremely efficient and I never felt like I really had the time to go out for coffee while a compilation was in progress.

One possible problem for some people might be the amount of RAM required to run the new environment. The SPM requires 8 Mb of RAM to run and you need to add the 1.5 Mb required by the debugger, and also the amount of RAM required for your application, in order to run within the environment. My Power Macintosh 6100 with 24 Mb of RAM had no difficulty running this and several other applications simultaneously; however, a pristine 8 Mb Power Mac is not going to hack it with this environment.

Also, I’m sorry that exception handling hasn’t yet made it into the compiler. This feature is still provided through the use of macros that are part of the TCL. In addition, templates must still be expanded explicitly. Perhaps these two drawbacks will be resolved in a future update to the product.

All in all, the product is incredibly good. I think that maybe Symantec has made life too easy for me.