Tips & Tidbits

By Neil Ticktin, Editor-in-Chief

Tip of the Month: Accelerating MPW's Startup Sequence

This trick is described in the Examples folder that comes with MPW. But in talking to other users, I was surprised to find few people know about it, and even fewer use it.

When MPW is launched, it executes a script named “Startup,” which sets up environment variables, aliases, custom menus, and so forth. This can take from several seconds to over a minute.

It is easy to optimize this startup sequence. After launching MPW normally, copy the following lines into the MPW Worksheet window. Then highlight them as a block and press Enter:

/* 1 */

   Rename "{MPW}"Startup "{MPW}"Startup.Old
   Begin
      Set
      Export
      Alias
      AddMenu
   End > "{MPW}"Startup

This creates an optimized Startup script that will typically execute two to ten times faster than the original. The initial “Rename” command saves the original Startup script, so you can revert to it if you decide you don’t like the results. But if you do “before and after” timings, I think you’ll be happy with the speed improvement.

There are a couple of caveats though. First, the optimized Startup script is not organized and commented the same way the original is. If you frequently change your MPW configuration, you might find the optimized script harder to read and edit. Or you might find it to be easier; the point is that it is different.

Second, if you have UserStartup files that are often modified (such as UserStartup•RunMenu, described in MacTech Magazine, October, 1993), you may wish to add a line to the end of the optimized Startup script to forcibly execute the UserStartup commands. With UserStartup•RunMenu as an example, here’s what the command would look like:

        Execute "{PrefsFolder}"UserStartup•RunMenu

In doing this, you will cause some startup commands to be executed more than once (since some commands from the UserStartup will appear in the optimized Startup script as well). As a final “tweak,” you should then edit the optimized Startup script to delete any commands which will be carried out by forcibly executed UserStartup scripts.

- Lee David Rimar, Absoft Corporation

Strings that go both ways

When writing programs in C on the Macintosh, one thing that we need to deal with is the two possible formats of strings: C-style and Pascal-style. To save the repeated conversion time between the two formats, I sometimes use a format I call the two-in-one format that has both at once.

The C-style string uses a terminating zero character (null) at the end of the string to mark it’s length. The Pascal-style string uses a length byte as the first byte of the string (see figure). Both are allocated by allocating the space for the maximum number of characters the string will hold plus one for either the length byte or the termination byte. My two-in-one format uses both a length byte as it’s first byte and the zero byte as it’s last. To allocate this, take the data size and add two for both the Pascal-style length byte and the C-style terminator. The illustration shows how the length byte, string data, and terminator are laid out.

To use this as a Pascal string, simply use it normally. To use it as a C string, pass the string address as string + 1. Of course, if the size of the string is changed, then either the length byte or the terminator will need to adjusted. If you use calls that treat it as a C string, then the length byte will need adjusting. If you use Pascal-style calls, the terminator will need adjusting. The adjusting isn’t always as hard as you might think.

The following code fragment illustrates using the two-in-one string format:

/* 2 */

Str255  stringOne;
char  stringTwo[50];

...
/*   #1 Toolbox call uses Pascal-style string. */
GetIText (dialogItemHandle, stringOne);
stringOne[stringOne[0] + 1] = ’\0’;     // Add term. byte
...
/*   #2 Uses C-style string and returns the num. of characters. */
stringTwo[0] = sprintf (stringTwo + 1, “foobar”);
...
/*   #3 Two-in-one style, notice the length plus two. */
BlockMove (stringOne, stringTwo, stringOne[0] + 2);

In #1, the toolbox call returns a Pascal-style string, so, for the two-in-one format we’ve got to add the terminator. We know that stringOne[0] is the length byte and we know that stringOne[length] is the last byte of data in the string. So, the length plus one is the terminator byte.

In #2, we’re using the string as a C-style string. Notice that the C-style string starts at an offset of one, this avoids the Pascal-style length byte. Fortunately, sprintf returns the number of bytes (characters) written if there’s no error so we can use it to adjust the length byte. Other C library calls like printf, scanf and their derivatives also return the number of characters processed.

In #3, we’re using the Toolbox call BlockMove() to copy a two-in-one format string. Since the length is the length of the data, we’ve got to add two to allow for the length byte and the terminator byte.

I’ve found that judicious use of this string format can save a lot of conversion in string-heavy programs.

- Malcolm Teas

Step-step

In Think Pascal, the option key allows you to “step-step” through the code. Hold down the option key and pull down the RUN menu. You will see the step-step option. Step-step walks through your source code one line at a time, stepping into functions and procedures. It’s like a guided tour through your own program. Hold down the option key and browse through the Think Pascal menus. You may be surprised how much the option key modifies in the menus.

- Lillian Thompson, Reno, Nevada