C.CodeCompared.To/Pascal

The final end. — with a period, not a semicolon — is what ends the program text; anything after it is ignored. Single quotes delimit strings and double quotes have no meaning at all, so an apostrophe inside a literal is doubled: 'it''s'. writeln adds the newline, write does not, and both accept any number of arguments of any printable type without a format string.

A semicolon before else is a syntax error, because it would end the if statement and leave the else attached to nothing. In practice compilers accept a trailing semicolon before end — it simply separates the statement from an empty one — so the rule bites almost exclusively at else. Note also that then takes a single statement, which is why the begin/end pair is needed for two.

The colon syntax is positional: one colon is a minimum field width, two is width and decimal places. Without them a Double prints in scientific notation with far more digits than you wanted, which is the first thing everyone hits. Format takes its arguments as an array of variants, so it counts them — passing too few raises EConvertError rather than reading whatever was on the stack.

ParamCount excludes the program name, which argc includes — so the C column subtracts one to agree. ParamStr(0) is the program name, matching argv[0]. Because both are functions rather than parameters, a procedure buried five levels down can read them without anything being threaded through, which in C means a global.

The C column prints value is now 1, having silently overwritten the variable it was meant to test. Requiring two different symbols costs one keystroke per assignment and removes the bug entirely — which is the trade Pascal makes over and over. The same reasoning is why there is no ++: Inc(value) is a procedure call, so it cannot appear inside an expression and cannot be evaluated twice by accident.

It reads as bureaucracy until you notice what it buys: every name a block uses is visible in a dozen lines at the top, there is no shadowing surprise from a declaration halfway down, and the loop variable is a genuine local of the procedure rather than of the loop. The cost is real too — a long procedure’s declarations drift far from their use, which is an argument for shorter procedures rather than for the other rule.

Without the extra type keyword — plain TMetres = Integer — you get C’s behavior, an alias that is assignment-compatible with the original. With it you get a distinct type that must be cast, which is how Pascal lets you attach meaning to an integer without paying for a wrapper struct. The cast is still available, so the check is a speed bump rather than a wall; that is usually exactly the right strength.

Low, High, Succ and Pred work on any ordinal type, so an enumeration can be looped over without anyone maintaining a COLOUR_COUNT constant that goes stale — which is the C idiom this replaces. Ord is the deliberate one-way door to the integer; there is no implicit conversion in either direction, and TColour(1) is the explicit way back.

Range checking is off by default and is turned on per-region with {$RANGECHECKS ON} or for the whole build with -Cr — so this is a deliberate cost you pay where correctness matters more than speed. Even with checking off the type is still useful: the compiler sizes the variable from the range, Low and High report it, and an array [TDigit] of … is exactly ten elements with no separate constant to keep in step.

The operators are arithmetic ones with set meanings: + is union, - is difference, * is intersection, and in is membership. Because the element type is an enumeration, there is no way to put a stray bit in — the C column’s last line has no spelling here. Under the hood it is the same bitmask, one bit per possible element, which is why a set is limited to 256 elements.

The operators are words — and, or, not, xor — and in objfpc mode they short-circuit for Booleans, so if (p <> nil) and (p^.value > 0) is safe. Note the brackets around each comparison: and binds tighter than =, which is the opposite of C, and forgetting them is the one precedence trap the language has.

Both columns report 256 bytes, because that is what the structure is: one length byte and 255 characters. Two consequences follow. Subscripts start at 1, since index 0 is the length — and you can read it as text[0], which is the same trick as reading text.length in the C column. And the maximum length is 255, silently: assigning a longer value truncates it.

The variable itself is eight bytes — a pointer — which is why SizeOf reports the same number the C column does for its char *. What differs is what happens next: there is no free, because the reference count drops to zero when the variable leaves scope. Adding {$H+} at the top of a unit makes a bare string mean AnsiString, and most real Free Pascal code turns it on.

Pos returns a 1-based position and 0 when the substring is absent, which is why the two columns print 4 and 5 for the same match. The comparison operators are the real win: = compares contents, so the C habit of writing if (a == b) for strings — a bug there, comparing addresses — is correct here. Copy(text, start, count) is substr, with no destination buffer to size.

Note the subscript base flips: a Pascal string starts at 1, a PChar starts at 0, because it is a C pointer. PChar(text) does not copy — it hands out the address of the AnsiString’s buffer, which Free Pascal keeps NUL-terminated for exactly this purpose — so the pointer becomes invalid as soon as the string is reassigned or goes out of scope. That is the same lifetime discipline C makes you keep, arriving back at the one place the languages meet.

There is no length parameter, because the type carries it and Low/High read it back — so the C column’s last line, where the caller passes the wrong count and gets a plausible wrong answer, cannot be written. The cost is rigidity: a procedure for TFive takes only that. The escape is an open array, array of Integer as a parameter type, which accepts any length and still supplies High.

The check costs a compare and a branch per subscript and is off by default, which is the honest engineering position: you turn it on with -Cr for development and testing and decide per project whether to ship with it. A constant subscript outside the bounds is rejected at compile time regardless of the switch, which is the free half of the deal.

The 0-based indexing is a genuine inconsistency in the language — every static array you declare starts wherever you say, usually 1, and every dynamic one starts at 0 — which is why the loops here use High rather than a literal. Assigning one dynamic array to another shares the reference rather than copying; Copy(source) is how you get an independent one, which is the same distinction as memcpy against copying a pointer.

Inside the procedure an open array is always indexed from 0 regardless of how the caller’s array was declared, which is why the loop must use Low and High rather than assume. The [10, 20, 30] at the last call is an open array constructor, built on the spot — the same idea as a C compound literal, with the length going along for the ride.

Both columns report 16 bytes, because both are two doubles laid out in order. A record can be compared field by field only if you write the comparison — there is no = for records, exactly as there is none for C structs — but unlike C you can assign a whole record to another in one statement without memcpy, and a function can return one by value.

The catch is that a name inside the block resolves to the record’s field if it has one, shadowing any local or global of the same name — silently. Two nested withs over records that share a field name are worse still, since the inner one wins and nothing says so. Modern style uses it sparingly, or not at all; it is here because you will meet it in existing code and need to know that width is not a variable.

The case in a type declaration is a different construct from the statement, and the fields it introduces sit at the same address — so this is genuinely a union, with the tag stored alongside. The standard says reading a variant other than the active one is undefined; Free Pascal permits it, which means it is also the idiomatic way to reinterpret bits, the same use C unions get put to.

Both columns report 12 padded and 6 packed. A packed record is what you declare for anything read from a file or a socket, because the layout then depends on nothing but the field list — and the cost is the same one C pays, an unaligned field access that is slower on every architecture and a fault on some. The names differ slightly and are worth learning: Byte, Word, LongInt and Int64 are the fixed 8, 16, 32 and 64-bit types, where Integer’s width depends on the mode.

The ^ is postfix, which reads better in a chain: C’s node->next->value is node^.next^.value. Removing arithmetic removes the ability to walk off the end of anything by mistake — the price is that iterating over a buffer means subscripting an array rather than incrementing a pointer, which is what you should have been doing anyway. Free Pascal will re-enable arithmetic on typed pointers with {$POINTERMATH ON}, which is the deliberate way back to the C model.

Note the forward reference: PNode is declared as ^TNode before TNode exists, which is legal only inside a type block and is the one place Pascal permits using a name before defining it. New and Dispose carry every obligation malloc and free do — this is the one corner of the language where the leak, the double free and the dangling pointer are all still available. GetMem and FreeMem are the untyped, byte-counted pair when you want them.

FillChar is memset and Move is memmove — note the argument order of Move(source, destination, count), which is the opposite of memcpy’s and is a reliable source of mistakes when switching between the two. FreeMem can be given the size or not; supplying it lets the runtime check, which is the sort of optional rigour the language is built around.

Result is a Free Pascal and Delphi addition that {$mode objfpc} turns on; standard Pascal assigns to the function’s own name instead, which also works here. The split means the C habit of calling something purely for its side effect and dropping the result has no spelling, so a routine that does work is declared as the procedure it is — and a stray call to a function is caught rather than ignored.

There is no & at the call, which is convenient and means you cannot tell from a call whether an argument will be modified — the declaration is where that lives. out is the mode with no C counterpart: the incoming value is discarded and the compiler warns if a path leaves it unset. Note div rather than /: integer division has its own operator here, because / always produces a Double.

The helper is scoped to its parent, so it cannot be called from anywhere else and does not need a name that avoids collisions — which is what static in a C file achieves at file granularity and this achieves at procedure granularity. Implementing it costs a hidden link to the parent’s frame, the same mechanism GCC uses for its non-standard nested-function extension; the difference is that here it is in the language.

Abs, Sqr and the rest are intrinsics the compiler resolves by operand type, so the abs/labs/fabs family collapses to one name without anyone writing an overload. The overload directive is required on each routine that participates — an omission means the second declaration simply hides the first, which is worth knowing because the resulting error message points somewhere else entirely.

The range form 3..5 and the list form 1, 2 are what C spells as a run of empty labels. The selector must be an ordinal — an integer, a character, an enumeration or a subrange — so a case on a string is not available, and a case on an enumeration that misses a value is something the compiler will warn about, which is -Wswitch built in.

The two columns print different first lines on purpose: C runs five times because the bound is re-read, Pascal three times because both bounds were evaluated before the first pass. The step is always one, up or down — a stride of three is a while loop — and the loop variable’s value after the loop is officially undefined, so reading it afterwards is a mistake the compiler will warn about.

Inverting the condition is the whole difference and it is a reliable source of off-by-one thinking when moving code between the two. Break and Continue exist in Free Pascal and work as you expect; standard Pascal had neither, which is why old code is full of boolean guard variables. There is a goto, requiring the label to be declared in a label section first — deliberate friction.

Everything in interface is exported and everything in implementation is private, which is the opposite default from C and the same effect as marking every internal function static. If the two disagree about a signature the unit does not compile, so there is no equivalent of a stale header. The compiler also writes a compiled interface file, so uses reads a summary rather than re-parsing the source — which is why Pascal builds have always been fast.

The runtime runs every initialization section in dependency order before the program body and every finalization in reverse afterwards, including when the program exits through an unhandled exception. That is a guarantee C’s atexit gives only for the second half, and only for the functions you remembered to register. GCC’s __attribute__((constructor)) is the closest equivalent, and it is an extension rather than part of the language.

The library offers both styles deliberately: StrToInt raises because a malformed number is usually a bug, and StrToIntDef returns a fallback because parsing user input is not. on error: EConvertError do selects by class, and a bare except catches everything — worth avoiding, since it swallows the out-of-memory and access-violation cases along with your parse error.

Pascal keeps try/finally and try/except as separate constructs — one block cannot have both, so nesting them as above is the normal shape. That is a little more typing than the combined form other languages offer, and it makes the distinction explicit: finally is about releasing, except is about deciding, and mixing the two responsibilities in one block is usually what goes wrong.

Division by zero always raises; overflow and range checking are switches, off by default and turned on with {$OVERFLOWCHECKS ON}/{$RANGECHECKS ON} or the -Co/-Cr flags. Two details this example had to work around: the overflow switch has to be set before the program header rather than around the statement, and it is demonstrated on an Int64 because on a 64-bit target Free Pascal evaluates 32-bit arithmetic in 64-bit registers and truncates on the store, so an Integer overflow never trips the check at all. The design is the honest middle: the language specifies what happens rather than leaving it undefined, and lets you decide where the check is worth its cost. The usual practice is on for development and test builds, and a considered decision for release.

The try/finally around the lifetime is the standard Object Pascal idiom, and it exists because there is no garbage collector: Create allocates and Free releases, with the same one-to-one obligation malloc and free have. The reward for it is a real object model — virtual, override, abstract, interfaces and properties are all here, and a method call goes through a vtable the compiler builds rather than one you fill in by hand.

The abstract on TShape.Area means there is no body and every descendant must supply one, which is the check nothing in the C column makes — a null function pointer compiles and crashes later. Both shapes fitting in one array is the other half: the C version cannot manage that without a common header struct or a void * and a tag. override is checked too, so a signature that drifts from the parent’s is an error rather than a silently separate method.

Three things must agree and only the calling convention is checked: the symbol name, the parameter widths, and the presence of the library at link time. {$linklib c} is what tells the linker to pull in the C library; without it the symbols are undeclared at link time on Linux, though a macOS build happens to link libc anyway — which is exactly the kind of difference that makes a local pass a poor proof. cdecl matters because Pascal’s own convention differs — arguments in the other order, and the callee cleaning the stack — so omitting it corrupts the stack rather than raising an error. A string literal converts to PChar automatically here because it is already NUL-terminated in the binary; an AnsiString variable needs the explicit PChar(…) cast from the strings section.

Writing external 'libfoo' instead of a bare external makes the runtime dynamically load that library, which is what you do for anything outside the C library itself. The ctypes unit is the discipline that keeps interop portable: Integer is 32 bits in objfpc mode but a C long is 64 on Unix and 32 on Windows, and clong is the name that tracks that. The same unit supplies csize_t, cuint8 and the rest.

Both columns print the same sorted line, with the C library doing the sorting in each. The cdecl on CompareIntegers is not optional — without it the two integers arrive in the wrong registers and the comparison returns nonsense, which sorts the array into a plausible wrong order rather than crashing. @CompareIntegers takes the routine’s address, and the array is passed as @numbers[0] because Pascal has no array-to-pointer decay to do it implicitly.

Both columns report seven bytes, because both are packed and the fields are 1, 4 and 2 wide. The absolute declaration in the Pascal column overlays a byte array on the record at the same address — a variant record would do the same job — and the bytes it prints are in the machine’s own order, so a wire format still needs explicit byte-swapping. Drop the packed and the size becomes 12 on both sides, for the same alignment reasons.