.PAS File Format – Exceptions and memory

try … except

try
  Value := StrToInt(Text);
  Result := 100 div Value;
except
  on E: EConvertError do
    ShowMessage('Not a number: ' + E.Message);
  on EDivByZero do
    Result := 0;
  on E: Exception do
  begin
    Log(E.ClassName + ': ' + E.Message);
    raise;                      { raise the same exception again }
  end;
else
  { any other kind of exception, only without an on clause }
end;

The statements between try and except run; if one raises an exception, the rest of them are skipped and the handlers are tried in order. An on clause names an exception class (and optionally a variable bound to the object) and matches that class and its descendants. Statements directly after except (with no on) handle every exception. If no handler matches, the exception goes on to the caller. The exception object is freed when the handler ends, unless it is re-raised.

try … finally

Stream := TFileStream.Create(Name, fmOpenRead);
try
  Process(Stream);
finally
  Stream.Free;                  { runs whether Process worked or raised }
end;

The statements after finally run however the statements after try end: normally, by an exception, or by Exit, Break, Continue or goto out of the block. The idiom is to create a resource, then try straight after, and release it in finally. An exception that passes through goes on afterwards.

raise

raise Exception.Create('Something went wrong');
raise EInvalidInput.CreateFmt('Bad value %d', [N]);
raise;                                  { inside an except block: re-raise }
raise EFoo.Create('x') at ReturnAddress; { set the reported address }

raise with an object creates the exception; raise alone in an except part raises the current one again. at Address gives the address the error is reported to be at. An exception is an object of a class derived from Exception, which has a Message property, a constructor Create(Msg), CreateFmt(Format, Args) and CreateRes, and HelpContext.

The exception classes

Run-time errors and I/O results

• Turbo Pascal and ISO programs have no exceptions: a fault ends the program with a message Runtime error N at address. The number is the exit code: 2 file not found, 3 path not found, 4 too many open files, 5 file access denied, 100 disk read error, 101 disk write error, 106 invalid numeric format, 200 division by zero, 201 range check, 202 stack overflow, 203 heap overflow, 205 floating point overflow, 207 invalid floating point operation, and so on.
• {$I-} turns off the automatic check of input and output. After a file operation IOResult returns the error code (0 for none) and must be read to clear it, and it is the way to test whether a file exists or can be opened in code without exceptions.
• Halt(Code) ends the program at once with an exit code; RunError(Code) ends it with a run-time error; ExitProc (Turbo Pascal) or finalization sections and AddExitProc run on the way out. ExitCode and ErrorAddr hold the end state.
• Delphi and Free Pascal turn most run-time errors into exceptions of the classes above. ExceptObject and ExceptAddr give the current exception inside a handler.

Pointers and dynamic memory

var
  P: ^Integer;
  Buf: Pointer;
begin
  New(P);               { allocate an Integer on the heap }
  P^ := 42;
  Dispose(P);           { free it }

  GetMem(Buf, 1024);    { allocate raw bytes }
  FillChar(Buf^, 1024, 0);
  ReallocMem(Buf, 2048);
  FreeMem(Buf);
end;

• New(P) allocates the size of P^ and Dispose(P) frees it, finalising managed fields. GetMem(P, Size), ReallocMem and FreeMem(P) work on bytes. A nil pointer points at nothing; using it raises an access violation. Initialize and Finalize prepare and release managed contents.
• MaxAvail and MemAvail (Turbo Pascal) report free memory, and GetHeapStatus, GetFPCHeapStatus (Delphi, Free Pascal) fill a record with heap figures.
• Mark and Release (Turbo Pascal, UCSD) free everything allocated since the mark.
• The heap manager can be replaced: SetMemoryManager in Delphi and Free Pascal; Delphi has used FastMM since Delphi 2006 as its default; Free Pascal’s -gh option turns on the heaptrc unit that reports leaks.

Who frees what

Low-level access

• @X and Addr(X) take addresses; Ptr(Segment, Offset) (DOS) and Ptr(Address) make a pointer from a number; Seg and Ofs split a DOS far pointer; Mem[Seg:Ofs], MemW and MemL (Turbo Pascal) read and write memory directly; Port[N] and PortW[N] read and write I/O ports.
• Typed pointer arithmetic and indexing need {$POINTERMATH ON}, or are allowed on PChar; Inc(P) steps by the size of the target.
• absolute variables overlay an address or another variable.
• Move, FillChar, CompareByte and Copy work on blocks of memory.