Related Info: Window Manager

C or Pascal?

Which is the best language?

By Dave Mark, MacTutor Regular Contributing Author

If my writing seems a little jumpy this month, there’s a good reason for it. I’m thrilled, pleased, and proud to announce the birth of my first child, Daniel Justin, on July 27th, 1992 at 5:39 pm. While I could easily write an entire column describing Daniel’s birthday, suffice it to say that things went relatively smoothly, and we are all doing fine (and no, Dad, the boy doesn’t have a job yet!).

C and Pascal

Recently, we’ve been getting a lot of mail concerning programming in C vs. programming in Pascal. Some folks want to know which language is better for Macintosh programming. Others want some help translating C examples into Pascal and Pascal examples into C. So far, this column has leaned pretty heavily in the C direction. In this month’s column, I’ll try to give Pascal equal time.

C or Pascal: What’s the Best Language?

C and Pascal are both procedural, as opposed to object, programming languages. Pascal is a rigidly formal language, and is said to be strongly typed. C is an informal language, and is very loosely typed. While Pascal forces you to follow a very specific, rigidly defined programming style, C offers more notational flexibility.

For example, consider this snippet of C code:

/* 1 */

void main()
{
 int  age, weight;

 for ( age=0,weight=0; age<=20; age++,weight++ )
 {
 •
 •
 •
 }
}

This for loop initializes two variables, sets the end condition, and increments both variables each time through the loop (the three dots represent the inner workings of the loop). Notice how compact this code is.

To emphasize this point, check out the Pascal version of the same loop:

{2}

program MyProgram;
 var
 age, weight: INTEGER;
begin
 weight := 0;

 for age := 0 to 20 do
 begin
 •
 •
 •
 weight := weight + 1;
 end;
end.

Beginners may find the Pascal code easier to read than the C code. The Pascal example is very straight-forward. Each statement consists of a single expression and the flow is very simple.

The C example, on the other hand, is more complex. Lots of action is crammed into a single line of code. One advantage to this approach is that by allowing several variables to be initialized or incremented at the same time, the structure of the loop is more natural. In the Pascal loop, weight is initialized explicitly, while age is initialized in the for statement. In the C example, both variables are modified in the same breath, more closely matching the intent of the loop.

Pascal is more straight-forward, C is more complex. Now the question is, which of these two languages is better?

The answer to this question depends on your point of view. Some folks claim that Pascal is a superior language because its straight-forwardness makes it somewhat easier to learn than C. Is this your first programming language? If so, Pascal might be the choice for you.

The other side of the coin is C’s power. While Pascal is a safe, dependable Volvo, C is a turbo-charged Porsche, both powerful and dangerous. If you pick C as your language, you’ll be forced to develop a carefully considered coding style. Pascal is a much more forgiving language, but C will really let you fly!

The Support Factor

Whether you are a beginner or an old-timer, you’d probably do just fine no matter which of the two languages you pick. If you need a little push in one direction or another, consider the support factor.

Learning a new language can be pretty tough. The right support can make a huge difference. For example, if your best friend is a C guru, you might choose C over Pascal (that is, if your buddy won’t mind your harassing him or her with questions all the time). If you have access to a Pascal course at your school, Pascal might be your best bet. Once you learn one of these languages, it’s pretty easy to come up to speed on the other one.

One place you can always turn to for support is your local technical bookstore. Books are usually a pretty good investment, and there are lots of good C and Pascal titles available.

All Things Being Equal

If none of this reasoning has swayed you in one direction or another, consider this argument for C over Pascal. There is a strong movement in programming circles towards object programming. This movement is likely to get a lot stronger in the coming years. Apple is doing most of their development in C++, an extremely popular object programming language that happens to be a superset of C.

Pascal also has a related object programming language, Object Pascal. Most likely, in coming years you’ll be able to develop complete Macintosh applications in both Object Pascal and C++. So why am I leaning towards C and C++? Support, support, support...

Here’s why: Go down to your local Software Etc. (or whatever technical bookstore you’ve got in your neck of the woods) and count all the Pascal/Object Pascal books. Next count all the C/C++ books. Chances are, the C and C++ books will outnumber the Pascal/Object Pascal books by at least five to one. This should tell you something.

C and C++ have skyrocketed in popularity in recent years and interest in Pascal and Object Pascal has cooled off. All things being equal, I’d choose C over Pascal. Nothing against Pascal, you understand. It’s just a question of support. My feeling is, over the coming years, I’m going to be able to find C/C++ support a lot more readily than Pascal/Object Pascal support.

Navigating Between C and Pascal

Whether you select C or Pascal, you’ll want to be able to navigate between the two languages. One big reason for this is the proliferation of C and Pascal sample code. If you are trying to solve a specific Macintosh interface problem, there’s no substitute for an example. Murphy’s Law being what it is, if you are programming in one language, the only example you’ll be able to turn up will be in the other language.

C programmers have another reason for learning to read Pascal code. Most of the original Macintosh operating system was written in Pascal. Because of this, most of the examples in Inside Macintosh and in the Macintosh Technical Notes are in Pascal. In addition, the Toolbox routines were designed to take advantage of the Pascal parameter passing mechanism.

The remainder of this column will explore some of the differences between C and Pascal and will help C programmers call Toolbox routines designed for Pascal programmers.

Calling the Toolbox From C

Pull out your copy of Inside Macintosh, Volume I, and turn to page 283. There you’ll find the calling sequence for the Toolbox routine GetNewWindow():

{3}

FUNCTIONGetNewWindow(windowID:INTEGER;
 wStorage:Ptr;
 behind:WindowPtr ): WindowPtr;

The first word in this calling sequence tells you whether the routine being described returns a value or not. In the case of a FUNCTION, the routine returns a value of the type listed at the end of the calling sequence. The calling sequence above tells you that GetNewWindow() returns a WindowPtr.

If the routine is declared as a PROCEDURE, it doesn’t return a value and is analagous to a C routine declared as a void.

Translating Pascal Types to C Types

Once you’ve figured out whether the Toolbox routine under consideration returns a value or not, you’ll need to figure out the C data types that correspond to each of the routine’s parameters. This process is actually pretty easy. For starters, take a look at this table:

Pascal Data Type THINK C Equivalent

INTEGER short

LONGINT long

CHAR short

BOOLEAN Boolean

A Toolbox parameter declared as an INTEGER corresponds to the THINK C type short. Both of these types are two bytes in length. The Pascal type LONGINT corresponds to the THINK C type long. The Pascal type CHAR corresponds to the THINK C type short, and the Pascal type BOOLEAN corresponds to the THINK C type Boolean. The Pascal type Ptr corresponds to a C pointer. In the Macintosh world, both pointers and Ptrs are four bytes in length. In C, a pointer is declared using the * operator.

In addition to these basic Pascal types, you’ll frequently encounter types specific to the Toolbox. For example, the Window Manager defines the type WindowPtr. When you run into one of these Toolbox types, just use them as is. Typically, the Toolbox types are named using the same conventions as the Toolbox routines. The name is divided into a series of words. The first letter of each word is an upper-case letter while the remainder of each word is spelled with lower-case letters. This gives you Toolbox types such as WindowPtr, Rect, and GrafPort.

Let’s go back to the GetNewWindow() call presented earlier:

{4}

FUNCTIONGetNewWindow(windowID:INTEGER;
 wStorage:Ptr;
 behind:WindowPtr ): WindowPtr;

To call this routine from C, you’ll want to pass a short, a pointer, and a WindowPtr 
as parameters. Finally, you’ll receive the result in a variable of type WindowPtr:

/* 5 */

#define kBaseResID 128
#define kMoveToFront (WindowPtr)-1L

WindowPtr window;

window = GetNewWindow( kBaseResID, nil, kMoveToFront );

Notice that we passed constants as parameters. As long as the values are of the proper type, this works just fine.

Remember, C is a case-sensitive language and Pascal is not. In Pascal, you can get away with spelling horrors like WINDowptr and WiNdOwPtR. In C, however, you’d best get it right: WindowPtr.

C and Pascal Strings

In C, text strings are represented by a series of bytes terminated by a null byte, a byte with a value of 0. In Pascal, however, text strings are stored in a variable of type Str255. The first byte of a Str255 is known as a length byte and indicates the length of the text string. The string itself is imbedded in the bytes that follow the length byte. Since the length byte can hold values from 0 to 255, a Pascal text string can be anywhere from 0 to 255 bytes long. C strings are limited only by available memory.

For example, this figure shows a Pascal string containing the text string “Hello, World!”:

Figure 1

The first byte has a value of 13, describing the length of the text string. This figure, on the other hand, shows the same string represented as a C string:

Figure 2

Notice that the string is terminated by a byte with a value of zero.

When a Toolbox routine makes use of a Str255, you need to pass it a string in the Pascal format. For example, here’s the calling sequence for the Toolbox routine DrawString():

{6}

PROCEDURE DrawString( s: Str255 );

You must call DrawString() with a proper Pascal string. THINK C helps you in this regard by offering a special escape sequence you can use to declare a Pascal string literal in C. If THINK C encounters the characters \p at the very beginning of a string literal, the string is stored as a Pascal Str255. For example, this call to DrawString() works like a charm:

/* 7 */

DrawString( “\pHello, World!” );

You might also find it useful to use \p in a #define:

/* 8 */

#define kMyString“\pHello, World!”

DrawString( kMyString );

This approach works just as well.

THINK C also provides the routines CToPStr() and PToCStr() to translate a C string to Pascal and a Pascal string to C. Note that these routines are not part of the Macintosh Toolbox. They are provided as a service by THINK C.

When to Use the &

Another important issue for C programmers concerns the & operator and its use in parameter passing. Pascal parameters are normally passed by reference. This means that you can pass an INTEGER into a routine and, if the routine modifies the INTEGER, the changed value goes back to the calling routine.

C normally passes parameters by value. In C, if you pass a short to a routine, and the routine modifies the short, the modification only affects the local copy of the short and not the calling routine’s copy. To pass a parameter by reference in C, you’ll typically pass a pointer to the variable:

/* 9 */

MyRoutine( &myVar );

There’s more to parameter passing than just sticking an & in front of any parameter you want to pass by reference. Here’s a set of four rules you should use to decide when the & is appropriate when making Toolbox calls. These rules can be found in Volume I of the Mac C Primer:

1) If a parameter is declared as a VAR parameter in the Pascal calling sequence, precede it by an &. Here’s the Pascal calling sequence for GetFNum():

{10}

 PROCEDUREGetFNum( fontName: Str255;
 VAR  theNum: INTEGER );

Here’s a C code fragment that calls GetFNum():

/* 11 */

 short  myFontNumber;

 GetFNum( “\pGeneva”, &myFontNumber );

2) If the parameter is bigger than 4 bytes (as is the case with most Pascal and C data structures), precede it by an & whether or not it is declared as a VAR parameter. Here’s the Pascal calling sequence for UnionRect():

{12}

 PROCEDUREUnionRect( src1, src2: Rect;
 VAR dstRect:  Rect );

Here’s a C fragment that calls UnionRect():

/* 13 */

 Rect src1, src2, dstRect;
 •
 • /* assign values to src1 and src2 */
 •
 UnionRect( &src1, &src2, &dstRect );

3) If the parameter is 4 bytes or smaller and is not declared as a VAR parameter, pass it without the &. This rule applies even if the parameter is a struct. This is the Pascal declaration of the routine PtToAngle():

{14}

 PROCEDURE PtToAngle(   r:  Rect;
 pt:    Point;
 VAR  angle:INTEGER );

Here’s a C fragment that calls PtToAngle():

/* 15 */

 Rect   r;
 Point  pt;
 short  angle;
 •
 •  /* assign values to r and pt */
 •
 PtToAngle( &r, pt, &angle );

Notice that pt was passed without a leading &. This is because Points are only 4 bytes in size. Most of the predefined Mac types are larger than 4 bytes in size. Point is one of the few exceptions.

4) If the parameter is a Str255, do not use an &, even if the parameter is declared as a VAR. This is the Pascal declaration of the routine GetFontName():

/* 16 */

 PROCEDURE GetFontName(   fontNum: INTEGER;
 VAR  theName: Str255 );

Here is an example of a Pascal string used in a Toolbox call:

{17}

 Short  fontNum;
 Str255 fontName;

 fontNum = 4;
 GetFontName( fontNum, fontName );

Note that fontName was passed without a leading &.

Last Month’s Program In Pascal

Last month we worked through a program called PICTWindow. Since this column focused on Pascal, I thought you might like to see a Pascal version of PICTWindow. Here it is...

Create a new folder called PICTWindow. Follow the directions in last month’s column to create the resource file called PICTWindow.Π.rsrc and copy the file into the PICTWindow folder.

Next, launch THINK Pascal and create a new project in the PICTWindow folder. Select Run Options... from the Run menu and click on the Use Resource File: checkbox. When prompted, select the PICTWindow.Π.rsrc file in the PICTWindow folder, then click the OK button.

Next, select New from the File menu to create a new source code window. Type in this source code:

program PICTWindow;
 const
 kBaseResID = 128;

{----------------> WindowInit <--}
 procedure WindowInit;
 var
 window: WindowPtr;
 begin
 window := GetNewWindow(kBaseResID, nil, WindowPtr(-1));

 if window = nil then
 begin
 SysBeep(10);
 ExitToShell;
 end;

 ShowWindow(window);
 SetPort(window);
 end;

{----------------> DrawMyPicture <--}
 procedure DrawMyPicture;
 var
 pictureRect: Rect;
 picture: PicHandle;
 begin
 picture := GetPicture(kBaseResID);

 if picture = nil then
 begin
 SysBeep(10);
 ExitToShell;
 end;

 pictureRect := picture^^.picFrame;

 OffsetRect(pictureRect, -pictureRect.left, -pictureRect.top);

 DrawPicture(picture, pictureRect);

 FrameRect(pictureRect);
 end;

{----------------> PICTWindow <--}
begin
 WindowInit;
 DrawMyPicture;

 while not Button do
 ;
end.

Finally, save the source code as PICTWindow.p and add the file to the project. Select Go from the Run menu to run the program. Enjoy!

Next Month

Next month we’ll return to the topic of resources. Till then, it’s back to late nights and diaper changing. Coming, Daniel...