Comparison of Pascal and C
   HOME

TheInfoList



OR:

The computer
programming language A programming language is a system of notation for writing computer programs. Programming languages are described in terms of their Syntax (programming languages), syntax (form) and semantics (computer science), semantics (meaning), usually def ...
s C and Pascal have similar times of origin, influences, and purposes. Both were used to design (and compile) their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972. Both are descendants of the
ALGOL ALGOL (; short for "Algorithmic Language") is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the ...
language series. ALGOL introduced programming language support for
structured programming Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making specific disciplined use of the structured control flow constructs of selection ( if/then/else) and repet ...
, where programs are constructed of single entry and single exit constructs such as if, while, for and case. Pascal stems directly from
ALGOL W ALGOL W is a programming language. It is based on a proposal for ALGOL X by Niklaus Wirth and Tony Hoare as a successor to ALGOL 60. ALGOL W is a relatively simple upgrade of the original ALGOL 60, adding string, bitstring, complex number a ...
, while it shared some new ideas with
ALGOL 68 ALGOL 68 (short for ''Algorithmic Language 1968'') is an imperative programming language member of the ALGOL family that was conceived as a successor to the ALGOL 60 language, designed with the goal of a much wider scope of application and ...
. The C language is more indirectly related to ALGOL, originally through B, BCPL, and CPL, and later through ALGOL 68 (for example in case of struct and union) and also Pascal (for example in case of enumerations, const,
typedef typedef is a reserved keyword in the programming languages C, C++, and Objective-C. It is used to create an additional name (''alias'') for another data type, but does not create a new type, except in the obscure case of a qualified typedef of ...
and Booleans). Some Pascal dialects also incorporated traits from C. The languages documented here are the Pascal designed by
Niklaus Wirth Niklaus Emil Wirth ( IPA: ) (15 February 1934 – 1 January 2024) was a Swiss computer scientist. He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering. In 1984, he won the Tu ...
, as standardized as ISO 7185 in 1982, and the C designed by Dennis Ritchie, as standardized as C89 in 1989. The reason is that these versions both represent the mature version of the language, and also because they are comparatively close in time. ANSI C and C99 (the later C standards) features, and features of later implementations of Pascal (
Turbo Pascal Turbo Pascal is a software development system that includes a compiler and an integrated development environment (IDE) for the programming language Pascal (programming language), Pascal running on the operating systems CP/M, CP/M-86, and MS-DOS. ...
, Free Pascal etc.) are not included in the comparison, despite the improvements in robustness and functionality that they conferred e.g. Comparison of Pascal and Delphi


Syntax

Syntactically, Pascal is much more ALGOL-like than C. English keywords are retained where C uses punctuation symbols – Pascal has and, or, and mod where C uses &&, , , , and % for example. However, C is more ALGOL-like than Pascal regarding (simple) declarations, retaining the ''type-name'' ''variable-name'' syntax. For example, C can accept declarations at the start of any block, not just the outer block of a function.


Semicolon use

Another, more subtle, difference is the role of the
semicolon The semicolon (or semi-colon) is a symbol commonly used as orthographic punctuation. In the English language, a semicolon is most commonly used to link (in a single sentence) two independent clauses that are closely related in thought, such as ...
. In Pascal, semicolons ''separate'' individual statements within a compound statement; instead in C, they ''terminate'' the statement. In C, they are also syntactically part of the statement (transforming an expression into a statement). This difference manifests mainly in two situations: * in Pascal, a semicolon can never be directly before else, whereas in C, it is mandatory, unless a block statement is used * the last statement before an end or until is not required to be followed by a semicolon A superfluous semicolon can be put on the last line before end, thereby formally inserting an ''empty statement''.


Comments

In traditional C, there are only /* block comments */. In Pascal, there are and (* ''block comments'' *).


Identifiers and keywords

C and Pascal differ in their interpretation of upper and lower case. C is case sensitive while Pascal is not, thus MyLabel and mylabel are distinct names in C but identical in Pascal. In both languages, identifiers consist of letters and digits, with the rule that the first character may not be a digit. In C, the underscore counts as a letter, so even _abc is a valid name. Names with a leading underscore are often used to differentiate special system identifiers in C. Both C and Pascal use keywords (words reserved for use by the language). Examples are if, while, const, for and goto, which are keywords that happen to be common to both languages. In C, the basic built-in type names are also keywords (e.g., int, char) or combinations of keywords (e.g., unsigned char), while in Pascal the built-in type names are predefined normal identifiers.


Definitions, declarations, and blocks

In Pascal,
subroutine In computer programming, a function (also procedure, method, subroutine, routine, or subprogram) is a callable unit of software logic that has a well-defined interface and behavior and can be invoked multiple times. Callable units provide a ...
definitions start with keywords procedure (no value returned) or function (a value is returned) and type definitions with type. In C, all subroutines have function definitions (procedures being void functions) and type definitions use the keyword typedef. Both languages use a mix of keywords and punctuation for definitions of complex types; for instance, arrays are defined by the keyword array in Pascal and by punctuation in C, while
enumeration An enumeration is a complete, ordered listing of all the items in a collection. The term is commonly used in mathematics and computer science to refer to a listing of all of the element (mathematics), elements of a Set (mathematics), set. The pre ...
s are defined by the keyword enum in C but by punctuation in Pascal. In Pascal subroutines, begin and end delimit a block of statements preceded by local declarations, while C functions use "" to delimit a block of statements optionally preceded by declarations : C (before C99) strictly defines that any declarations must occur ''before'' the statements within a particular block but allows blocks to appear within blocks, which is a way to go around this. By its syntax of a subroutine's body, Pascal enforces that declarations occur before statements. Pascal also allows ''definitions'' of types and functionsnot only variable declarations to be encapsulated by function definitions to any level of depth.


Implementation

The grammars of both languages are of a similar size. From an implementation perspective the main difference between the two languages is that to parse C it is necessary to have access to a symbol table for types, while in Pascal there is only one such construct, assignment. For instance, the C fragment X * Y; could be a declaration of Y to be an object whose type is pointer to X, or a statement-expression that multiplies X and Y. In contrast, the corresponding Pascal fragments var Y : ^X; and Z := X * Y; are inherently unambiguous; correct parsing does not require a symbol table.


Simple types


Integers

Pascal requires all variable and function declarations to specify their type explicitly. In traditional C, a type name may be omitted in most contexts and the default type int (which corresponds to
integer An integer is the number zero (0), a positive natural number (1, 2, 3, ...), or the negation of a positive natural number (−1, −2, −3, ...). The negations or additive inverses of the positive natural numbers are referred to as negative in ...
in Pascal) is then implicitly assumed (however, such defaults are considered bad practice in C and are often flagged by warnings). C accommodates different sizes and signed and unsigned modes for integers by using modifiers such as long, short, signed, unsigned, etc. The exact meaning of the resulting integer type is machine-dependent, what ''can'' be guaranteed is that long int is no shorter than int and int is no shorter than short int. However, in C standard, there are at least minimal sizes of types are specified which guarantees char to be a single
byte The byte is a unit of digital information that most commonly consists of eight bits. Historically, the byte was the number of bits used to encode a single character of text in a computer and for this reason it is the smallest addressable un ...
and int to be at least two bytes.


Subranges

In Pascal, a similar end is performed by declaring a ''subrange'' of integer (a compiler may then choose to allocate a smaller amount of storage for the declared variable): type a = 1..100; b = -20..20; c = 0..100000; This subrange feature is not supported by C. A major, if subtle, difference between C and Pascal is how they promote integer operations. In Pascal, the result of an operation is defined for all integer/subrange types, even if intermediate results do not fit into an integer. The result is undefined only if it does not fit into the integer/subrange on the left hand side of the assignment. This may imply an artificial restriction on the range of integer types, or may require slow execution to handle the intermediate results: However, the compiler may take advantage of restricted subranges to produce more efficient code. In C, operands must first be promoted to the size of the required result: intermediate results are undefined if they do not fit into the range of the promoted operands. If range of the required result is greater than the range of operands, this normally produces slow inefficient code, even from a good optimising compiler. However, a C compiler is never required or expected to handle out of range intermediate results: it is the programmers responsibility to ensure that all intermediate results fit into the operand range. Pre-Standard implementations of C as well as Small-C et al. allowed integer and pointer types to be relatively freely intermixed.


Character types

In C the character type is char which is a kind of integer that is no longer than short int, . Expressions such as 'x'+1 are therefore perfectly legal, as are declarations such as int i='i'; and char c=74;. This integer nature of char (one byte) is clearly illustrated by declarations such as unsigned char uc = 255; /* common limit */ signed char sc = -128; /* common negative limit */ Whether the char type should be regarded as signed or unsigned by default is up to the implementation. In Pascal, characters and integers are distinct types. The inbuilt compiler functions ord() and chr() can be used to typecast single characters to the corresponding integer value of the character set in use, and vice versa. e.g. on systems using the ASCII character set ord('1') = 49 and chr(9) is a TAB character.


Boolean types

In Pascal, boolean is an enumerated type. The possible values of boolean are false and true, with ordinal value of false = 0 and true = 1. For conversion to integer, ord is used: i := ord(b); There is no standard function for integer to boolean, however, the conversion is simple in practice: b := i <> 0; C has no Boolean type. C uses binary valued relational operators (<, >,

, !=, <=, >=) which may be regarded as ''Boolean'' in the sense that they always give results that are either zero or one. As all tests (&&, , , , ?:, if, while, etc.) are performed by zero-checks, false is represented by zero, while true is represented by any other value. This is visible in the bool numeric datatype defined in stdbool.h.


Bitwise operations

C allows using bitwise operators to perform Boolean operations. Care must be taken because the semantics are different when operands make use of more than one bit to represent a value. Pascal has another more abstract, high-level method of dealing with bitwise data, sets. Sets allow the programmer to set, clear, intersect, and unite bitwise data values, rather than using direct bitwise operators. Example; Pascal: Status := Status + tickyFlag Status := Status - tickyFlag if (StickyFlag in Status) then ... C: Status , = StickyFlag; Status &= ~StickyFlag; if (Status & StickyFlag) { ... Although bit operations on integers and operations on sets can be considered similar if the sets are implemented using bits, there is no direct parallel between their uses unless a non-standard conversion between integers and sets is possible.


A note on implementation

During expression evaluation, and in ''both languages'', a Boolean value may be internally stored as a single bit, a single byte, a full machine word, a position in the generated code, or as a condition code in a status register, depending on machine, compiler, and situation; these factors are usually more important than the language compiled.


Floating point types

C has a less strict model of floating point types than Pascal. In C, integers may be implicitly converted to floating point numbers, and vice versa (though possible precision loss may be flagged by warnings). In Pascal, integers may be implicitly converted to real, but conversion of real to integer (where information may be lost) must be done explicitly via the functions trunc() and round(), which truncate or round off the fraction, respectively.


Enumeration types

Both C and Pascal include enumeration types. A Pascal example: type color = (red, green, blue); var a: color; A C example: enum color {red, green, blue}; enum color a; The behavior of the types in the two languages however is very different. In Pascal enumerations are ordinal and parsed using ord(), succ() and pred() functions and are distinct from the array structure. In C, enumerations are in fact implemented as arrays and red becomes just a synonym for 0, green for 1, blue for 2, and nothing prevents a value outside this range to be assigned to the variable a. Furthermore, operations like a = a + 1; are strictly forbidden in Pascal; instead, you would use a := succ(a);. In C, enums can be freely converted to and from ints, but in Pascal, the function ord() must be used to convert from enumerated types to integers. Integers cannot be converted to enumerated types, but enumerated types can be used in statements that might otherwise use integers: for a := red to blue do


Structured types


Array types

Both C and Pascal allow arrays of other complex types, including other arrays. However, there the similarity between the languages ends. C arrays are simply defined by a base type and the number of elements: int a IZE and are always indexed from 0 up to SIZE−1 (i.e. modulo SIZE). In Pascal, the range of indices is often specified by a subrange (as introduced under simple types above). The ten elements of var a : array ..9of integer; would be indexed by 0..9 (just as in C in this case). Array indices can be any ordinal data type, however, not just ranges: type TColor = (red, green, blue); (* enumeration *) RGB = array
Color Color (or colour in English in the Commonwealth of Nations, Commonwealth English; American and British English spelling differences#-our, -or, see spelling differences) is the visual perception based on the electromagnetic spectrum. Though co ...
of 0..255; var picture : array ..640, 1..480of RGB var palette : array yte, 0..2of byte
Strings consisting of n (>1) characters are defined as packed arrays with range 1..n.


Arrays and pointers

In C expressions, an identifier representing an array is treated as a constant pointer to the first element of the array, thus, given the declarations int a 0/code> and int *p; the assignment p = a is valid and causes p and a to point to the same array. As the identifier a represents a ''constant'' address, a = p is not valid, however. While arrays in C are fixed, pointers to them are interchangeable. This flexibility allows C to manipulate any length array using the same code. It also leaves the programmer with the responsibility not to write outside the allocated array, as no checks are built in into the language. In Pascal, arrays are a distinct type from pointers. This makes
bounds checking In computer programming, bounds checking is any method of detecting whether a variable is within some bounds before it is used. It is usually used to ensure that a number fits into a given type (range checking), or that a variable being used as ...
for arrays possible from a compiler perspective. Practically all Pascal compilers support range checking as a compile ''option''. The ability to both have arrays that change length at runtime, and be able to check them under language control, is often termed "dynamic arrays". In Pascal the number of elements in each array type is determined at compile-time and cannot be changed during the execution of the program. Hence, it is not possible to define an array whose length depends in any way on program data. C has the ability to initialize arrays of arbitrary length. The
sizeof sizeof is a unary operator in the C and C++ programming languages that evaluates to the storage size of an expression or a data type, measured in units sized as char. Consequently, the expression sizeof(char) evaluates to 1. The number of b ...
operator can be used to obtain the size of a statically initialized array in C code. For instance, in the following code, the terminating index for the loop automatically adjusts should the list of strings be changed. static char *wordlist[] = { "print", "out", "the", "text", "message" }; static int listSize = (sizeof(wordlist)/sizeof(wordlist[0])); int i; for (i=0; i; for (i=listSize-1; i>=0; i--) puts(wordlist ; Pascal has neither array initialization (outside of the case of strings) nor a means of determining arbitrary array sizes at compile time. One way of implementing the above example in Pascal, but without the automatic size adjustment, is: const minlist = 1; maxlist = 5; maxword = 7; type listrange = minlist .. maxlist; wordrange = 1..maxword; word = record contents: packed array ordrangeof char; length: wordrange end; wordlist = array istrangeof word; var i: integer; words: wordlist; procedure CreateList(var w: wordlist); begin w contents := 'print '; w length := 5; w contents := 'out '; w length := 3; w contents := 'the '; w length := 3; w contents := 'text '; w length := 4; w contents := 'message'; w length := 7; end; begin CreateList(words); for i := minlist to maxlist do with words do WriteLn(contents: length); for i := maxlist downto minlist do with words do WriteLn(contents: length) end.


Strings

In both languages, a string is a primitive array of characters. In Pascal a
string literal string literal or anonymous string is a literal for a string value in the source code of a computer program. Modern programming languages commonly use a quoted sequence of characters, formally "bracketed delimiters", as in x = "foo", where , "foo ...
of length n is compatible with the type packed array ..nof char. In C a string generally has the type char /code>. Pascal has no support for variable-length arrays, and so any set of routines to perform string operations is dependent on a particular string size. The now standardized Pascal "conformant array parameter" extension solves this to a great extent, and many or even most implementations of Pascal have support for strings native to the language. C string literals are null-terminated; that is to say, a trailing null character as an end-of-string
sentinel Sentinel may refer to: Places Mountains * Mount Sentinel, a mountain next to the University of Montana in Missoula, Montana * Sentinel Buttress, a volcanic crag on James Ross Island, Antarctica * Sentinel Dome, a naturally occurring granit ...
: const char *p; p = "the rain in Spain"; /* null-terminated */ Null-termination must be manually maintained for string variables stored in arrays (this is often partly handled by library routines). C lacks built-in string or array assignment, so the string is not being transferred to p, but rather p is being made to point to the constant string in memory. In Pascal, unlike C, the string's first character element is at index 1 and not 0 (leading it to be length-prefixed). This is because Pascal stores the length of the string at the 0th element of the character array. If this difference is not well understood it can lead to errors when
porting In software engineering, porting is the process of adapting software for the purpose of achieving some form of execution in a computing environment that is different from the one that a given program (meant for such execution) was originally desig ...
or trying to interface
object code In computing, object code or object module is the product of an assembler or compiler In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' ...
generated by both languages.
FreeBSD FreeBSD is a free-software Unix-like operating system descended from the Berkeley Software Distribution (BSD). The first version was released in 1993 developed from 386BSD, one of the first fully functional and free Unix clones on affordable ...
developer Poul-Henning Kamp, writing in ''
ACM Queue ACM ''Queue'' (stylized ''acmqueue'') is a bimonthly computer magazine, targeted to software engineer Software engineering is a branch of both computer science and engineering focused on designing, developing, testing, and maintaining softwar ...
'', would later refer to the victory of null-terminated strings over length-prefixed strings as "the most expensive one-byte mistake" ever.


Record types

Both C and Pascal can declare " record" types. In C, they are termed "structures". struct a { int b; char c; }; type a = record b: integer; c: char; end; In Pascal, we can use the sentence "with ''name_of_record'' do" in order to use directly the fields of that record, like local variables, instead of write ''name_of_record''.''name_of_field''. Here there is an example: type r = record s: string; c: char; end; var r1 : r; begin with r1 do begin s := 'foo'; c := 'b' end end; There is no equivalent feature to with in C. In C, the exact bit length of a field can be specified: struct a { unsigned int b:3; unsigned int c:1; }; How much storage is used depends on traits (e.g., word-alignment) of the target system. This feature is available in Pascal by using the subrange construct (3 bits gives a range from 0 to 7) in association with the keyword packed: type a = packed record b: 0..7; c: 0..1; end; Both C and Pascal support records which can include different fields overlapping each other: union a { int a; float b; }; type a = record case boolean of false: (a: integer); true: (b: real) end; Both language processors are free to allocate only as much space for these records as needed to contain the largest type in the union/record. In Pascal, such constructs are called variant records, not to be mistaken with the Variant datatype defined in Free Pascal. The biggest difference between C and Pascal is that Pascal supports the explicit use of a "tagfield" for the language processor to determine if the valid component of the variant record is being accessed: type a = record case q: boolean of false: (a: integer); true: (b: real) end; In this case, the tag field q must be set to the right state to access the proper parts of the record.


Pointers

In C, pointers can be made to point at most program entities, including objects or functions: int a; int *b; int (*compare)(int c, int d); int MyCompare(int c, int d); b = &a; compare = &MyCompare; In C, since arrays and pointers have a close equivalence, the following are the same: a = b a = *(b+5); a = *(5+b); a = 5 Thus, pointers are often used in C as just another method to access arrays. To create dynamic data, the library functions malloc() and free() are used to obtain and release dynamic blocks of data. Thus,
dynamic memory allocation Memory management (also dynamic memory management, dynamic storage allocation, or dynamic memory allocation) is a form of resource management applied to computer memory. The essential requirement of memory management is to provide ways to dyna ...
is not built into the language processor. This is especially valuable when C is being used in operating system kernels or embedded targets as these things are very platform (not just architecture) specific and would require changing the C compiler for each platform (or operating system) that it would be used on. Pascal has the same kind of pointers as C, through the ^ referencing operator instead of the * of C. Each pointer is bound to a single dynamic data item, and can only be moved by assignment: type a = ^integer; var b, c: a; new(b); c := b; Pointers in Pascal are type safe; i.e. a pointer to one data type can only be assigned to a pointer of the same data type. Also pointers can never be assigned to non-pointer variables. Pointer arithmetic (a common source of programming errors in C, especially when combined with
endianness file:Gullivers_travels.jpg, ''Gulliver's Travels'' by Jonathan Swift, the novel from which the term was coined In computing, endianness is the order in which bytes within a word (data type), word of digital data are transmitted over a data comm ...
issues and platform-independent type sizes) is not permitted in Pascal. All of these restrictions reduce the possibility of pointer-related errors in Pascal compared to C, but do not prevent invalid pointer references in Pascal altogether. For example, a runtime error will occur if a pointer is referenced before it has been initialized or after it has been disposed of.


Expressions


Precedence levels

The languages differ significantly when it comes to expression evaluation, but all-in-all they are comparable. ''Pascal'' # ''Logical negation:'' not # ''Multiplicative:'' * / div mod and # ''Additive:'' + - or # ''Relational:'' = <> < > <= >= in ''C'' # ''Unary postfix:'' [] () . -> ++ -- # ''Unary prefix:'' & * + - ! ~ ++ -- (type)
sizeof sizeof is a unary operator in the C and C++ programming languages that evaluates to the storage size of an expression or a data type, measured in units sized as char. Consequently, the expression sizeof(char) evaluates to 1. The number of b ...
# ''Multiplicative:'' * / % # ''Additive:'' + - # ''Shift:'' << >> # ''Relational:'' < > <= >= # ''Equality:''

!=
# ''Bitwise and:'' & # ''Bitwise xor:'' ^ # ''Bitwise or:'' , # ''Logical and:'' && # ''Logical or:'' , , # ''Conditional:'' ? : # ''Assignment:'' = += -= *= /= %= <<= >>= &= ^= , = # ''Comma operator'': ,


Typing

Most operators serve several purposes in Pascal, for instance, the minus sign may be used for negation, subtraction, or set difference (depending on both type and syntactical context), the >= operator may be used to compare numbers, strings, or sets, and so on. C uses dedicated operator symbols to a greater extent.


Assignment and equality tests

The two languages use different operators for assignment. Pascal, like
ALGOL ALGOL (; short for "Algorithmic Language") is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the ...
, uses the mathematical equality operator = for the equality test and the symbol := for assignment, whereas C, like B, uses the mathematical equality operator for assignment. In C (and B) the

symbol of FORTRAN was chosen for the equality test. It is a common mistake in C, due either to inexperience or to a simple typing error, to accidentally put assignment expressions in conditional statements such as . The code in braces will always execute because the assignment expression a = 10 has the value 10 which is non-zero and therefore considered "true" in C; this is in part because C (and ALGOL) allow multiple assignment in the form a = b = c = 10; which is not supported by Pascal. Also note that a now has the value 10, which may affect the following code. Recent C compilers try to detect these cases and warn the user, asking for a less ambiguous syntax like . This kind of mistake cannot happen in Pascal, as assignments are not expressions and do not have a value: using the wrong operator will cause an unambiguous compilation error, and it's also less likely that anyone would mistake the := symbol for an equality test. It is notable that ALGOL's conditional expression in the form has an equivalent in C (the ternary operator from CPL) but not in Pascal, which will use .


Implementation issues

When
Niklaus Wirth Niklaus Emil Wirth ( IPA: ) (15 February 1934 – 1 January 2024) was a Swiss computer scientist. He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering. In 1984, he won the Tu ...
designed Pascal, the desire was to limit the number of levels of precedence (fewer parse routines, after all). So, the OR and exclusive OR operators are treated just like an Addop and processed at the level of a math expression. Similarly, the AND is treated like a Mulop and processed with Term. The precedence levels are Notice that there is only ONE set of syntax rules, applying to both kinds of operators. According to this grammar, then, expressions like
     x + (y AND NOT z) / 3
are perfectly legal. And, in fact, they are, as far as the parser is concerned. Pascal does not allow the mixing of arithmetic and Boolean variables, and things like this are caught at the semantic level, when it comes time to generate code for them, rather than at the syntax level. The authors of C took a diametrically opposite approach: they treat the operators as different, and in fact, in C there are no fewer than 15 levels. That's because C also has the operators '=', '+=' and its kin, '<<', '>>', '++', '--', etc. Although in C the arithmetic and Boolean operators are treated separately, the variables are not: a Boolean test can be made on any integer value.


Logical connectives

In Pascal a ''boolean'' expression that relies on a particular evaluation ordering (possibly via side-effects in function calls) is, more or less, regarded as an error. The Pascal compiler has the freedom to use whatever ordering it may prefer and must always evaluate the whole expression even if the result can be determined by partial evaluation. In C, dependence on ''boolean'' evaluation order is perfectly legal, and often systematically employed using the && and , , operators together with operators such as ++, +=, the comma operator, etc. The && and , , operators thereby function as combinations of logical operators and conditional ''statements''. Short circuit expression evaluation has been commonly considered an advantage for C because of the "evaluation problem": var i: integer; a: packed array ..10of char; ... i := 1; while (i <= 10) and (a <> 'x') do i := i+1; ... This seemingly straightforward search is problematic in Pascal because the array access a would be invalid for i equal to 11. There is more than one way to avoid this problem. The following example introduces a Boolean variable which indicates whether or not the target character has been found: const strlen = 10; var i: integer; a: packed array ..strlenof char; found: boolean; ... i := 1; found := false; while not found and (i <= strlen) do if (a = 'x') then found := true else i := i+1; ... The following uses a repeat statement instead: const strlen = 10; var i: integer; a: packed array ..strlenof char; found: boolean; ... i := 1; repeat found := a = 'x'; if not found then inc(i); until found or (i > strlen); ...


Control structures

Statements for building control structures are similar but not equivalent. The final value of id, the control variable, is left undefined upon normal exit from the statement in Pascal. Pascal does not have an equivalent to . Pascal programmers otherwise have to guard case-statements with an expression such as: . At most, only one of the case statements will be executed. C has the so-called early-out statements and . They are not required and, if omitted, can result in more than one case statement being executed. Both C and Pascal have a statement. However, since Pascal has nested procedures/functions, jumps can be done from an inner procedure or function to the containing one; this was commonly used to implement error recovery. C has this ability via the ANSI C and . This is equivalent, but arguably less safe, since it stores program specific information like jump addresses and stack frames in a programmer accessible structure.


Functions and procedures

Pascal routines that return a value are called functions; routines that do not return a value are called procedures. All routines in C are called functions; C functions that do not return a value are declared with a return type of '' void''. Pascal procedures are considered equivalent to C "void" functions, and Pascal functions are equivalent to C functions that return a value. The following two declarations in C: int f(int x, int y); void k(int q); are equivalent to the following declarations in Pascal: function f(x, y: integer): integer; procedure k(q: integer); Pascal functions can only be used in an expression, whereas a C function that returns a value can be called in the same way as a "void" function and its return value ignored. Pascal has two different types of parameters: pass-by-value, and pass-by-reference (VAR). In both cases the variable name is used when calling (no need of address operator). function f(z: integer; var k: integer): integer; // function accepts two integers, one by value, one by reference Begin z:=1; // outer variable u will not be modified, but local value is modified in the function's scope k:=1; // outer variable t will be modified because it was passed by reference // up to here, z exists and equals 1 End; x := f(u,t); // the variables u and t are passed to the call : the value of u and the reference to t In C all parameters are passed by value but pass-by-reference can be simulated using pointers. The following segment is similar to the Pascal segment above: int f(int z, int *k) { //function accepts an int (by value) and a pointer to int (also by value) as parameter z=1; // idem Pascal, local value is modified but outer u will not be modified *k=1; // variable referenced by k (eg, t) will be modified // up to here, z exists and equals 1 } x = f(u,&t); // the value of u and the (value of) address of variable t are passed to the call One of the most important difference between C and Pascal is the way they handle the parameters on stack during a subroutine call : This is called the calling convention : PASCAL-style parameters are pushed on the stack in left-to-right order. The STDCALL calling convention of C pushes the parameters on the stack in right-to-left order. Pascal-style procedure call is made with : * caller pushing parameters into the stack in left-to-right order (opposite of ) * calling the function * stack is cleaned up by the callee ; example of pascal-style call. ; NOTE: __stdcall would push the arguments in reverse order. push arg1 push arg2 push arg3 call function ; no stack cleanup upon return: callee did it The advantage of PASCAL call over STDCALL is that the code is slightly smaller, though the size impact is only visible in large programs, and that recursion works faster. C allows for functions to accept a variable number of parameters, known as
variadic function In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages. The term ''var ...
s, using a clumsy mechanism of va_list ap;, va_start(ap, count);, va_arg(ap, ''type''); with limited ''type'' availability (example : nothing for bool) int f(int a, ...); f(1, 2, 3, 4, 5); The function f() uses a special set of functions (varargs) that allow it to access each of the parameters in turn. Pascal and C also have some variadic I/O functions, for instance WriteLn() and printf(). Pascal allows procedures and functions to be nested. This is convenient to allow variables that are local to a group of procedures, but not global. C lacks this feature and the localization of variables or functions can be done only for a compiling module wherein the variables or functions would have been declared static. C allows functions to be indirectly invoked through a
function pointer A function pointer, also called a subroutine pointer or procedure pointer, is a pointer referencing executable code, rather than data. Dereferencing the function pointer yields the referenced function, which can be invoked and passed arguments ...
. In the following example, the statement (*cmpar)(s1, s2) is equivalent to strcmp(s1, s2): #include int (*cmpar)(const char *a, const char *b); const char *s1 = "hello"; const char *s2 = "world"; cmpar = &strcmp; b = (*cmpar)(s1, s2); In Pascal functions and procedures can be passed as parameters to functions or procedures: procedure ShowHex(i: integer); ... end; procedure ShowInt(i: integer); ... end; procedure Demo(procedure Show(i: integer)); var j: integer; begin Show(j) end; ... Demo(ShowHex); Demo(ShowInt); ...


Preprocessor

Early C had neither constant declarations nor type declarations, and the C language was originally defined as needing a "
preprocessor In computer science, a preprocessor (or precompiler) is a Computer program, program that processes its input data to produce output that is used as input in another program. The output is said to be a preprocessed form of the input data, which i ...
"; a separate program, and pass, that handled constant, include and macro definitions, to keep memory usage down. Later, with ANSI C, it obtained constant and type definitions features and the preprocessor also became part of the language, leading to the syntax we see today. Pascal constant and type defines are built in and don't need a preprocessor. There were programmers using a preprocessor also with Pascal (sometimes the same one used with C), certainly not as common as with C. Although often pointed out as a "lack" in Pascal, technically C does not have program modularity nor macros built in either. It has a simple low level separate compilation facility, however (traditionally using the same generic linker used for assembly language), Pascal does not.


Type escapes

In C, the programmer may inspect the byte-level representation of any object by pointing a char pointer to it: int a; char *p = (char *)(&a); char c = *p; // first byte of a It may be possible to do something similar in Pascal using an undiscriminated variant record: var a: integer; b: real; a2c: record case boolean of false: (a: integer); true: (b: real); end; end; begin a2c.b := b; a := a2c.a; end; Although casting is possible on most Pascal compilers and interpreters, even in the code above a2c.a and a2c.b are not required by any Pascal standardizations to share the same address space. Niklaus Wirth, the designer of Pascal, has written about the problematic nature of attempting type escapes using this approach: "Most implementors of Pascal decided that this checking would be too expensive, enlarging code and deteriorating program efficiency. As a consequence, the variant record became a favourite feature to breach the type system by all programmers in love with tricks, which usually turn into pitfalls and calamities". Several languages now specifically exclude such type escapes, for example Java, C# and Wirth's own
Oberon Oberon () is a king of the fairy, fairies in Middle Ages, medieval and Renaissance literature. He is best known as a character in William Shakespeare's play ''A Midsummer Night's Dream'', in which he is King of the Fairies and spouse of Titania ...
.


Files

In C files do not exist as a built-in type (they are defined in a system header) and all I/O takes place via library calls. Pascal has file handling built into the language. The typical statements used to perform I/O in each language are: : printf("The sum is: %d\n", x); : writeln('The sum is: ', x); The main difference is that C uses a "format string" that is interpreted to find the arguments to the printf function and convert them, whereas Pascal performs that under the control of the language processor. The Pascal method is arguably faster, because no interpretation takes place, but the C method is highly extensible.


Later Pascal implementations and extensions

Some popular Pascal implementations have incorporated virtually all C constructs into Pascal. Examples include type casts, being able to obtain the address of any variable, local or global, and different types of integers with special promotion properties. However, the incorporation of C's lenient attitude towards types and type conversions can result in a Pascal that loses some or all of its type security. For example,
Java Java is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea (a part of Pacific Ocean) to the north. With a population of 156.9 million people (including Madura) in mid 2024, proje ...
and C# were created in part to address some of the perceived type security issues of C, and have "managed" pointers that cannot be used to create invalid references. In its original form (as described by
Niklaus Wirth Niklaus Emil Wirth ( IPA: ) (15 February 1934 – 1 January 2024) was a Swiss computer scientist. He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering. In 1984, he won the Tu ...
), Pascal qualifies as a managed pointer language, some 30 years before either Java or C#. However, a Pascal amalgamated with C would lose that protection by definition. In general, the lower dependence on pointers for basic tasks makes it safer than C in practice. The Extended Pascal standard extends Pascal to support many things C supports, which the original standard Pascal did not, in a type safer manner. For example, schema types support (besides other uses) variable-length arrays while keeping the type-safety of mandatory carrying the array dimension with the array, allowing automatic run-time checks for out-of-range indices also for dynamically sized arrays.


See also

* C, C++ * Pascal,
Object Pascal Object Pascal is an extension to the programming language Pascal (programming language), Pascal that provides object-oriented programming (OOP) features such as Class (computer programming), classes and Method (computer programming), methods. T ...
, Free Pascal,
Delphi Delphi (; ), in legend previously called Pytho (Πυθώ), was an ancient sacred precinct and the seat of Pythia, the major oracle who was consulted about important decisions throughout the ancient Classical antiquity, classical world. The A ...
, Oxygene * Component Pascal


Notes


Further reading

* Kathleen Jensen and Niklaus Wirth: ''PASCAL - User Manual and Report.'' Springer-Verlag, 1974, 1985, 1991, https://web.archive.org/web/20050314152247/http://www.cs.inf.ethz.ch/~wirth/books/Pascal/] *
Brian Kernighan Brian Wilson Kernighan (; born January 30, 1942) is a Canadian computer scientist. He worked at Bell Labs and contributed to the development of Unix alongside Unix creators Ken Thompson and Dennis Ritchie. Kernighan's name became widely known ...
, Dennis Ritchie: ''
The C Programming Language ''The C Programming Language'' (sometimes termed ''K&R'', after its authors' initials) is a computer programming book written by Brian Kernighan and Dennis Ritchie, the latter of whom originally designed and implemented the C programming langu ...
''. Also called K&R – the original book on C. ** 1st, Prentice Hall 1978; . Pre-ANSI C. ** 2nd, Prentice Hall 1988; . ANSI C. * Niklaus Wirth
''Comment on a note on dynamic arrays in PASCAL''
37-38, ACM SIGPLAN Notices, Volume 11, Issue 1, January 1976. * Niklaus Wirth
''Recollections about the Development of Pascal.''
333-342, ACM SIGPLAN Notices, Volume 28, Issue 3, March 1993.
ISO/IEC 9899
The official C:1999 standard, along with defect reports and a rationale.
Detailed analysis of converting C to Pascal
*Alan R. Feuer, Narain H. Gehani
''Comparison of the Programming Languages C and Pascal''
73-92, ACM Computing Surveys, Volume 14, Issue 1, March 1982. * ''Comparing and Assessing Programming Languages: Ada, C and Pascal'', Ed. by Alan R. Feuer and Narain Gehani, Prentice Hall, 1984. * Scott Meyers: ''Effective C++'', 2nd Ed., Addison-Wesley, 1998, * Vincent Hayward
''Compared anatomy of the programming languages Pascal and C''
50-60, ACM SIGPLAN Notices, Volume 21, Issue 5, May 1986.
Pascal for C users
in the FreePascal Compiler Wiki * Brian Kernighan
''Why Pascal Is Not My Favorite Programming Language''
* Andrew Koenig
''C Traps and Pitfalls''
{{DEFAULTSORT:Pascal and C comparison Comparison of individual programming languages C (programming language) Pascal (programming language) Pascal programming language family Articles with example Pascal code