# Pascal
Pascal is a procedural programming language created by [Niklaus Wirth](niklaus_wirth.md) in 1970.

Pascal was a popular choice for microcomputers in the 70's and 80's, even more popular than [C](c.md) initially (C was still quite an UNIX-only language)
due to its simple design, which allowed fast simple single-pass compilers. Later on in the mid-80s and early-90s Pascal began
losing its dominance to C, mainly because of the influence of [OSes](os.md) of that time, which were all written in C.

In its "vanilla" form, Pascal is not any more complex than C, aside from having features that C doesn't have,
such as range types, nested procedures, sets, builtin tagged unions, etc.

Pascal has an ISO standard: ISO 7185. Since the Pascal described in said standard is quite useless for practical programming,
most compilers are for an extended superset of the Pascal described in that standard.

## Compilers
- [FPC](https://www.freepascal.org/) (Free Pascal Compiler): currently the most popular Pascal compiler with wide support
for different OSes and architectures, libre software.
- [GNU Pascal](https://www.gnu-pascal.de/gpc/h-index.html): frontend for [GCC](gcc.md), abandoned.
- Turbo Pascal: old compiler for [DOS](dos.md) systems, proprietary.
- Delphi: proprietary, adds [OOP](oop.md) [bloat](bloat.md) and [exception](exception.md) handling.

## Notes
### Returning values from functions
```pascal
{ The "classical" way, assigning the return value to the function name }
function Square(n: integer): integer;
begin
    Square := n * n; 
end;

{ Object Pascal and Delphi, assigning to special `Result` variable }
{ Enable with `-S2` in FPC }
function Square(n: integer): integer;
begin
    Result := n * n; 
end;

{ Return statement like }
function Square(n: integer): integer;
begin
    Exit(n * n);
end;
```
## Identifiers
Pascal is case-insensitive, so `WriteLn`, `writeLn`, `writeln` and `wRiTeLn` are the same
identifiers.

## Examples
### Hello world
```pascal
program HelloWorld;

begin
    WriteLn('Hello, World!');
end.
```

And then compile:
```
fpc hellopascal.pas
```

### Factorial
```pascal
program Factorial;

{ qword = 64 bit unsigned type }
function factorial(n: qword): qword;
begin
    Result := 1;
    while n > 0 do
    begin
        { The usage of C-like arithmetic assignment operators is possible with -Sc: }
        { Result *= n; }
        Result := Result * n;
        dec(n); { equivalent to C's `--` operator }
    end;
end;

var
    n: qword;
    values: array of qword = (14, 5, 2, 10, 1, 18, 4);
begin
    for n in values do
    begin
        writeLn('Factorial of ', n, ' = ',  factorial(n));
    end;
end.
```

Compiling:
```
fpc -O3 -S2 fact.pas
```

## Resources
- [Free Pascal Wiki](https://wiki.freepascal.org/Main_Page)
- [Basic Pascal Tutorial](https://wiki.freepascal.org/Basic_Pascal_Tutorial)
- *Why Pascal is Not My Favorite Programming Language* by Brian Kernighan, mostly of historic interest as almost all of the
flaws described in the article has been fixed by modern Pascal compilers. <https://www.lysator.liu.se/c/bwk-on-pascal.html>

## See also
- [Oberon](oberon.md)
- [PL/0](pl0.md)