Symbolics C, FORTRAN, and Pascal environments

Files and compiled products

A media .vbin is a versioned compiled Genera module; it is not evidence that the product's original implementation source was distributed. A .sab is a compiled documentation payload. Neither is a VM snapshot. The VLOD world holds the live Lisp-machine state into which these systems can be loaded, while the language source and binary files remain normal Genera file-system artifacts.

Development, RTO, and run-time configurations

The manuals distinguish a development configuration from a run-time-only (RTO) configuration. A development BIN retains source-level and incremental compilation information. An RTO BIN keeps executable code under the same file extension but strips information needed by the language debugger and some incremental recompilation. A run-time system can load and execute suitable BINs, but cannot compile source or provide the full language-level debugger.

For C, compiling an individual RTO function is safe only after its file or buffer has established the necessary external environment. FORTRAN and Pascal have the analogous requirement that external declarations and initialization context precede an isolated routine. The practical preservation target is therefore not just “a BIN which loads”: it is the compiler product, package and runtime systems, headers or libraries, system definitions, and the metadata needed to reconstruct the call tree.

Identity and implementation

Symbolics C targets the draft ANSI X3.159-198x language described by its guide, not a later finalized ISO C revision. The source system declaration dates the product to 1986. Its development system depends on C Runtime, Compiler Tools development and debugger support, lexer/LALR machinery, the C editor, library headers, and documentation.

The inspected declaration is revealing about source distribution. The compiler and editor systems are marked not to distribute implementation source, while C Runtime is marked to distribute source. The media accordingly exposes Lisp runtime source and ordinary header files but keeps the compiler/editor proper as compiled .vbin modules. This makes C more source-visible than the other two products without making it an open-source compiler.

Zmacs modes, bindings, and named commands

The C product documents three editing levels:

• C Fundamental Mode supplies a compiler-oriented lexical subset without syntax templates;
• C Mode supplies the language major mode; and
• Electric C Mode enables the full syntax-aware behavior.

In addition to the shared syntax-editor keys, C defines:

The common syntax-editor record calls Control-Meta-Q Correct Structure, while the C-specific command summary calls the same gesture Format Language Region. This may be an alias, a context-sensitive binding, or version drift; the effective loaded command table is a runtime TODO.

The same command-summary witness contains unresolved implementation notes: Kill Definition is marked “not working”; List Definitions and List Changed Definitions are marked available; List C Callers is marked unavailable; and Macro Expand Region on Control-Shift-M is questioned as either not implemented or renamed Macro Expand Expression. Those are release-document editorial states, not findings from the currently unloaded runtime.

Dynamic C Listener

Select Activity C enters the Dynamic C Listener when the product is installed. It combines a command history, C evaluator, and Command Processor-style menus. Help describes the active interface.

At an earlier prompt, left-click reexecutes the command, middle-click modifies and then reexecutes it, and right-click obtains the contextual menu. On a command name, left-click reads typed arguments, the documented middle gesture has no operation, and right-click chooses arguments from menus. End commits a value; a second End activates the completed command. The C 1.1 notes say typed commands were newly enabled and that a menu selection may abbreviate a full command name.

The listener's C evaluator is also available in debugger and suspended-break contexts. A comma introduces a C expression and End evaluates it. It cannot define a C function; definitions must be compiled first. The guide says setjmp/longjmp have no useful effect in this evaluator, and atexit has no useful program-exit context there.

C Command Processor inventory

These are the language-specific commands and options recovered from the C command chapters:

The Generate C System Definition description is internally inconsistent: its argument list includes search lists and component systems, but nearby prose says the generator cannot preserve those facts. A generated definition should therefore be reviewed rather than treated as a lossless serialization of the interactive environment.

An environment records the current file context, include search lists, files, and names. It is the development-time analogue of the call-tree context needed at execution. The source-only export routine adds another preservation warning: its implementation comment says that recompiling a C library between minor C releases invalidates user BINs. Preserving only header text and recompiling a library with an arbitrary compiler version can therefore break binary compatibility.

Compilation, systems, and execution

The normal workflow is:

1. enter C Mode or Electric C Mode and establish the package/search-list context;
2. compile a definition, region, buffer, file, or Genera system;
3. inspect Compiler Warnings and navigate to individual warnings;
4. establish or generate the C environment and call tree; and
5. run through Execute C Function, Make C Main Program, or the equivalent Lisp entry point.

Compile and Load System applies the ordinary Genera system-construction machinery. Incremental definition replacement is available in a development world, but its correctness depends on the current environment, external declarations, and runtime initialization. C programs which use static data or string literals must remain below C-SYSTEM:EXECUTE in the call tree. Calling a generated Lisp symbol directly can bypass required C initialization. C-SYSTEM:BUILD-EXPANDED-ARGUMENT-LIST constructs the argc/argv representation for Lisp callers.

Libraries

The inspected header system contains the standard-library families:

The C 1.1 release notes specifically call locale support new. Presence of these headers establishes the library shipped with this product revision; it does not imply conformance to later C standards.

Lisp interoperation and representation

A C declaration with the lisp function directive names a Lisp callee, optionally including an explicit package and Lisp-name string. The directive applies to one function. Callers must be recompiled when it changes.

The lispobj type can carry any Lisp object, but C may only assign it or pass it as an argument; the C program cannot portably inspect, compare, coerce, or mutate its Lisp representation. Ordinary scalars cross by value. Aggregates cross according to size:

The documented sizes are 8-bit char, 16-bit short, one-word int, long, and float, and two-word double and pointer. C structure storage uses ART-Q arrays. These are properties of this implementation and target, not portable C ABI promises.

Debugging limits

The compiler emits source-level information for the Genera debugger, but the available documents disagree about breakpoints. The C 1.1 notes say C breakpoints are not supported, while a C debugger chapter still describes them. No C package is resident in the base world, so this audit cannot decide which statement applies to the inspected media version. Standard Genera debugger commands remain inherited; no separate, trustworthy complete C-only debugger command table was exposed by the recovered records.

Language identity and extensions

The FORTRAN manual claims full ANSI FORTRAN 77, X3.9-1978, and then adds Symbolics facilities: arbitrary-size integers, detection of uninitialized values, stronger type checks, packages, integer/logical coercions, selected Department of Defense extensions, DO WHILE and ENDDO forms, INCLUDE and IMPLICIT facilities, binary patterns, logical and shift operators, and bit substrings. Source is case-insensitive except in strings and Hollerith data. The system declaration dates the product to 1982.

The normal package is FTN-USER with no superiors. CL-USER can be made visible, but the manual warns about name conflicts. Character data is 8-bit; INTEGER, REAL, and LOGICAL occupy one word; DOUBLE and COMPLEX occupy two.

Fixed-format Zmacs interaction

FORTRAN mode is deliberately different from the C/Pascal syntax editor. Its bindings know statement fields, continuations, sequence numbers, and the column-72 source limit:

Electric FORTRAN Mode wraps at column 72 and inserts continuation syntax. Two editor variables are user-settable: F77:WRAPAROUND-COLUMN, documented default 40, and F77:CONTINUATION-CHARACTER, documented default dollar sign.

The recovered FORTRAN-specific named commands are:

Programs, systems, and run commands

A FORTRAN program can be run by Execute FORTRAN Program in Zmacs, Execute FORTRAN in the Command Processor, or F77:EXECUTE/F77:XQT from Lisp. The Command Processor interface exposes:

F77:DEF-LIBRARY and F77:DEF-PROGRAM define language-level libraries and program call trees. DEFSYSTEM and Compile/Load System integrate FORTRAN, Lisp, and—subject to dependency order—Pascal components. Explicit PROGRAM names are recommended because unnamed main programs reuse the conventional .MAIN. name and can replace one another.

The runtime provides separate numeric and character spaces. Lisp code can allocate scoped regions with F77:WITH-FORTRAN-NUMBER-DATA and F77:WITH-FORTRAN-CHARACTER-DATA; FORTRAN addresses entries by integer offset. The inspected compiled media includes modules named libraries, io-libraries, and intrinsic-inits. The manual describes Genera- and network-compatible I/O, but the exact exported routine inventory has not yet been recovered safely.

Debugger and language listener

FORTRAN participates in the Display Debugger's eight-pane source interface. Its language listener can evaluate FORTRAN statements in a suspended context. The recovered restriction record names GOTO and RETURN as excluded, but that record is not demonstrably exhaustive. The recovered language-specific debugger commands are:

• Show Local (Meta-L);
• Show Variable's Value;
• Show Detailed Value;
• Show Variable's Type;
• Show Value's Type;
• Describe Type Detailed;
• Show Type Name;
• Edit Viewspecs;
• Statement Step For Function; and
• Clear Statement Step For Function.

The ordinary debugger commands, traps, stack navigation, and presentations are inherited from Genera. The documentation itself says Show FORTRAN Global Common does not exist, and some trap/breakpoint records retain editorial notes asking whether the facility works. They are not counted as confirmed commands.

Lisp interoperation

The lispobject type has the same deliberately narrow role as C lispobj: it may be assigned or passed but not inspected as a foreign structure. A lispfunction declaration names a Lisp routine. Scalars cross by value; arrays become indirect Lisp arrays or references.

DOUBLE arrays remain unboxed high/low-word data, while DOUBLE scalar arguments are boxed automatically on the Lisp side. A function cannot return a character array directly; callers must supply an output argument. Data initialization requires execution below the FORTRAN program call tree, or an appropriate EXTERNAL declaration and environment. Directly invoking an internal compiled symbol can therefore be as unsafe as bypassing C-SYSTEM:EXECUTE.

A decoded on-line Help record titled Standard FORTRAN Functions contains Pascal EOF/EOLN material rather than a FORTRAN intrinsic inventory. This audit does not turn that mislabeled payload into a claim about supported intrinsics. The exact intrinsic and library list is a runtime TODO.

Dialects, extensions, and restrictions

The Pascal environment supports an ISO-oriented default dialect and a Pascal/VS dialect. It adds arbitrary-size integers, uninitialized-value detection, stronger type checking, SHORTREAL, an OTHERWISE case arm, %INCLUDE, single/double conversion, packages, Lisp interaction, a second file-open argument, and the units facility. The system declaration dates the product to 1982.

The book's broad “full ISO and Pascal/VS” overview is qualified by its own restriction chapters. The Pascal/VS mode omits routines or facilities named PARMS, PDSIN, PDSOUT, RETCODE, and TOKEN; percent directives other than %INCLUDE; DEF, REF, SEGMENT, SPACE, and STATIC declarators; EXTERNAL, FORTRAN, MAIN, and REENTRANT directives; and range case selectors. ISO OTHERWISE becomes a reserved word. Pascal/VS strings cannot be passed directly to ISO routines, and conformant arrays cannot be passed directly to Pascal/VS routines.

The normal package is PASCAL-USER with no package conflicts documented. The manual calls units the Release 6.0 replacement for the older 5.2 separate compilation scheme; Set Using survives in the editor inventory only as an obsolete 5.2 command.

Zmacs bindings and commands

Pascal uses all shared syntax-editor bindings above. Its direct language bindings add Control-Meta-A/E for routine boundaries, Control-Shift-A for the compiled argument list, and Control-Shift-C for compilation. The Control-Shift-A documentation itself asks whether the command works, so the binding is documented but its behavior is not runtime-confirmed.

The complete recovered Pascal-specific named-command inventory is:

Load File is also named in the Pascal appendix, but it is inherited Zmacs functionality rather than a Pascal-only command.

Programs, units, and run options

Pascal programs run through Execute Pascal Program in Zmacs, Execute Pascal in the Command Processor, or PASCAL:EXECUTE/PASCAL:XQT from Lisp. The documented Command Processor options are:

The PASCAL:EXECUTE arglist shown elsewhere omits Streams and Use Abort Mode, and prose uses the singular Stream where the option table says Streams. This is another unresolved manual inconsistency.

PASCAL:DEF-PROGRAM and DEFSYSTEM describe programs and their units. Compile/Load System can combine Pascal, FORTRAN, and Lisp components when dependencies are declared correctly. Units, not the obsolete Set Using mechanism, are the relevant separate-compilation model for the later text in the inspected book.

Debugger

Pascal uses the same eight-pane Display Debugger architecture as FORTRAN. Its language listener may evaluate executable statements in the suspended environment except GOTO, LEAVE, EXIT, and RETURN. The recovered Pascal-specific value, type, and stepping commands are the same set:

• Show Local (Meta-L);
• Show Variable's Value;
• Show Detailed Value;
• Show Variable's Type;
• Show Value's Type;
• Describe Type Detailed;
• Show Type Name;
• Edit Viewspecs;
• Statement Step For Function; and
• Clear Statement Step For Function.

Generic debugger operations are inherited. The existence of Clear All Breakpoints and List Breakpoints in the editor documents intended integration, but only a loaded product can establish the effective release behavior.

Lisp interoperation and data representation

Pascal's lispobject and lisp directive provide the bridge to Lisp. Scalars pass by value; arrays and records may pass by value or reference. Packed character arrays and Pascal/VS strings map to Lisp strings. REAL is boxed for Lisp while the Pascal side uses its unboxed high/low representation.

Lisp invokes a main program through PASCAL:EXECUTE. The manual also documents calling a first-level routine through its generated Lisp symbol with a NIL compiler display argument. It does not authorize the same shortcut for nested routines.

The documented target model uses 8-bit characters, approximately 24-bit single precision, approximately 53-bit double precision, and arbitrary-size integers through Lisp bignums. An unconstrained set constructor defaults to a 256-element integer domain. These implementation choices affect data exchange and should be retained in compatibility tests.

Findings visible only in the media declarations

• C compiler and editor source are marked non-distributable, while C Runtime source is distributable; this explains the mixed source/binary media tree.
• C's library exporter warns that recompilation across minor C releases invalidates user BINs.
• The C editor declares explicit dependencies on syntax-editor support, lexer, grammar, search, kill, and language modules rather than being a superficial file-suffix mode.
• Pascal declares the same syntax-editor/lexer/grammar architecture and explicitly disables source distribution.
• FORTRAN, Pascal, and their run-time/package systems are separate loadable systems. Finding one package would not prove the compiler, editor, and documentation systems were all loaded.

Runtime provenance

The detailed harness boundary is documented in Operating Genera through the Xvfb computer-use harness. Machine-specific paths are intentionally omitted.