Turbo Pascal

Turbo Pascal

Turbo Pascal is a complete software development system that includes a compiler and an Integrated Development Environment (IDE) for the Pascal programming language running under CP/M, CP/M-86, and MS-DOS, developed by Borland under Philippe Kahn's leadership. The name Borland Pascal was generally reserved for the high end packages (with more libraries and standard library source code) while the original cheap and widely known version was sold as Turbo Pascal. The name Borland Pascal is also used more generically for Borland's dialect of Pascal.

Borland has released three versions of Turbo Pascal of historical interest free of charge: versions 1.0, 3.02 and 5.5 for MS-DOS.

Motivation and release

Philippe Kahn first saw an opportunity for Borland, his newly formed software company, in the field of programming tools. Historically, the vast majority of programmers saw their work flow in terms of the edit/compile/link cycle, with separate tools dedicated to each task. Programmers wrote source code and entered it using a text editor, a compiler created object code from source (often requiring multiple passes), and a linker combined object code with runtime libraries to produce an executable program.

In the IBM PC market of the early 1980s, the major programming tool vendors included IBM, Microsoft, and Lattice. They all made C compilers (and some made Pascal compilers), which all worked in a similar fashion. For example, the Microsoft Pascal system consisted of two compiler passes and a final linking pass (which could take minutes on systems with only floppy disks for secondary storage). This process was the cumbersome product of the extremely limited resources of the early IBM PC models. Vendors of software development tools aimed their products at professional developers, and the price for these basic tools plus ancillary tools like profilers ran into the hundreds of dollars.

Kahn's idea was to integrate these separate functions in a programming toolkit, have it run with much better performance, and charge one low price for it all. Instead of selling the kit through established sales channels (retailers or resellers), his new tool would be sold inexpensively via mail-order. Turbo Pascal is generally considered to be the first popular Integrated Development Environment (IDE) of any type.

As an additional selling point against the bigger vendors, Turbo Pascal disks came with no copy protection of any sort. Turbo Pascal came with the famous "Book License": "You must treat this software just like a book ... may be used by any number of people ... may be freely moved from one computer location to another". Since the first versions didn't have online help, copy protection was effectively enforced by possession of the Turbo Pascal reference manual (pictured below).

Version history

The Turbo Pascal compiler is based on the Blue Label Pascal compiler originally produced for the NasSys cassette-based operating system of the Nascom microcomputer in 1981 by Anders Hejlsberg. This was first rewritten as the Compas Pascal compiler for the CP/M operating system and then as the Turbo Pascal compiler for DOS and CP/M. A version of Turbo Pascal was available for the Apple Macintosh from about 1986 but was eventually discontinued around 1992. Another version was available for CP/M machines like the DEC Rainbow through several releases.

Versions 1 to 3

See also Antique Software: Turbo Pascal v1.0 Borland licensed the PolyPascal compiler core, written by Anders Hejlsberg (Poly Data was the name of his company in Denmark), and added the user interface and editor. Anders joined the company as an employee and was the architect for all versions of the Turbo Pascal compiler and the first three versions of Borland Delphi.

The first version of Turbo Pascal, later referred to as version 1, was very fast compared to other microcomputer Pascal compilers. It was available for the CP/M, CP/M-86, and MS-DOS operating systems, all widely used at the time. The CP/M version could be used on the very popular Apple II computer if fitted with a Z-80 SoftCard, the first hardware product of the small company Microsoft released in 1980.

At the time CP/M used a simple executable file format using the file name extension .COM; MS-DOS could use either .COM files (incompatible with CP/M) or the more flexible relocatable .EXE format used almost universally in later years. Turbo Pascal generated only .COM files, which was not a severe restriction for the computer world of the time. Turbo Pascal itself was a single .COM file about 38 kilobytes long. which included the editor, compiler, linker, and the library routines. The edit/compile/run cycle was fast compared to other Pascal implementations because everything related to building the program was stored in RAM. The compiled program could run from the IDE; writing it to disk, once free of obvious errors, was an additional menu option.

When the first version of Turbo Pascal appeared on November 20 1983, the type of IDE it used was relatively new. On its debut in the American market, Turbo Pascal retailed for USD$49.99. The integrated Pascal compiler also was of very good quality compared to other Pascal products of the time and was affordable above all. The "Turbo" name alluded to its compilation speed as well as the speed of the executables it produced. The speed of these "com" executable files was a revelation for developers whose only previous experience programming microcomputers was with interpreted BASIC or the semi-interpreted and more cumbersome UCSD Pascal.

The IDE was incredible for its day, when computing resources were very limited. The IBM PC and other machines were often sold with 64 kbytes of RAM; the IBM PC was expandable up to a maximum 640kb. Many machines equipped with only one or two floppy disc drives of a 140 - 360 kilobytes capacity were used; a 5 or 10 megabyte hard disk was a luxury. Turbo Pascal was simple and intuitive, and had a well-organized menu system. Early versions of the editor used WordStar key functions, which was the de facto standard because of WordStar's wide use. Later versions of the IDE, designed for later PCs with more disk space and memory, could display the definitions of the keywords of the language by putting the cursor over a keyword and pressing the F1 key. The definitions also frequently included example code that used the keyword. This enabled the inexperienced programmer to learn Pascal simply by using the IDE, without actually requiring help from a book.

Versions 2 and 3 were improved versions of the same basic all-in-one system, working in memory and producing .COM/.CMD files. Support for CP/M and CP/M-86 was dropped after version 3.

Later versions

Version 4, released in 1987, was a major rewrite of the whole system. The compiler generated executables in EXE format under MS-DOS, rather than the simpler but more restricted .COM executables. Support for the now obsolescent CP/M and CP/M-86 operating systems was dropped. This version also introduced a full-screen user interface with pull-down menus; earlier versions had a text-based menu screen and a separate full-screen editor.

Version 5.x introduced the familiar Borland blue screen, which would be the trademark of the company's MS-DOS compiler tools until the end of this line in the middle 1990s.

While all versions of Turbo Pascal could include inline assembly code, later versions had the ability to easily integrate assembly language within Pascal. Assembly code provides the lowest human-readable interface to the machine, and allows faster execution than can be generated by a compiler, with access to the machine at a very detailed level. Overall program execution could be improved by coding much-executed inner-loop code this way.

The IDE allowed single stepping through a program for debugging, and now assembly-language blocks could be stepped through. The user could add watches on variables and registers in an IDE window. Programs using IBM PC graphics mode could flip between graphics and text mode automatically or manually.

The IDE now included a code profiler that could report on which parts of the program were using the most time. The books included with Borland Pascal had detailed descriptions of the Intel assembler language, going so far as to provide the clock cycles required by each instruction. Overall this system, as a whole, made for a relatively pleasant experience when trying to debug and optimize code; the user never had to leave the IDE.

Units

Over the years, Borland enhanced not only the IDE, but also the programming language. Borland's dialect of Pascal became a de facto industry standard (and is still implemented by modern variants like Free Pascal), since ISO standard Pascal proved inadequate for real-world application development.

From version 4.0, the language introduced the concept of Units. Units were used as external function libraries, like the object files used in other languages such as C, but a little more high level (the programmer was able to define what will be visible outside the unit and what not).

Units in Borland's Pascal were similar to Modula-2's separate compilation system. In 1987 when Turbo Pascal 4.0 came out, Modula-2 was making inroads as an educational language which could replace Pascal. Borland, in fact, had a Turbo Modula-2 compiler, but this product ran only on CP/M and was never ported to MS-DOS (its user interface was almost identical to that of Turbo Pascal 3.x and earlier). Instead of porting their Modula-2 compiler to MS-DOS, Borland elected to implement separate compilation in their popular Pascal product. Separate compilation was not part of the standard Pascal language, but was already available in UCSD Pascal, which was very popular on 8-bit machines. Turbo Pascal syntax for units appears to have been borrowed from UCSD Pascal. With earlier versions of Turbo Pascal, which ran on computers with limited resources, the complexity of software written with the package did not demand it; but with the new ability to generate large EXE files, programs of significant complexity were now possible which needed separate compilation.

Object oriented programming

From version 5.5 onwards some object oriented programming features were introduced: classes (this should not be confused with "objects" because "classes" only become objects when they are instantiated/created), inheritance, and constructors and destructors. The IDE was already augmented with an object browser interface showing relations between objects and methods and allowing the programmer to navigate the modules easily. Some people call these extensions Object Pascal although that is more commonly used as a name for the language underlying Delphi (which has two totally separate OOP systems).

Turbo Pascal 7 and Borland Pascal 7

The last version released was version 7. Borland Pascal 7 contained an IDE and compilers for creating DOS, extended DOS and Windows 3.x programs. Turbo Pascal 7 on the other hand could only create standard DOS programs. It also had a graphical API (the Graph unit) which supported multiple external drivers (BGI files - standing for Borland's Graphics Interface) and provided a mechanism to link these drivers with the EXE, but as it was quite slow and caused unpleasant flickering, interchangeable visual pages were used, which caused overfilling the video memory. Some third party drivers, such as SVGA drivers, were made by fans, but they never gained big popularity, since next-generation tools like Delphi were on their way at that time.

Windows versions

Two versions of Turbo Pascal for Windows 3.x were released: Turbo Pascal for Windows 1.0 (based on Turbo Pascal 6 but released about 2 years later), and 1.5 (released after Turbo Pascal 7). The Windows compiler included in Borland Pascal 7 was entitled Borland Pascal for Windows' but presumably was from the same code base as TPW 1.5.

All versions built Windows-compatible programs, and featured a Windows-based IDE, as opposed to the DOS-based text IDE in Turbo Pascal. The IDE and editor commands conformed to Microsoft Windows user interface guidelines instead of the classic TP user interface. The support for Windows programs required the use of the ObjectWindows library, similar but not identical to the first release of Borland C++, and radically different from the earlier DOS Turbo Vision environment. Turbo Pascal was essentially made obsolete for the Windows platform by the release of Delphi. The Delphi compiler can be used to produce command-line programs, so that the use of Turbo and Borland Pascal became unnecessary.

Apple Macintosh version

Borland released Turbo Pascal for Macintosh in 1985. Much like versions 1 to 3 for other operating systems, it was written in compact assembly language and had a very powerful IDE, but not a good debugger. Borland did not support this product very well, although they issued a version 1.1, patched to run on the 32-bit Macintosh II. Macintosh support was dropped soon after.

Successors

By 1995, Borland had dropped Turbo Pascal and replaced it with the RAD environment Delphi, which included the language Object Pascal. Native 32-bit Delphi versions still support the more portable Pascal enhancements (i.e. those that are not 16-bit centric) of the earlier products including the earlier static object model.

Several Turbo Pascal compatibles also exist. The best-known ones are Free Pascal and Virtual Pascal.

Legacy

Borland Pascal is still taught at secondary, sixth form level and University level in the island of Malta, at other colleges in Germany and the USA and at some secondary schools in Belgium, Romania, Serbia, Moldova and Bulgaria. It was the state-approved educational programming language for all South African secondary schools until 2002. Today it continues to be taught in some universities around the world as an introduction to computer programming, usually continuing on with C and/or Java. Some lecturers prefer to use Borland Pascal 7 or Turbo Pascal 5.5 as it is very simple (in comparison to more modern IDEs like Microsoft Visual Studio or Borland JBuilder), introduces students less familiar with computing to using the keyboard and keyboard shortcuts (TP 5.5 has no mouse support), familiarises students with DOS commands (which are largely the same as those of Microsoft Windows's Command Prompt) and is available legally for free download.

Issue with CRT unit on fast processors

Several versions of Turbo Pascal, including the last version 7, include a CRT unit used by many fullscreen text mode applications. This unit contains code in its initialisation section to determine the CPU speed for calibration of delay loops. This code fails on processors with a speed greater than about 200 MHz and aborts immediately after loading the program with Runtime error 200. This is caused by using a counter to count the number of times a loop can be executed in a fixed time, measured by the real-time clock. When Turbo Pascal was developed it ran on machines with CPUs running at 1 to 8 MHz, and no thought was given to the possibility of much higher speeds; but at 200MHz the 16-bit counter overflows. More than one patch has been required as processor speeds increased.

Programs compiled with this error can be patched by a tool named TPPATCH or equivalent, or by loading a Terminate and Stay Resident program loaded before running the faulty program.

In many cases MS-DOS programs not known to have been compiled with Turbo Pascal fail with Runtime error 200; the above patch is worth trying.

For running the Turbo and Borland Pascal compilers on a fast machine, a version of TURBO.TPL patched with a corrected CRT unit to resolve the error can be used to generate programs compatible with fast machines. See links below.

Graphic

Turbo Pascal uses Borland Graphics Interface.

Sample code

Notes:

  • Historically, Pascal comments are indicated { like this }, or (* like this *), but later versions of Borland Pascal also supported C++-style comments // like this.
  • The line uses crt; is a Borland specific extension to Pascal.
  • Borland's Pascal is not case sensitive.

Samples:

  • This simple program prints the words "Hello World" on the screen.

begin

 WriteLn('Hello World');
end.

  • This asks for a person's name and prints it on the screen.

program WriteName;

var Name: String; { This declares the variable Name as a string }

begin

 Write('Please give your name: ');
Readln(Name); { Readln reads the string printed on the screen }
 WriteLn('Hello ', Name)
end.

See also

References

External links

Search another word or see turbo pascalon Dictionary | Thesaurus |Spanish
Copyright © 2014 Dictionary.com, LLC. All rights reserved.
  • Please Login or Sign Up to use the Recent Searches feature