HiSoft C

ZX Computing

David Nowotnik

PROGRAMMING IN C If you're bored with Basic but not yet up to machine code, there are alternatives. David Nowotnik looks at the increasingly popular 'C' language. Once the basics of BASIC have been mastered, then the Programming enthusiast often looks for a fresh challenge. One of the main motivations or this is for speed. For fast action games, BASIC is frustratingly slow. This sluggishness is a result of the fact that BASIC is a translated language. In other words, a BASIC program exists in memory in a form which is relatively easy tor us to understand, and this program is then translated by the routines in ROM to machine code, in run-time (while the program is in operation). It would be better for this translation process to be carried out before the program is in operation, simply to save time. Doing the translation this way is called compilation, and the result is a machine code program (or something close to machine code) which runs very much faster than the original translated program. COMPILERS You can buy BASIC compilers tor both Spectrum and QL computers, which convert your BASIC programs to machine code. However, these compilers are never fully compatible with all aspects of BASIC, so, more often than not, alterations have to be made to BASIC programs to allow them to be compiled and to run smoothly. Furthermore, BASIC was not designed to be compiled, and the machine code produced by BASIC compilers can still be rather slow and wasteful of space. Learning machine code (or assembly language) to achieve fast machine code programs is a daunting task for amateur programmers. For those with neither the time or patience to devote to mastering, the complexity of machine code, there are 'high level' languages which are designed to be compiled. Over the relatively short history of microcomputers, the fashionable alternative to BASIC has changed a few times. Pascal was the favoured language in the '70s but gave way to FORTH in the early 1980s. Now, top of the charts is the language of 'C'. The attraction of 'C' is that it adopts a structured style similar to Pascal, and allows close interaction with the machine operating system. 'C' is machine language orientated, compiling to fast and space efficient machine code, yet it is relatively simple to learn and to write in 'C'. 'C' originated in 1972 as the systems language of the UNIX operating system, designed by Bell Laboratories. Like many other languages, 'C' developed because of deficiencies in other languages: 'C' was based upon BCPL and 'B'. The former is still used, but the latter appears to have faded into obscurity. LURE OF THE 'C' The attraction of 'C' is its size. It has very few keywords, so it is easy to learn. Routines can be small, but very powerful. Many of the operations adopt a shorthand which save on typing, and enhance readability (eg. ++i is equivalent to LET i=i-1 in BASIC). Its structured style will be very familiar to SuperBASIC programmers on the QL. Programs are built up in a modular fashion using routines, called functions, which can be independent of each other. Each function can be written separately and tested independently before building into a program. By tradition there are no functions built in to the 'C' compiler; all compilers are supplied with a 'standard' library of functions and routines are 'borrowed' from the library in compiling a program. Like most libraries, new functions can be added by the user, or the supplier. This is also a feature of SuperBASIC, but 'C' has the advantage that all functions remain in the external library (rather than occupying ROM or RAM space), and are included only when required by a program. 'C' is not without certain disadvantages. Being small and powerful, it can be very difficult to debug. A particular problem lies in the multiple use of operators such as *,+,=, etc For example '=' and '==' mean quite different things, but a simple typing error could enter the wrong operator, which might take some time to spot and correct. It is beyond the scope of this article to provide a detailed description of 'C'. Due to its popularity, there are a number of books available which provide a tutorial on the language. The 'C' programmer's 'bible' is "The C Programming Language" by 'C' designers W. Kernigham and D. M. Richie, which sets the standard for the language. Good lower price options are "C at a Glance" by Adam Denning, and "Practical C" by Mark Harrison; both cost £7.95. However, to give a flavour of the language, fig. 1, contains a listing a a simple 'C' program, with its equivalent in BASIC. The BASIC listing was designed to run on both QL and Spectrum, and is a simple test of speed. The 'C' listing was typed into two 'C' compilers, one for the QL and one of the Spectrum, to determine how much faster the compiled program will run compared with the BASIC versions. More on that test later... Notice in the 'C' listing, there is one defined function called 'main'. This function appears in all 'C' programs, and is the starting point for all programs (other functions can be called from 'main'). The body of the function is contained within 'braces' (curly brackets); braces are also used to group together blocks of statements which combine logically together, eg, the do...while block. Variables can be defined as local (as in SuperBASIC) to the function, and these are normally defined at the beginning of a function. In the example, the keyword 'int' defines the variables a, b and c as integer. The mathematical expressions used in fig. 1, are very similar in both languages The 'printf' command is a standard function of formatted output to the screen. HISOFT C Hisoft £25 Hisoft's compiler costs £25 and consists of a tape cassette with the compiler on one side, the 'C' library on side 2, and two manuals. The main manual, 78 pages in length, provides instructions on how to use the compiler and text editor, with a reference section giving differences of Hisoft's implementation of 'C' to the standard of Kernigham and Richie. There is also a chapter explaining error messages. The second booklet explains upgrades of version 1.3 (the second issued version of this compiler) and responds to deficiencies reported by users in the original version. Once the compiler is loaded, the user is given the option to save the compiler to microdrive. The library routines on side two can also be transferred to microdrive once in the editor routine. The compiler is very simple to use, and Hisoft's package is ideal if you are learning to program in 'C'. Pressing 'EDIT' takes you into the text editor. When typing in a program, the text editor assigns each line a number. Line numbers are not part of the language of 'C', but they are used to simplify text editing. Once a program or routine is complete, compilation is simply a matter of returning to the compiler (pressing 'c'), then typing 'include'. The compiler appears to operate, unusually, in a single pass. Many of the standard 'C' routines are built into the compiler so there's often no need to access the library. If the compiler finds any errors, it stops to present an error number, line number, and short error message, of course, the actual error may not be on the line indicated (and the compiler did sometimes gets its line numbers mixed up), but with very few key presses the programmer can return to the text editor, edit the offending line, then back to the compiler for another try. Once all bugs are removed, the programmer indicates 'end of file', and the compiler asks if you want to run the program, and if the reply is yes, the compiled program is executed. In this mode, the compiler, text editor, text file and compiled code all exist in RAM at the same time, so the amount of space for 'C' programs is rather limited. The object code generated in this manner cannot be saved independently; to use a 'C' program in another session, the text file must be saved to tape or cartridge, then compiler and text file loaded at the next session, then the source file re-compiled and run. Alternatively, use of the 'translate' command in the source file causes the compiled code with run time routines to be dumped to tape, for use independent of the compiler. Compiled code can only be used when loaded to a start address of 25200, leaving just enough space for a short BASIC boot program. A feature very useful for beginners is the library; as it is in source code, the library can be loaded into the text editor and many lessons learnt from examining the routines. User routines can be added to the library, and Hisoft promise to add routines periodically. Library routines are added to the user programs with the 'include' command. A special variant of this command, '?include?' searches the library, and only includes routines which are required by the user program. Hisoft's compiler offers integer arithmetic only, but otherwise it is an excellent, easy-to-use package, ideally suited to both beginner and computer professional. Before moving onto the QL compiler, it's worth making the point that neither package offers any tutorial on 'C'. Both manuals make frequent reference to Kernigham and Richie's book. This is a must for professionals, although beginners may find one of the cheaper books, mentioned earlier, easier to use. LATTICE C Metacomco £99 At £99, the Metacomco Lattice 'C' compiler, called the 'QL C Development Kit', is much more up-market; not only in price but in the extra facilities on offer. It is a professional package for professional users. In its smart case, this package provides a plug-in ROM, software on three cartridges, and a 248 page manual. The ROM is the system's security mechanism, providing a few extra keywords essential to the operation of the system, and allowing the cartridges to be backed-up freely. The compiler uses Metacomco's highly-rated full-screen text editor, with a wide-ranging set of immediate and extended commands to make program development very easy. Once complete the source file is saved to disc or microdrive with a '_C' suffix, required for recognition by the compiler. Compilation is carried out in a two pass process followed by use of the GST 'Linker' (included in the package) to add library and run-time routines; all three steps are required to produce code suitable for running with the QL's EXEC OR EXEC_W commands. First pass compilation is initiated with the new keyword 'LC1'. Several arguments can be added to this keyword to provide a very wide range of options for the compiler, including adjusting workspace, producing list files, and setting the stack reserved space. The compiler, loaded from the first microdrive cartridge, displays any warning or error messages, automatically halting compilation with fatal errors. In a similar way, 'LC2' initiates the second pass loading the compiler routine from the second cartridge. Again, many compile time options are permitted. The second pass compiler signs off with a message providing information on code size, and the sizes of blocks for initialised and uninitialised data. Having called Metacomco's 'C' compiler a professional system, it must be said that it really needs a professional QL system for ease of use. With a standard QL, with no added memory it can take over 10 minutes to compile even a very short routine, such as shown in fig. 1. With 'only' 128K of RAM, the compiler needs to use part of the screen display as workspace, producing some interesting coloured screen displays. Most of that 10 minutes is devoted microdrive access, and the longest operation is using the linker. With added memory and discs total compilation time and linking can be less than a minute. A lot of space on the microdrives provided with 'QL C' is devoted to library routines, and a comprehensive set of Unix, mathematical, and QDOS functions are available to the user. When including any library routines, all the library is incorporated, giving rise to very large files, even with short programs (the object code compiled from the program in example in fig. 1, occupies 29 sectors on microdrive). Machine code functions can be included, provided they follow the standard explained in the manual. The compiler closely follows the Kernigham and Richie standard with full floating point arithmetic; and it also supports Macros. The compiler was designed by Lattice, so code written on the QL should be compatible with other Lattice compilers for 68000 and 8086/88 micros. 'QL C' may be expensive by home computing standards, but it is well worth the investment for those taking up 'C' programming seriously. SPEED TEST So what of the operating speed, mentioned at the beginning? Here are the results a the test programs in fig. 1. The Spectrum took 164 seconds to work its way through the BASIC version; In 'C' the program ran in just 9 seconds. The corresponding times for the QL are 82 an 7.5 seconds. Quite a saving! As a footnote to all those tempted to take a look at 'C', it is worth bearing in mind that many established software houses now program almost entirely in 'C', and it is predicted by some that 'C' will eventually take over from BASIC as the standard for microcomputers.

Your Spectrum

ALL AT C Hisoft has just released version 1.1 of its C compiler for the Spectrum. C is a very flexible and easy to learn language (it says here) that was originally designed for writing operating systems. You may not have to be a mega-brain to learn C but it's not a beginner's language. Little errors in it can cause big crashes. Still, if you're bored with Basic and fancy knocking out an operating system or two before tea, Hisoft are on [redacted].

Sinclair User

Gilbert Factor 9/10

Adam Denning 9/10

A LANGUAGE FOR THE FUTURE Adam Denning lays bare the mysteries of C, a new language for the Spectrum which is faster than Forth and simpler than Pascal. Memory: 48K Price: £25.00 If the Spectrum was pitched against the BBC Micro for serious applications, it would not be at all surprising if it came out on top amongst programmers. That is almost entirely due to the efforts of one small software company up in Bedfordshire, Hisoft. The company's release of its acclaimed Pascal compiler over a year ago, coupled with the simultaneous release of its machine code development system Devpac, has gained it and the Spectrum a higher credibility factor than Sinclair Research could ever manage by itself. Now the company has released another compiler, this time for the language C. C is widely regarded as the language of the future, not least because of its unique position as the language in which Unix™ is written. Unix is now the de facto standard operating system for any 16-bit computer, with versions even available for the 68000 extended BBC Micro and soon the QL. C is integral to all that, gaining a reputation as the systems language most likely to succeed. It has two main advantages over other languages like Basic and Pascal: First, C is standard, so programs are in practice portable - as opposed to the theoretical portability of Pascal and the mess created by the myriad versions of Basic. Second, it is block structured and far less formal than rivals of the Pascal ilk. Two long words here, both of which need definition. A portable language is one which has exactly the same form on all machines, which means a program written in language X on machine Y will run without alteration on another machine Z that also supports language X. Only C gets truly close to that level of portability. A block structured language is one in which each task in a program is broken down into small, easily manageable modules. That type of programming is much in vogue, with Pascal being the most shouted-about progenitor. The trend probably started with the BCPL language, developed by Dr Martin Richards in Cambridge, but Pascal and C soon became more widely used. BCPL is in fact the grandfather of C, as two Americans, Dennis Ritchie and Brian Kernighan, took the offspring of BCPL - called B - and came up with C. The only book worth reading on C was written by those two Americans, and is called The C Programming Language published by Prentiss Hall and costing £16.95. So the Spectrum now provides more opportunity for the budding systems programmer than any other home micro widely available. The provision of C gives distinct advantages to the Spectrum owner, as it is compiled into Z80 machine code and therefore runs faster than most other languages available - it beats the hell out of Forth. Moreover, anyone contemplating a career in computing is going to need to know about the language, and this is the cheapest option there is. The average programmer will also find it useful as it is easier to use than Pascal and easier to learn. It can do almost everything which Spectrum Basic can do without any of the disadvantages. Hisoft C is supplied on a cassette, containing everything - the compiler, the editor, the standard input/output header and a library of useful system routines. Once loaded the program asks if you wish to save the compiler and editor to microdrive. That follows Hi- soft philosophy of making all its products microdrive compatible, so that a user equipped with those devices need never be hampered by having to return to cassette tapes again. The editor supplied as an integral part of the compiler is the standard Hisoft line editor used on all its source code based products, but programs can be written without recourse to the editor once you are familiar with both C and the implementation. The editor is invoked by pressing CAPS SHIFT and 1, i.e. EDIT, simultaneously, and from thereon all functions are standard until the c commnd is used to return to the C compiler. C programs created that way can be saved to and loaded from tape or microdrive, and of course any section of saved source can be included in a compilation with the #include directive. That is standard practice in C compilers as it is usual for at least one header file containing all the #define definitions and standard i/o to be included in the source file. Hisoft C has something else which, as far as we know, is unique - programs can be entered directly into the compiler just by typing them in, and subsequently invoked either by telling the machine that the end of the source file has been reached - by pressing SYMBOL SHIFT i - or by going into direct mode with #direct+ and typing a suitable invocation such as: main(); That direct mode also means that individual functions can be tested as stand alone programs, or quick calculations can be done. For instance, you might want to know the hexadecimal equivalent of 23456. All you have to do (assuming you are in direct mode) is type: printf("%x/n", 23456); and your answer will be printed out. You can leave direct mode by typing #direct-. Before we look at some C programs and discuss how to use the language, we must look at some of the imperfections of the current version of Hisoft C. The most noticeable of those is that invocation of a non-existent function resets the machine, losing the compiler and returning to Basic. The float type is also missing, which means that floating point numbers cannot be operated on. Oddly, the scanf function - the C equivalent of INPUT - is not here either, but it is fairly simple to write the parts of the function that you require. Those are really the shortcomings worth mentioning, and even those will not be there for long. Hisoft will give a free update to purchasers of the current version of the compiler, and all the facilities mentioned as lacking are going to be included at some stage. A program consists of a number of functions, of which one must be called main. That is where execution begins when the program is run. Of course, Hisoft's direct mode obviates the need for that, but it is best to follow the standard language definition so that later program development on other machines will not be hindered by silly mistakes. The program in Figure 1 converts any number between 0 and 65535 into its hexadecimal and binary equivalents - a bit simple, perhaps, but then how many of us have programmed in C on the Spectrum before? The program is simpler than it looks, but introduces a lot of C's more interesting properties. It was very hurriedly written, so it is by no means the best example of C programming. The first thing we do in all three functions is to declare our variables, so that main has two integer variables and a character string (an array) 16 characters long, readn has three integers and a smaller string array and binary has two integers. The only function that returns a result is readn, and the type of that result is indicated by declaring the function itself as having a type - integer in this case. We also see that binary has two parameters passed to it. We have to tell it what type those parameters are, which is the purpose of the two lines after the function declaration. The body of the program is controlled by main. It first prints a prompt and then uses our readn function to read in a decimal number, passing the integer value to the variable n. The binary function is then called to convert this into a 16 character binary string in the array b, and then the answers are printed out. The printf function can handle the printing of numbers in hex, but not binary, so we then use a for loop to print out the 16 digits of b in reverse order. Notice the structure of the 'for loop' - the start value first, then the end condition and finally the increment. The ++ here is just the C way of incrementing. As carriage returns and various other 'non-printing' characters are rather hard to represent on screen, C uses the backlash () as an escape character, so that various symbols after the slash are converted to various characters. Thus, is a new line character. The readn function is a very simple method of reading in a number from the keyboard, and has two distinct disadvantages. It can only handle digits, so no sign must be included, and if you type in more digits than there are places in the s array, you will crash the computer. It is, however, quite fast. It simply reads in each digit from the keyboard at a time, using the getchar function until it finds a new line character. The != symbol means 'not equal to'. The resulting string is then converted to decimal by taking each digit and progressively adding into ten times the total - a very standard method. That is then returned as the result. A 'for loop' is also used by binary, this time decrementing from 15 to 0 to access each element of the array in reverse order. We use bitwise ANDing (the & operator) on powers of two to generate each binary digit. Each power of two is formed by shifting one left the requisite number of places (the << operator - pure BCPL). That is by no means the extent of C's usefulness, and its reputation for systems programming is well founded but difficult to demonstrate briefly. It is the most welcome addition to the Spectrum catalogue since Sinclair introduced the Microdrives, and at the price cannot be missed. Hisoft is at: [redacted].

Figure 1.

Personal Computer News

Features 4/5

Documentation 4/5

Performance 5/5

Overall Value 4/5

David Janda 4/5

HIGH C David Janda hits the high notes with Hisoft's version of C language for the Spectrum. NAME: Hisoft C V1.0 SYSTEM: 48K ZX Spectrum (Microdrive compatible) PUBLISHER: Hisoft, [redacted] PRICE: £25 AVAILABILITY: Mail order only The language of the '80s is C. At least, I that's what the pundits would have us believe, and judging by the amount of publicity it's getting, this could well be the case. C is usually associated with minicomputers and micros running CP/M, CP/M86 or MSDOS. But now Hisoft, which produces an excellent Pascal for the Spectrum, has released a version of Spectrum C. The C language is a general purpose, high-level programming language that can be used for a wide variety of programming tasks. Many software houses use C instead of assembly language, because C object code is fast and saves costs. The other attraction is its portability - a program written in C on one machine can be run on another, providing both machines use compatible Cs (there are dialects of C but the differences are often unimportant). Hisoft's C conforms closely with the definition given in the C programmer's bible - Kernighan & Ritchie's The C Programming Language (often abbreviated to K&R). After learning C with Hisoft's version it would be possible to progress to a Unix-based system without too much trouble, and you could run programs written on your Spectrum on a DEC VAX, or vice versa. FEATURES The package consists of a tape and manual. On one side of the tape is the C compiler/editor and a front-end program which allows a backup to be made. On the flip side is a standard C function library containing functions for dealing with I/O string, store management and so on. While Hisoft's implementation is very close to the K&R standard, there are exceptions. The two most notable are that there is no floating point feature, and you can't use indentifiers. Included in the package is the line editor used in Hisoft's Pascal and Devpac. Source code can be entered and amended, saved to tape or Microdrive, printed and so on. Although the compiler and editor are separate, they're loaded into the Spectrum's RAM together. This means that program development is quicker because the two are always resident. Error messages are abundant, and for each an error number is displayed with a brief description. A neat feature is that the error messages can be cleared from memory, just leaving the number; this frees about 2K, and it's easy enough to look up the error meaning in the manual. Version 1.0 does not allow object code to be run independently of the compiler, but this will be possible in the next version. This will also feature identifiers, and floating point routines are being considered. IN USE The best method of getting to grips with this package is to keep a copy of K&R close to hand. It's a bit pricey at £16.95, but it's essential because Hisoft's manual is written with dozens of references to it. Cross referencing between the two isn't difficult. The first thing I did was to make a working copy of C on Microdrive. Once the compiler/editor is loaded from tape you're asked whether you wish to make a backup and a single key press will do the job. Unfortunately, this process doesn't also backup the library and I hope Hisoft includes this in future versions. Entering source code using the line editor is straightforward. It's comprehensive and includes a full set of useful functions, such as search and replace. Source code can be entered directly, but is not recommended for large programs because mistakes cannot be rectified. One non-standard feature I took a liking to was the ability to use commands in an immediate mode, similar to that of Basic, which allows you to 'test the water' without diving in. VERDICT Hisoft C is an excellent tool for learning the language, and an important product for the Spectrum. The lack of floating point and identifiers is no hassle if you're learning the language, but I hope floating point will be included in later versions as integer maths is restrictive. C is a mega-product for the Spectrum, but £25 is quite costly. Ten pounds less and more would buy it. However, to learn C on another machine you'd have to lash out somewhere in the region of a thousand pounds for the kit and a decent compiler.

WHAT IS C? The C programming language was developed by Dennis Ritchie on a Unix system running on a DEC PDP-11. It is very much a 'bare bones' language with no inbuilt I/O, string handling or array functions. These are achieved by using routines from function libraries. This system might seem odd, but it has the advantage of making the language compact and due to the minimal set of commands and functions it can be learned quickly. Fundamental data objects are provided by integers, characters and floating point. Control constructs include IF, WHILE, FOR and DO and there's a case-like statement called SWITCH. C promotes the use of memory pointers, and address arithmetic is allowed. The result is that although C is not very strongly typed, it is possible to create data types quite easily.