CSC(1)

📦
version 5.4.0 · 4 versions
, in alpine 3.24, fedora 43, fedora 44, nixos 26.05

💖 CSC(1) 💖

okay so bestie, welcome to the manual page for csc — the driver program for the CHICKEN Scheme compiler. It lives in the General Commands Manual section (that's section 1, the "commands you actually type" section, iykyk). This is a big one, so hydrate 💅

✨ NAME ✨

csc — driver program for the CHICKEN Scheme compiler

🎀 SYNOPSIS 🎀

csc [OPTION ...] [FILENAME ...]

🦋 DESCRIPTION 🦋

So like, csc is the main character of the CHICKEN build process. It's a program that invokes the CHICKEN compiler and the host system's C compiler, and it does that so you get an executable out of a Scheme source file — or out of C files that CHICKEN itself generated. Bestie it's literally the glue holding the whole thing together, no cap 🫶

FILENAME is a Scheme source file name with an optional extension, or a C / C++ / Objective-C source, object, or library file name with an extension. And OPTION can be any one of the following. Buckle up, there are a lot, and they're all real:

🌈 General options 🌈

  • -h, -help — shows you the usage text and then dips out. Bye 💨
  • -v, -verbose — spills the compiler notes and every tool invocation. Very "tell me everything" of it.
  • -vv — shows info about translation progress.
  • -vvv — shows info about all the compilation stages. Maximum yapping, and honestly? obsessed.
  • -version — displays the Scheme compiler version and exits.
  • -release — displays the release number and exits.

🍓 File and pathname options 🍓

  • -o FILENAME, -output-file FILENAME — specifies the target executable name.
  • -I PATHNAME, -include-path PATHNAME — specifies an alternative path for included files.
  • -to-stdout — write compiler to stdout (this one implies -t).
  • -s, -shared, -dynamic — generate a dynamically loadable shared object file.

💜 Language options 💜

  • -D SYMBOL, -feature SYMBOL — register a feature identifier.
  • -no-feature SYMBOL — disable a builtin feature identifier.
  • -c++ — compile via a C++ source file (.cpp).
  • -objc — compile via Objective-C source file (.m).
  • -i, -case-insensitive — don't preserve the case of read symbols.
  • -K, -keyword-style STYLE — enable alternative keyword-syntax. The STYLE can be prefix, suffix or none.
  • -no-parentheses-synonyms — disables list delimiter synonyms.
  • -no-symbol-escape — disables support for escaped symbols.
  • -r5rs-syntax — disables the CHICKEN extensions to R5RS syntax.
  • -compile-syntax — macros are made available at run-time.
  • -j MODULE, -emit-import-library MODULE — write compile-time module information into a separate file.
  • -J, -emit-all-import-libraries — emit import-libraries for all defined modules.
  • -no-compiler-syntax — disable expansion of compiler-macros.
  • -m NAME, -module NAME — wrap the compiled code in a module of the given name.
  • -M, -module-registration — always generate module registration code, even when import libraries are emitted.
  • -N, -no-module-registration — do not generate module registration code. This one overrides -module-registration. Rude but valid.

⭐ Translation options ⭐

  • -x, -explicit-use — do not use the units library and eval by default.
  • -P, -check-syntax — stop compilation after macro-expansion.
  • -A, -analyze-only — stop compilation after the first analysis pass.

💀 Debugging options 💀

  • -w, -no-warnings — disable warnings. Living on the edge, I respect it.
  • -d0, -d1, -d2, -d3, -debug-level NUMBER — set the level of available debugging information.
  • -no-trace — disable rudimentary debugging information.
  • -profile — the executable emits profiling information.
  • -accumulate-profile — the executable emits profiling information in append mode.
  • -profile-name FILENAME — name of the generated profile information file.
  • -types FILENAME — load an additional type database.

🔥 Optimization options 🔥

  • -O, -O0, -O1, -O2, -O3, -O4, -O5, -optimize-level NUMBER — enable certain sets of optimization options.
  • -optimize-leaf-routines — enable leaf routine optimization.
  • -no-usual-integrations — standard procedures may be redefined.
  • -u, -unsafe — disable safety checks. ⚠️ yes, that means what it sounds like, be so fr.
  • -local — assume globals are only modified in the current file.
  • -b, -block — enable block-compilation.
  • -disable-interrupts — disable interrupts in compiled code.
  • -f, -fixnum-arithmetic — assume all numbers are fixnums.
  • -disable-stack-overflow-checks — disables detection of stack-overflows.
  • -inline — enable inlining.
  • -inline-limit LIMIT — set the inlining threshold.
  • -inline-global — enable cross-module inlining.
  • -specialize — perform type-based specialization of primitive calls.
  • -oi FILENAME, -emit-inline-file FILENAME — generate a file with globally inlinable procedures (this implies -inline -local).
  • -consult-inline-file FILENAME — explicitly load an inline file.
  • -ot FILENAME, -emit-types-file FILENAME — write type-declaration information into a file.
  • -no-argc-checks — disable argument count checks.
  • -no-bound-checks — disable bound variable checks.
  • -no-procedure-checks — disable procedure call checks.
  • -no-procedure-checks-for-usual-bindings — disable procedure call checks only for usual bindings.
  • -no-procedure-checks-for-toplevel-bindings — disable procedure call checks for toplevel bindings.
  • -strict-types — assume variables do not change their type.
  • -clustering — combine groups of local procedures into a dispatch loop.
  • -lfa2 — perform an additional lightweight flow-analysis pass.
  • -unroll-limit LIMIT — specifies the inlining limit for self-recursive calls.

🌸 Configuration options 🌸

  • -unit NAME — compile file as a library unit.
  • -uses NAME — declare a library unit as used.
  • -heap-size NUMBER — specifies the heap-size of the compiled executable.
  • -nursery NUMBER -stack-size NUMBER — specifies the nursery size of the compiled executable.
  • -X FILENAME, -extend FILENAME — load file before compilation commences.
  • -prelude EXPRESSION — add expression to the beginning of the source file.
  • -postlude EXPRESSION — add expression to the end of the source file.
  • -prologue FILENAME — include file before the main source file.
  • -epilogue FILENAME — include file after the main source file.
  • -e, -embedded — compile as embedded (don't generate main()).
  • -gui — compile as a GUI application.
  • -link NAME — link extension with the compiled executable (this implies -uses).
  • -R NAME, -require-extension NAME — require extension and import it in the compiled code.
  • -dll, -library — compile multiple units into a dynamic library.
  • -libdir DIRECTORY — override the location of the runtime library directory.

🎀 Options to other passes 🎀

  • -C OPTION — pass option to the C compiler.
  • -L OPTION — pass option to the linker.
  • -I<DIR> — pass -I<DIR> to the C compiler (add include path).
  • -L<DIR> — pass -L<DIR> to the linker (add library path).
  • -k — keep intermediate files.
  • -c — stop after compilation to object files.
  • -t — stop after translation to C.
  • -cc COMPILER — select a C compiler other than the default.
  • -cxx COMPILER — select a C++ compiler other than the default.
  • -ld COMPILER — select a linker other than the default.
  • -static — link with static CHICKEN libraries and extensions.
  • -F<DIR> — pass -F<DIR> to the C compiler (add framework header path on Mac OS X).
  • -framework NAME — passed to the linker on Mac OS X.
  • -rpath PATHNAME — add directory to the runtime library search path.
  • -Wl,... — pass linker options.
  • -strip — strip the resulting binary. 💅

🫶 Inquiry options 🫶

  • -home — show home-directory (where support files go).
  • -cflags — show required C-compiler flags and exit.
  • -ldflags — show required linker flags and exit.
  • -libs — show required libraries and exit.
  • -cc-name — show the name of the default C compiler used.
  • -cxx-name — show the name of the default C++ compiler used.
  • -ld-name — show the name of the default linker used.
  • -dry-run — just show the commands executed, don't run them (this implies -v).

🙈 Obscure options 🙈

  • -debug MODES — display debugging output for the given modes.
  • -compiler PATHNAME — use a compiler other than the default chicken.
  • -raw — do not generate implicit init- and exit code.
  • -emit-external-prototypes-first — emit prototypes for callbacks before foreign declarations.
  • -regenerate-import-libraries — always emit import libraries, even when their contents haven't changed. The default behaviour is to preserve existing import libraries.
  • -ignore-repository — do not refer to the repository for extensions.
  • -keep-shadowed-macros — do not remove shadowed macros.
  • -host — compile for host when configured for cross-compiling.
  • -private-repository — load extensions from the executable path.
  • -deployed — link support file to be used from a deployed executable (sets rpath accordingly, if supported on this platform).
  • -no-elevation — embed manifest on Windows to supress elevation warnings for programs named install or setup. (yes, "supress", that's how it's spelled in the original, I'm not touching it 💖)
🦋 PSA bestie: options can be collapsed if unambiguous, so -vkfO is the same as -v -k -fixnum-arithmetic -optimize. It's giving "keyboard smash but make it intentional". Iconic.

🌈 ENVIRONMENT 🌈

The following environment variables change the behaviour of csc:

  • CSC_OPTIONS — can hold default options that should be passed to every invocation of csc.

⭐ EXIT STATUS ⭐

The csc utility exits 0 on success, and >0 if an error occurs.

💜 SEE ALSO 💜

More information can be found in the CHICKEN User's Manual: http://wiki.call-cc.org/manual/index.

🎀 AUTHORS 🎀

The CHICKEN Team — absolute legends, no notes 👑

💀 BUGS 💀

Submit bug reports by e-mail to chicken-janitors@nongnu.org. They're nice, I promise, but like... be specific okay? 🫶

and that's the whole thing, bestie ✨ this page came from the Debian folks and it's dated Apr 26, 2017 — go forth and csc responsibly, mwah 💅🦋

📦 where this page comes from