Consider Again the Pascal Tool Set Distributed by Niklaus

Programming language

Pascal
Major implementations

Paradigm	Imperative structured
Family	Wirth Pascal
Designed by	Niklaus Wirth
First appeared	1970; 52 years ago (1970)
Typing discipline	Static strong prophylactic
Scope	Lexical
Filename extensions	`.pp`, `.pas`, `.inc`
CDC 6000 Embarcadero Delphi ICL 1900 Pascal-P PDP-11 PDP-10 IBM System/370 VSI Pascal Gratis Pascal GNU Pascal
Dialects
Delphi Turbo Pascal UCSD Pascal
Influenced by
ALGOL Westward Simula 67
Influenced
Ada C/AL Component Pascal Get Coffee^[one] ^[2] ^[3] Modula / -ii / -3 Oberon / -ii Object Pascal Oxygene Power Fx Seed7 Standard ML VHDL Structured text

Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a pocket-size, efficient language intended to encourage good programming practices using structured programming and information structuring. Information technology is named in honour of the French mathematician, philosopher and physicist Blaise Pascal.

Based on Wirth'south book Algorithms + Data Structures = Programs, Pascal was developed on the pattern of the ALGOL 60 language. Wirth was involved in the process to improve the linguistic communication equally part of the ALGOL X efforts and proposed a version named ALGOL W. This was non accepted, and the ALGOL X process bogged downwards. In 1968, Wirth decided to abandon the ALGOL X process and further better ALGOL W, releasing this as Pascal in 1970.

On top of ALGOL's scalars and arrays, Pascal enables defining complex datatypes and building dynamic and recursive data structures such as lists, trees and graphs. Pascal has strong typing on all objects, which ways that one blazon of data cannot exist converted to or interpreted as another without explicit conversions. Unlike C (and almost languages in the C-family), Pascal allows nested procedure definitions to any level of depth, and also allows most kinds of definitions and declarations inside subroutines (procedures and functions). A programme is thus syntactically like to a single process or function. This is similar to the block structure of ALGOL 60, just restricted from arbitrary block statements to just procedures and functions.

Pascal became very successful in the 1970s, notably on the burgeoning minicomputer market. Compilers were also bachelor for many microcomputers every bit the field emerged in the late 1970s. Information technology was widely used as a teaching language in university-level programming courses in the 1980s, and also used in production settings for writing commercial software during the same period. It was displaced by the C programming language during the late 1980s and early on 1990s every bit UNIX-based systems became popular, and particularly with the release of C++.

A derivative named Object Pascal designed for object-oriented programming was adult in 1985. This was used by Apple Computer and Borland in the late 1980s and afterward developed into Delphi on the Microsoft Windows platform. Extensions to the Pascal concepts led to the languages Modula-2 and Oberon.

History [edit]

Earlier efforts [edit]

Much of the history of computer language design during the 1960s can exist traced to the ALGOL sixty language. ALGOL was adult during the 1950s with the explicit goal of being able to clearly describe algorithms. It included a number of features for structured programming that remain common in languages to this twenty-four hours.

Soon after its introduction, in 1962 Wirth began working on his dissertation with Helmut Weber on the Euler programming language. Euler was based on ALGOL's syntax and many concepts but was non a derivative. Its primary goal was to add dynamic lists and types, assuasive information technology to be used in roles similar to Lisp. The language was published in 1965.

By this time, a number of problems in ALGOL had been identified, notably the lack of a standardized cord system. The group tasked with maintaining the linguistic communication had begun the ALGOL 10 process to place improvements, calling for submissions. Wirth and Tony Hoare submitted a conservative set of modifications to add strings and clean up some of the syntax. These were considered too small to be worth using as the new standard ALGOL, so Wirth wrote a compiler for the linguistic communication, which became named ALGOL W.

The ALGOL 10 efforts would continue to choose a much more complex linguistic communication, ALGOL 68. The complication of this language led to considerable difficulty producing high-performance compilers, and it was not widely used in the industry. This left an opening for newer languages.

Pascal [edit]

Pascal was influenced past the ALGOL W efforts, with the explicit goals of teaching programming in a structured manner and for the development of system software. ^[4] A generation of students used Pascal as an introductory language in undergraduate courses.

1 of the early successes for the language was the introduction of UCSD Pascal, a version that ran on a custom operating organization that could exist ported to different platforms. A key platform was the Apple tree 2, where it saw widespread employ. This led to Pascal becoming the primary high-level linguistic communication used for development in the Apple Lisa, and later, the Macintosh. Parts of the original Macintosh operating organization were hand-translated into Motorola 68000 assembly language from the Pascal source code.^[5]

The typesetting system TeX by Donald Eastward. Knuth was written in WEB, the original literate programming system, based on Dec PDP-10 Pascal. Successful commercial applications like Adobe Photoshop^[6] were written in Macintosh Programmer's Workshop Pascal, while applications like Full Commander, Skype^[7] and Macromedia Captivate were written in Delphi (Object Pascal). Apollo Computer used Pascal as the systems programming language for its operating systems beginning in 1980.

Variants of Pascal have also been used for everything from research projects to PC games and embedded systems. Newer Pascal compilers be which are widely used.^[8]

Object Pascal [edit]

During work on the Lisa, Larry Tesler began respective with Wirth on the thought of adding object-oriented extensions to the language. This led initially to Clascal, introduced in 1983. As the Lisa plan faded and was replaced past the Macintosh, a further version was created and named Object Pascal. This was introduced on the Mac in 1985 every bit part of the MacApp application framework, and became Apple tree'southward chief development language into the early on 1990s.

The Object Pascal extensions were added to Turbo Pascal with the release of version 5.5 in 1989.^[ix] Over the years, Object Pascal became the ground of the Delphi arrangement for Microsoft Windows, which is notwithstanding used for developing Windows applications, and tin can cross-compile code to other systems. Free Pascal is an open up source, cross-platform alternative with its own graphical IDE called Lazarus.

Implementations [edit]

Early Pascal compilers [edit]

The first Pascal compiler was designed in Zürich for the CDC 6000 serial mainframe computer family. Niklaus Wirth reports that a showtime endeavor to implement it in FORTRAN 66 in 1969 was unsuccessful due to FORTRAN 66's inadequacy to express complex data structures. The 2d attempt was implemented in a C-like language (Scallop past Max Engeli) then translated past hand (past R. Schild) to Pascal itself for boot-strapping.^[x] It was operational by mid-1970. Many Pascal compilers since have been similarly cocky-hosting, that is, the compiler is itself written in Pascal, and the compiler is usually capable of recompiling itself when new features are added to the linguistic communication, or when the compiler is to be ported to a new environment. The GNU Pascal compiler is one notable exception, being written in C.

The starting time successful port of the CDC Pascal compiler to another mainframe was completed by Welsh and Quinn at the Queen's Academy of Belfast (QUB) in 1972. The target was the International Computers Limited (ICL) 1900 series. This compiler, in plough, was the parent of the Pascal compiler for the Information Computer Systems (ICS) Multum minicomputer. The Multum port was developed – with a view to using Pascal equally a systems programming linguistic communication – by Findlay, Cupples, Cavouras and Davis, working at the Section of Calculating Science in Glasgow University. It is thought that Multum Pascal, which was completed in the summer of 1973, may have been the first 16-flake implementation.

A completely new compiler was completed past Welsh et al. at QUB in 1977. It offered a source-language diagnostic characteristic (incorporating profiling, tracing and blazon-enlightened formatted postmortem dumps) that was implemented by Findlay and Watt at Glasgow University. This implementation was ported in 1980 to the ICL 2900 series by a team based at Southampton University and Glasgow University. The Standard Pascal Model Implementation was also based on this compiler, having been adapted, by Welsh and Hay at Manchester University in 1984, to check rigorously for conformity to the BSI 6192/ISO 7185 Standard and to generate lawmaking for a portable abstract machine.

The first Pascal compiler written in North America was constructed at the University of Illinois nether Donald B. Gillies for the PDP-11 and generated native machine code.

The Pascal-P system [edit]

To propagate the language rapidly, a compiler porting kit was created in Zürich that included a compiler that generated so called p-code for a virtual stack machine, i.e., lawmaking that lends itself to reasonably efficient interpretation, forth with an interpreter for that lawmaking – the Pascal-P system. The P-organization compilers were named Pascal-P1, Pascal-P2, Pascal-P3, and Pascal-P4. Pascal-P1 was the first version, and Pascal-P4 was the final to come from Zürich. The version termed Pascal-P1 was coined after the fact for the many different sources for Pascal-P that existed. The compiler was redesigned to enhance portability, and issued every bit Pascal-P2. This lawmaking was later on enhanced to become Pascal-P3, with an intermediate lawmaking backward uniform with Pascal-P2, and Pascal-P4, which was not backward compatible.

The Pascal-P4 compiler–interpreter tin can nonetheless be run and compiled on systems compatible with original Pascal. Notwithstanding, it just accepts a subset of the Pascal language.

Pascal-P5, created exterior the Zürich group, accepts the full Pascal language and includes ISO 7185 compatibility.

UCSD Pascal branched off Pascal-P2, where Kenneth Bowles used it to create the interpretive UCSD p-System. It was 1 of three operating systems available at the launch of the original IBM Personal Estimator.^[11] UCSD Pascal used an intermediate code based on byte values, and thus was one of the earliest bytecode compilers. Pascal-P1 through Pascal-P4 was not, but rather based on the CDC 6600 60-bit word length.

A compiler based on the Pascal-P5 compiler, which created native binary object files, was released for the IBM System/370 mainframe computer by the Australian Atomic Energy Committee; it was named the AAEC Pascal 8000 Compiler after the abridgement of the name of the committee.^[12]

Object Pascal and Turbo Pascal [edit]

Apple Estimator created its ain Lisa Pascal for the Lisa Workshop in 1982, and ported the compiler to the Apple Macintosh and MPW in 1985. In 1985 Larry Tesler, in consultation with Niklaus Wirth, defined Object Pascal and these extensions were incorporated in both the Lisa Pascal and Mac Pascal compilers.

In the 1980s, Anders Hejlsberg wrote the Blue Label Pascal compiler for the Nascom-2. A reimplementation of this compiler for the IBM PC was marketed nether the names Compas Pascal and PolyPascal before information technology was caused by Borland and renamed Turbo Pascal.

Turbo Pascal became hugely popular, cheers to an aggressive pricing strategy, having one of the offset total-screen IDEs, and very fast turnaround fourth dimension (simply seconds to compile, link, and run). It was written and highly optimized entirely in assembly language, making it smaller and faster than much of the contest.

In 1986, Anders ported Turbo Pascal to the Macintosh and incorporated Apple'south Object Pascal extensions into Turbo Pascal. These extensions were so added back into the PC version of Turbo Pascal for version v.v. At the same time Microsoft also implemented the Object Pascal compiler.^[13] ^[14] Turbo Pascal 5.5 had a large influence on the Pascal customs, which began concentrating mainly on the IBM PC in the belatedly 1980s. Many PC hobbyists in search of a structured replacement for BASIC used this product. It also began to be adopted by professional developers. Around the same time a number of concepts were imported from C to let Pascal programmers use the C-based application programming interface (API) of Microsoft Windows directly. These extensions included null-terminated strings, arrow arithmetics, function pointers, an address-of operator, and unsafe typecasts.

Turbo Pascal and other derivatives with unit or module structures are modular programming languages. Nonetheless, it does not provide a nested module concept or qualified import and export of specific symbols.

Other variants [edit]

Super Pascal is a variant that added non-numeric labels, a return statement and expressions every bit names of types.

TMT Pascal was the first Borland-compatible compiler for 32-chip DOS protected manner, Os/2, and Win32 operating systems. The TMT Pascal language was the first one to permit role and operator overloading.

The universities of Wisconsin-Madison, Zürich, Karlsruhe, and Wuppertal adult the Pascal-SC ^[fifteen] ^[16] and Pascal-XSC ^[17] ^[18] ^[19] (Extensions for Scientific Computation) compilers, aimed at programming numerical computations. Development for Pascal-SC started in 1978 supporting ISO 7185 Pascal level 0, but level 2 support was added at a later stage.^[20] Pascal-SC originally targeted the Z80 processor, but was later rewritten for DOS (x86) and 68000. Pascal-XSC has at diverse times been ported to Unix (Linux, SunOS, HP-UX, AIX) and Microsoft/IBM (DOS with EMX, OS/2, Windows) operating systems. Information technology operates by generating intermediate C source lawmaking which is then compiled to a native executable. Some of the Pascal-SC language extensions have been adopted by GNU Pascal.

Pascal Sol was designed around 1983 by a French team to implement a Unix-like system named Sol. It was standard Pascal level-1 (with parameterized array bounds) merely the definition allowed alternative keywords and predefined identifiers in French and the language included a few extensions to ease arrangement programming (e.g. an equivalent to lseek).^[21] The Sol team later on moved to the ChorusOS projection to design a distributed operating system.^[22]

IP Pascal was an implementation of the Pascal programming language using Micropolis DOS, only was moved rapidly to CP/M-lxxx running on the Z80. It was moved to the 80386 machine types in 1994, and exists today every bit Windows/XP and Linux implementations. In 2008, the organization was brought upward to a new level and the resulting language termed "Pascaline" (after Pascal'southward reckoner). It includes objects, namespace controls, dynamic arrays, and many other extensions, and generally features the same functionality and blazon protection as C#. It is the only such implementation that is besides uniform with the original Pascal implementation, which is standardized as ISO 7185.

Linguistic communication constructs [edit]

Pascal, in its original class, is a purely procedural language and includes the traditional array of ALGOL-like control structures with reserved words such equally if, then, else, while, for, and case, ranging on a single argument or a begin-finish statements block. Pascal also has data structuring constructs not included in the original ALGOL 60 types, like records, variants, pointers, enumerations, and sets and process pointers. Such constructs were in office inherited or inspired from Simula 67, ALGOL 68, Niklaus Wirth'due south own ALGOL W and suggestions by C. A. R. Hoare.

Pascal programs start with the plan keyword with a listing of external file descriptors as parameters^[23] (not required in Turbo Pascal etc.); and then follows the chief cake bracketed by the begin and terminate keywords. Semicolons split up statements, and the full stop (i.east., a period) ends the whole program (or unit). Letter case is ignored in Pascal source.

Here is an example of the source code in apply for a very simple "Hello, World!" program:

                                program                HelloWorld                (                output                )                ;                begin                Write                (                'Hello, World!'                )                {No ";" is required later the last argument of a block -                                  adding one adds a "zippo argument" to the plan, which is ignored by the compiler.}                end                .

Information types [edit]

A type in Pascal, and in several other pop programming languages, defines a variable in such a way that it defines a range of values which the variable is capable of storing, and it also defines a set up of operations that are permissible to be performed on variables of that type. The predefined types are:

Data blazon	Blazon of values which the variable is capable of storing
integer	integer (whole) numbers
real	floating-indicate numbers
boolean	the values True or Simulated
char	a single graphic symbol from an ordered character gear up
gear up	equivalent to a packed array of boolean values
array	a countable group of whatsoever of the preceding data types
string	a sequence or "string" of characters (strings were not part of the original language; one could create an "array of char" and access the individual characters as an array, but referencing information technology as a string straight was not possible until subsequently dialects of Pascal added this functionality.)

The range of values allowed for each (except boolean) is implementation defined. Functions are provided for some data conversions. For conversion of real to integer, the post-obit functions are available: circular (which rounds to integer using banker's rounding) and trunc (rounds towards nothing).

The programmer has the freedom to define other commonly used data types (e.g. byte, string, etc.) in terms of the predefined types using Pascal'south type announcement facility, for example

                                blazon                byte                =                0                ..                255                ;                signed_byte                =                -                128                ..                127                ;                string                =                packed                assortment                [                1                ..                255                ]                of                char                ;

(Ofttimes-used types like byte and string are already divers in many implementations.)

Subrange types [edit]

Subranges of whatsoever ordinal data type (any elementary type except real) can also be made:

                                var                x                :                1                ..                10                ;                y                :                'a'                ..                'z'                ;

Set types [edit]

In contrast with other programming languages from its time, Pascal supports a ready type:^[24]

                                var                Set1                :                set                of                1                ..                10                ;                Set2                :                set                of                'a'                ..                'z'                ;

A gear up is a key concept for modern mathematics, and they may exist used in many algorithms. Such a feature is useful and may be faster than an equivalent construct in a language that does not support sets. For case, for many Pascal compilers:

executes faster than:

                                if                (                i                >                four                )                and                (                i                <                11                )                and then                ...

Sets of not-face-to-face values can be particularly useful, in terms of both functioning and readability:

                                if                i                in                [                0                ..                iii                ,                7                ,                nine                ,                12                ..                fifteen                ]                and so                ...

For these examples, which involve sets over small domains, the improved functioning is usually accomplished past the compiler representing set variables every bit bit vectors. The set up operators can and so exist implemented efficiently as bitwise machine lawmaking operations.

Matrimony types [edit]

In Pascal, there are two ways to create unions. Ane is the standard way through a variant record. The second is a nonstandard means of declaring a variable as accented, significant it is placed at the same retentiveness location as another variable or at an absolute address. While all Pascal compilers support variant records, only some back up accented variables.

For the purposes of this instance, the post-obit are all integer types: a byte is 8-bits, a word is 16-bits, and an integer is 32-bits.

The post-obit case shows the non-standard absolute grade:

                            VAR              A              :              Integer              ;              B              :              Array              [              1              ..              four              ]              of              Byte              absolute              A              ;              C              :              Integer              absolute              0              ;

In the first example, each of the elements of the array B maps to one of the specific bytes of the variable A. In the second example, the variable C is assigned to the exact machine accost 0.

In the post-obit example, a record has variants, some of which share the same location equally others:

                            Blazon              TSystemTime              =              tape              Yr              ,              Month              ,              DayOfWeek              ,              Day              :              give-and-take              ;              Hour              ,              Minute              ,              Second              ,              MilliSecond              :              word              ;              end              ;              TPerson              =              RECORD              FirstName              ,              Lastname              :              String              ;              Birthdate              :              TSystemTime              ;              Example              isPregnant              :              Boolean              of              true              :              (              DateDue              :              TSystemTime              )              ;              false              :              (              isPlanningPregnancy              :              Boolean              )              ;              END              ;

Type declarations [edit]

Types tin be defined from other types using type declarations:

                                type                x                =                integer                ;                y                =                10                ;                ...

Further, complex types can be constructed from uncomplicated types:

                                type                a                =                assortment                [                1                ..                10                ]                of                integer                ;                b                =                record                ten                :                integer                ;                y                :                char                {extra semicolon not strictly required}                end                ;                c                =                file                of                a                ;

File type [edit]

As shown in the example above, Pascal files are sequences of components. Every file has a buffer variable which is denoted by f^. The procedures go (for reading) and put (for writing) move the buffer variable to the next chemical element. Read is introduced such that read(f, x) is the same as ten := f^; get(f);. Write is introduced such that write(f, x) is the aforementioned as f^ := x; put(f); The blazon text is predefined as file of char. While the buffer variable could be used for inspecting the next character to be used (check for a digit before reading an integer), this leads to serious issues with interactive programs in early implementations, but was solved later with the "lazy I/O" concept.

In Jensen & Wirth Pascal, strings are represented as packed arrays of chars; they therefore take fixed length and are usually space-padded.

Arrow types [edit]

Pascal supports the apply of pointers:

                                type                pNode                =                ^                Node                ;                Node                =                record                a                :                integer                ;                b                :                char                ;                c                :                pNode                end                ;                var                NodePtr                :                pNode                ;                IntPtr                :                ^                integer                ;

Here the variable NodePtr is a arrow to the data blazon Node, a record. Pointers tin can be used before they are alleged. This is a frontwards annunciation, an exception to the rule that things must be alleged before they are used.

To create a new record and assign the value 10 and character A to the fields a and b in the record, and to initialise the arrow c to the null pointer ("NIL" in Pascal), the statements would be:

                                New                (                NodePtr                )                ;                ...                NodePtr                ^.                a                :=                x                ;                NodePtr                ^.                b                :=                'A'                ;                NodePtr                ^.                c                :=                Nil                ;                ...

This could also be done using the with statement, as follows:

                                New                (                NodePtr                )                ;                ...                with                NodePtr                ^                do                begin                a                :=                10                ;                b                :=                'A'                ;                c                :=                Zero                end                ;                ...

Within of the scope of the with statement, a and b refer to the subfields of the record pointer NodePtr and not to the tape Node or the pointer type pNode.

Linked lists, stacks and queues can be created by including a pointer type field (c) in the record.

Unlike many languages that characteristic pointers, Pascal just allows pointers to reference dynamically created variables that are anonymous, and does not allow them to reference standard static or local variables. Pointers also must take an associated type, and a arrow to one blazon is not compatible with a pointer to another blazon (e.g. a pointer to a char is not compatible with a arrow to an integer). This helps eliminate the blazon security issues inherent with other pointer implementations, particularly those used for PL/I or C. It besides removes some risks acquired by dangling pointers, merely the ability to dynamically deallocate referenced space by using the dispose function (which has the same outcome equally the gratis library function constitute in C) means that the risk of dangling pointers has not been entirely eliminated^[25] as it has in languages such as Java and C#, which provide automatic garbage collection (but which practise not entirely eliminate the related problem of retention leaks).

Some of these restrictions can be lifted in newer dialects.

Control structures [edit]

Pascal is a structured programming linguistic communication, meaning that the menses of control is structured into standard statements, usually without 'goto' commands.

                                while                a                <>                b                practise                WriteLn                (                'Waiting'                )                ;                if                a                >                b                then                WriteLn                (                'Status met'                )                {no semicolon allowed before else}                else                WriteLn                (                'Condition not met'                )                ;                for                i                :=                ane                to                10                do                {no semicolon hither every bit it would detach the side by side statement}                WriteLn                (                'Iteration: '                ,                i                )                ;                repeat                a                :=                a                +                ane                until                a                =                10                ;                example                i                of                0                :                Write                (                'zero'                )                ;                1                :                Write                (                'one'                )                ;                ii                :                Write                (                '2'                )                ;                3                ,                iv                ,                five                ,                6                ,                7                ,                8                ,                9                ,                ten                :                Write                (                '?'                )                end                ;

Procedures and functions [edit]

Pascal structures programs into procedures and functions. Generally, a procedure is used for its side furnishings, whereas a role is used for its return value.

                                program                Printing                ;                var                i                :                integer                ;                procedure                PrintAnInteger                (                j                :                integer                )                ;                begin                ...                end                ;                function                triple                (                const                10                :                integer                )                :                integer                ;                brainstorm                triple                :=                10                *                3                stop                ;                begin                { primary program }                ...                PrintAnInteger                (                i                )                ;                PrintAnInteger                (                triple                (                i                ))                cease                .

Procedures and functions can be nested to any depth, and the 'program' construct is the logical outermost block.

By default, parameters are passed by value. If 'var' precedes a parameter'south proper name, it is passed past reference.

Each procedure or function can accept its ain declarations of goto labels, constants, types, variables, and other procedures and functions, which must all be in that order. This ordering requirement was originally intended to allow efficient single-pass compilation. All the same, in some dialects (such as Delphi) the strict ordering requirement of declaration sections has been relaxed.

Semicolons as argument separators [edit]

Pascal adopted many language syntax features from the ALGOL language, including the utilize of a semicolon as a statement separator. This is in contrast to other languages, such equally PL/I and C, which use the semicolon as a statement terminator. No semicolon is needed before the end keyword of a tape blazon annunciation, a block, or a instance statement; before the until keyword of a repeat statement; and before the else keyword of an if statement.

The presence of an extra semicolon was not permitted in early versions of Pascal. However, the addition of ALGOL-like empty statements in the 1973 Revised Report and later changes to the linguistic communication in ISO 7185:1983 now let for optional semicolons in most of these cases. A semicolon is even so not permitted immediately before the else keyword in an if statement, considering the else follows a single statement, non a statement sequence. In the case of nested ifs, a semicolon cannot be used to avoid the dangling else trouble (where the inner if does non have an else, but the outer if does) past putatively terminating the nested if with a semicolon – this instead terminates both if clauses. Instead, an explicit begin...terminate block must be used.^[26]

Resource [edit]

Compilers and interpreters [edit]

Several Pascal compilers and interpreters are bachelor for general use:

Delphi is Embarcadero's (formerly Borland/CodeGear) flagship rapid application development (RAD) product. It uses the Object Pascal linguistic communication (termed 'Delphi' by Borland), descended from Pascal, to create applications for Windows, macOS, iOS, and Android. The .Net support that existed from D8 through D2005, D2006, and D2007 has been terminated, and replaced by a new language (Prism, which is rebranded Oxygene, see beneath) that is not fully backward uniform. In recent years Unicode support and generics were added (D2009, D2010, Delphi XE).
Complimentary Pascal is a cross-platform compiler written in Object Pascal (and is self-hosting). It is aimed at providing a convenient and powerful compiler, both able to compile legacy applications and to be the means to develop new ones. It is distributed under the GNU General Public License (GNU GPL), while packages and runtime library come under a modified GNU Bottom General Public License (GNU LGPL). In addition to compatibility modes for Turbo Pascal, Delphi, and Mac Pascal, information technology has its own procedural and object-oriented syntax modes with support for extended features such as operator overloading. It supports many platforms and operating systems. Current versions also characteristic an ISO mode.
Turbo51 is a complimentary Pascal compiler for the Intel 8051 family unit of microcontrollers, with Turbo Pascal 7 syntax.
Oxygene (formerly named Chrome) is an Object Pascal compiler for the .NET and Mono platforms. It was created and is sold by RemObjects Software, and sold for a while by Embarcadero equally the backend compiler of Prism.
Kylix was a descendant of Delphi, with support for the Linux operating system and an improved object library. It is no longer supported. Compiler and IDE are available now for non-commercial utilize.
GNU Pascal Compiler (GPC) is the Pascal compiler of the GNU Compiler Collection (GCC). The compiler is written in C, the runtime library more often than not in Pascal. Distributed nether the GNU General Public License, it runs on many platforms and operating systems. It supports the ANSI/ISO standard languages and has partial Turbo Pascal dialect back up. One of the more painful omissions is the absence of a 100% Turbo Pascal-compatible (short)string blazon. Support for Borland Delphi and other linguistic communication variants is quite limited. In that location is some support for Mac-pascal, however.
Virtual Pascal was created by Vitaly Miryanov in 1995 every bit a native Bone/2 compiler compatible with Borland Pascal syntax. Then, it had been commercially developed by fPrint, adding Win32 support, and in 2000 it became freeware. Today it tin compile for Win32, Bone/2, and Linux, and is mostly compatible with Borland Pascal and Delphi. Evolution was canceled on April four, 2005.
P4 compiler, the basis for many subsequent Pascal-implemented-in-Pascal compilers. It implements a subset of full Pascal.
P5 compiler is an ISO 7185 (total Pascal) adaption of P4.
Smart Mobile Studio is a Pascal to HTML5/Javascript compiler
Turbo Pascal was the ascendant Pascal compiler for PCs during the 1980s and early 1990s, pop both because of its powerful extensions and extremely short compilation times. Turbo Pascal was compactly written and could compile, run, and debug all from retentiveness without accessing disk. Slow floppy disk drives were common for programmers at the fourth dimension, further magnifying Turbo Pascal's speed reward. Currently, older versions of Turbo Pascal (up to 5.v) are bachelor for free download from Borland'due south site.
IP Pascal implements the language "Pascaline" (named after Pascal'south reckoner), which is a highly extended Pascal compatible with original Pascal co-ordinate to ISO 7185. It features modules with namespace control, including parallel tasking modules with semaphores, objects, dynamic arrays of whatsoever dimensions that are allocated at runtime, overloads, overrides, and many other extensions. IP Pascal has a built-in portability library that is custom tailored to the Pascal linguistic communication. For example, a standard text output awarding from 1970's original Pascal can be recompiled to work in a window and even have graphical constructs added.
Pascal-XT was created by Siemens for their mainframe operating systems BS2000 and SINIX.
PocketStudio is a Pascal subset compiler and RAD tool for Palm Os and MC68xxx processors with some of its own extensions to assist interfacing with the Palm Os API. It resembles Delphi and Lazarus with a visual form designer, an object inspector and a source code editor.
MIDletPascal – A Pascal compiler and IDE that generates small and fast Java bytecode specifically designed to create software for mobiles.
Vector Pascal is a language for SIMD instruction sets such as the MMX and the AMD 3d Now, supporting all Intel and AMD processors, and Sony's PlayStation 2 Emotion Engine.
Morfik Pascal allows the development of Web applications entirely written in Object Pascal (both server and browser side).
WDSibyl – Visual Evolution Environs and Pascal compiler for Win32 and Os/2.
PP Compiler, a compiler for Palm OS that runs directly on the handheld calculator.
CDC 6000 Pascal compiler is the source code for the starting time (CDC 6000) Pascal compiler.
Pascal-S^[27]
AmigaPascal is a costless Pascal compiler for the Amiga figurer.
VSI Pascal (originally VAX Pascal) is an ISO Standard Pascal compliant compiler for the OpenVMS operating system.
Stony Brook Pascal+ was a 16-bit (later on 32-bit) optimizing compiler for DOS and OS/2, marketed as a direct replacement for Turbo Pascal, but producing code that executed at least twice as fast.

IDEs [edit]

Dev-Pascal is a Pascal IDE that was designed in Borland Delphi and which supports Free Pascal and GNU Pascal as backends.
Lazarus is a free Delphi-similar visual cantankerous-platform IDE for rapid awarding development (RAD). Based on Free Pascal, Lazarus is available for numerous platforms including Linux, FreeBSD, macOS and Microsoft Windows.
Burn down (macOS) and Water (Windows) for the Oxygene and the Elements Compiler

Libraries [edit]

WOL Library for creating GUI applications with the Free Pascal Compiler.

Standards [edit]

ISO/IEC 7185:1990 Pascal [edit]

In 1983, the linguistic communication was standardized in the international standard IEC/ISO 7185^[28] and several local country-specific standards, including the American ANSI/IEEE770X3.97-1983, and ISO 7185:1983. These two standards differed only in that the ISO standard included a "level 1" extension for conformant arrays (an array where the boundaries of the assortment are not known until run fourth dimension), where ANSI did not allow for this extension to the original (Wirth version) language. In 1989, ISO 7185 was revised (ISO 7185:1990) to correct various errors and ambiguities institute in the original document.

The ISO 7185 was stated to exist a clarification of Wirth'due south 1974 linguistic communication every bit detailed past the User Manual and Report [Jensen and Wirth], only was also notable for adding "Conformant Array Parameters" as a level 1 to the standard, level 0 being Pascal without conformant arrays. This add-on was made at the asking of C. A. R. Hoare, and with the approval of Niklaus Wirth. The precipitating cause was that Hoare wanted to create a Pascal version of the (NAG) Numerical Algorithms Library, which had originally been written in FORTRAN, and found that information technology was not possible to exercise so without an extension that would allow assortment parameters of varying size. Like considerations motivated the inclusion in ISO 7185 of the facility to specify the parameter types of procedural and functional parameters.

Niklaus Wirth himself referred to the 1974 language as "the Standard", for case, to differentiate it from the machine specific features of the CDC 6000 compiler. This linguistic communication was documented in The Pascal Report,^[29] the second office of the "Pascal users manual and report".

On the large machines (mainframes and minicomputers) Pascal originated on, the standards were mostly followed. On the IBM PC, they were not. On IBM PCs, the Borland standards Turbo Pascal and Delphi have the greatest number of users. Thus, it is typically important to understand whether a particular implementation corresponds to the original Pascal language, or a Borland dialect of information technology.

The IBM PC versions of the language began to differ with the advent of UCSD Pascal, an interpreted implementation that featured several extensions to the language, forth with several omissions and changes. Many UCSD language features survive today, including in Borland's dialect.

ISO/IEC 10206:1990 Extended Pascal [edit]

This section needs expansion. You lot can help by adding to it. (February 2018)

In 1990, an extended Pascal standard was created as ISO/IEC 10206,^[30] which is identical in technical content^[31] to IEEE/ANSI 770X3.160-1989^[32] Equally of 2019, Support of Extended Pascal in FreePascal Compiler is planned.^[33]

Variations [edit]

Niklaus Wirth's Zürich version of Pascal was issued outside ETH in two basic forms: the CDC 6000 compiler source, and a porting kit called Pascal-P system. The Pascal-P compiler left out several features of the full language that were not required to bootstrap the compiler. For case, procedures and functions used as parameters, undiscriminated variant records, packing, dispose, interprocedural gotos and other features of the full compiler were omitted.

UCSD Pascal, nether Professor Kenneth Bowles, was based on the Pascal-P2 kit, and consequently shared several of the Pascal-P language restrictions. UCSD Pascal was later adopted equally Apple tree Pascal, and continued through several versions there. Although UCSD Pascal actually expanded the subset Pascal in the Pascal-P kit by calculation back standard Pascal constructs, it was however non a complete standard installation of Pascal.

In the early 1990s, Alan Burns and Geoff Davies developed Pascal-FC, an extension to Pl/0 (from the Niklaus' book Algorithms + Data Structures = Programs). Several constructs were added to use Pascal-FC every bit a teaching tool for Concurrent Programming (such every bit semaphores, monitors, channels, remote-invocation and resources). To be able to demonstrate concurrency, the compiler output (a kind of P-lawmaking) could then be executed on a virtual machine. This virtual automobile non but simulated a normal – fair – environment, but could also simulate farthermost conditions (unfair mode).

Borland-like Pascal compilers [edit]

Borland's Turbo Pascal, written past Anders Hejlsberg, was written in assembly language independent of UCSD and the Zürich compilers. However, it adopted much of the same subset and extensions as the UCSD compiler. This is probably considering the UCSD arrangement was the most mutual Pascal system suitable for developing applications on the resource-limited microprocessor systems bachelor at that fourth dimension.

The shrink-wrapped Turbo Pascal version 3 and later incarnations, including Borland'due south Object Pascal and Delphi and not-Borland most-compatibles became popular with programmers including shareware authors, and so the SWAG library of Pascal lawmaking features a large corporeality of code written with such versions as Delphi in mind.

Software products (compilers, and IDE/Rapid Application Evolution (RAD)) in this category:

Turbo Pascal – "TURBO.EXE" upward to version 7, and Turbo Pascal for Windows ("TPW") and Turbo Pascal for Macintosh.
Pure Pascal and HiSPeed Pascal two Pascal language Surroundings for the Atari ST range of computers.
Borland Pascal vii – A professional version of Turbo Pascal line which targeted both DOS and Windows.
Object Pascal – an extension of the Pascal language that was developed at Apple Computer by a team led by Larry Tesler in consultation with Niklaus Wirth, the inventor of Pascal; its features were added to Borland'southward Turbo Pascal for Macintosh and in 1989 for Turbo Pascal 5.5 for DOS.
Delphi – Object Pascal is essentially its underlying language.
Free Pascal compiler (FPC) – Free Pascal adopted the de facto standard dialect of Pascal programmers, Borland Pascal and, subsequently, Delphi. Freepascal also supports both ISO standards.
PascalABC.Net – a new generation Pascal programming linguistic communication including compiler and IDE.
Borland Kylix is a compiler and IDE formerly sold by Borland, but afterward discontinued. It is a Linux version of the Borland Delphi software development environment and C++Architect.
Lazarus – like to Kylix in function, is a free cross-platform visual IDE for RAD using the Gratis Pascal compiler, which supports dialects of Object Pascal to varying degrees.
Virtual Pascal – VP2/1 is a fully Borland Pascal– and Borland Delphi–compatible 32-bit Pascal compiler for Os/2 and Windows 32 (with a Linux version "on the fashion").^[34]
Sybil is an open up source Delphi-like IDE and compiler; implementations include:
- WDSibyl^[35] for Microsoft Windows and OS/2, a commercial Borland Pascal compatible environment released by a visitor named Speedsoft that was later developed into a Delphi-similar rapid application development (RAD) surround named Sybil and and then open up sourced under the GPL when that visitor closed downward;
- Open Sybil, which is an ongoing projection, an open up source tool for Os/two and eCS that was originally based on Speedsoft's WDsybl Sibyl Portable Component Classes (SPCC) and Sibyl Visual Development Tool (SVDE) sources, but now its core is IBM System Object Model (SOM), WPS and OpenDoc.^[36]

List of related standards [edit]

ISO 8651-2:1988 Information processing systems – Computer graphics – Graphical Kernel Arrangement (GKS) language bindings – Part two: Pascal

Reception [edit]

Pascal generated a wide variety of responses in the calculating customs, both critical and costless.

Early on criticism [edit]

While very popular in the 1980s and early 1990s, implementations of Pascal that closely followed Wirth's initial definition of the language were widely criticized as existence unsuitable for use exterior didactics. Brian Kernighan, who popularized the C linguistic communication, outlined his most notable criticisms of Pascal equally early as 1981 in his commodity "Why Pascal is Not My Favorite Programming Language".^[37] The almost serious problem Kernighan described was that array sizes and string lengths were role of the type, so it was non possible to write a function that would accept variable-length arrays or even strings every bit parameters. This fabricated information technology unfeasible to write, for example, a sorting library. Kernighan also criticized the unpredictable social club of evaluation of boolean expressions, poor library support, and lack of static variables, and raised a number of smaller issues. Also, he stated that the language did non provide any simple constructs to "escape" (knowingly and forcibly ignore) restrictions and limitations. More general complaints from other sources^[25] ^[38] noted that the scope of declarations was non clearly divers in the original linguistic communication definition, which sometimes had serious consequences when using forward declarations to define pointer types, or when record declarations led to mutual recursion, or when an identifier may or may not accept been used in an enumeration list. Another difficulty was that, like ALGOL sixty, the language did not permit procedures or functions passed equally parameters to predefine the expected blazon of their parameters.

Despite initial criticisms, Pascal connected to evolve, and most of Kernighan's points practice not utilize to versions of the language which were enhanced to be suitable for commercial production evolution, such as Borland'south Turbo Pascal. As Kernighan predicted in his commodity, most of the extensions to prepare these problems were incompatible from compiler to compiler. Since the early on 1990s, withal, virtually of the varieties seem condensed into 2 categories: ISO and Borland-like. Extended Pascal addresses many of these early criticisms. It supports variable-length strings, variable initialization, separate compilation, short-circuit boolean operators, and default (otherwise) clauses for case statements.^[39]

See besides [edit]

Ada (programming language)
Concurrent Pascal
Comparing of Pascal and Borland Delphi
Comparison of Pascal and C
Modula-two
Oberon (programming language)
Object Pascal
PascalCase
Standard ML

References [edit]

^ "Virtually Microsoft's "Delegates"". Archived from the original on 2012-06-27. Nosotros looked very carefully at Delphi Object Pascal and congenital a working prototype of bound method references in lodge to empathise their interaction with the Java programming language and its APIs ... Our decision was that bound method references are unnecessary and detrimental to the language. This conclusion was made in consultation with Borland International, who had previous experience with bound method references in Delphi Object Pascal.
^ TechMetrix Enquiry (1999). "History of Java" (PDF). Java Awarding Servers Report. Archived from the original (PDF) on 2010-12-29. The project went alee under the name "green" and the language was based on an old model of UCSD Pascal, which makes it possible to generate interpretive code
^ "A Conversation with James Gosling – ACM Queue". Archived from the original on 16 July 2015. Retrieved 11 August 2015.
^ Wirth, Niklaus (2000). "The Development of Procedural Programming Languages Personal Contributions and Perspectives". Modular Programming Languages. Lecture Notes in Figurer Scientific discipline. Vol. 1897. pp. 1–10. doi:10.1007/10722581_1. ISBN978-3-540-67958-five.
^ Hertzfeld, Andy. "Hungarian sociology.org Archived 2015-11-18 at the Wayback Machine: Macintosh Stories. Retrieved 2012-03-06.
^ https://world wide web.computerhistory.org/atchm/adobe-photoshop-source-lawmaking/ Archived 2014-05-07 at the Wayback Machine, Adobe Photoshop Source Lawmaking
^ "RAD Studio Application Showcase". 2021-10-29.
^ tiobe.com Archived 2012-03-xv at the Wayback Car, Programming Community Index for Jan 2011.
^ "Antiquarian Software: Turbo Pascal v5.5".
^ Computers and Computing. A Personal Perspective. Archived 2017-05-ten at the Wayback Machine by Niklaus Wirth
^ cbi.umn.edu, "An Interview with John Brackett and Doug Ross"^{[ permanent dead link ]}, p15, Charles Babbage Institute, 2004
^ Australian Atomic Energy Commission Research Institution, Lucas Heights, Nuclear Science and Technology Co-operative Report, Divisional Inquiry (PDF). International Atomic Energy Agency (IEAE) (Report). 1977. p. 22.
^ Jon Udell, Crash of the Object-Oriented Pascals, BYTE, July, 1989.
^ M. I. Trofimov, The End of Pascal?, BYTE, March, 1990, p. 36.
^ Rall, L. B. (1987). "An introduction to the scientific calculating linguistic communication Pascal-SC". Computers. 14: 53–69. doi:ten.1016/0898-1221(87)90181-7.
^ PI (1986-08-29). "Cadmus jetzt mit Kulisch-Arithmetik - Uni Karlsruhe gibt Pascal-Compiler nach München" [Cadmus now comes with Kulisch arithmetic - University Karlsruhe delivers Pascal compiler to Munich]. Computerwoche (in High german). Munich – Karlsruhe, Germany: IDG Business organization Media GmbH. Archived from the original on 2016-05-30. Retrieved 2016-05-30 .
^ "Pascal-XSC: Pascal for Extended Scientific Computing". Archived from the original on 2014-01-05.
^ "XSC Software". Archived from the original on 1 November 2015. Retrieved 11 August 2015.
^ "Universitaet Wuppertal: Wissenschaftliches Rechnen / Softwaretechnologie". Archived from the original on half dozen November 2015. Retrieved 11 August 2015.
^ Bamberger, Lothar; Davenport, James H.; Fischer, Hans-Christoph; Kok, Jan; Schumacher, Günter; Ullrich, Christian; Wallis, Peter J. 50.; Winter, Dik T.; Wolff von Gudenberg, Jürgen (1990). Wallis, Peter J. L. (ed.). Improving Floating-Indicate Programming (1st ed.). Bath, United Kingdom: John Wiley & Sons Ltd. ISBN0-471-92437-seven.
^ Michel Gien, "The SOL Operating Arrangement", in Usenix Summer '83 Conference, Toronto, ON, (July 1983), pp. 75–78
^ cs.berkeley.edu Archived 2015-02-07 at the Wayback Automobile
^ Pascal ISO 7185:1990 Archived 2012-06-17 at the Wayback Machine 6.10
^ Mandell, Steven L. (1987). Pascal Programming Today . W Publishing Company. ISBN978-0-314-33935-five.
^ ^a ^b J. Welsh, W. J. Sneeringer, and C. A. R. Hoare, "Ambiguities and Insecurities in Pascal", Software: Practice and Experience 7, pp. 685–696 (1977)
^ Pascal, Nell Dale and Chip Weems, "Dangling Else", p. 160–161 Archived 2017-03-18 at the Wayback Motorcar
^ "Pascal-S: A Subset and Its Implementation", N. Wirth in Pascal – The Language and Its Implementation, past D.West. Barron, Wiley 1979.
^ ISO/IEC 7185:1990 Pascal (PDF). Archived from the original (PDF) on 27 January 2016. Retrieved 16 September 2014.
^ Wirth, Niklaus (July 1973). The Programming Language Pascal (Revised Report). ETH Zürich. doi:10.3929/ethz-a-000814158.
^ Extended Pascal: ISO/IEC 10206:1990. Archived from the original on 2016-03-27. Retrieved xvi September 2014.
^ "Linguistic communication standards: Pascal, Extended Pascal, Fortan". Archived from the original on 2014-07-14. Retrieved sixteen September 2014.
^ 770X3.160-1989 – IEEE/ANSI Standard for the Programming Language Extended Pascal. 1990. doi:x.1109/IEEESTD.1990.101061. ISBN978-0-7381-4247-0.
^ "Extended Pascal - Free Pascal wiki".
^ "Virtual Pascal for OS/2". Archived from the original on 30 August 2011. Retrieved 3 Apr 2016.
^ Wolfgang (October 15, 2020). "WDSibyl: Visual Development Environment". WDSibyl.org. Archived from the original on 2020-02-12. Retrieved 2020-04-20 .
^ "netlabs.org – Project: Open Sibyl". Archived from the original on 4 March 2016. Retrieved 3 April 2016.
^ Brian West. Kernighan (1981). "Why Pascal is Not My Favorite Programming Linguistic communication". Archived 2009-04-28 at the Wayback Machine
^ O. Lecarme, P. Desjardins, "More Comments on the Programming Language Pascal", Acta Informatica four, pp. 231–243 (1975).
^ "Extended Pascal". Archived from the original on 2015-10-eighteen.