Crystal - Crystal 1.11.2

# module Crystal

##
Defined in:

crystal/datum.cr
crystal/dwarf.cr
crystal/dwarf/abbrev.cr
crystal/dwarf/info.cr
crystal/dwarf/line_numbers.cr
crystal/dwarf/strings.cr
crystal/elf.cr
crystal/main.cr:3
crystal/main.cr:20
crystal/small_deque.cr

##
Constant Summary

BUILD_COMMIT = `nil`
BUILD_DATE = `"2024-02-27"`
CACHE_DIR = `"/tmp/crystal"`
DEFAULT_PATH = `"lib:/usr/lib/crystal"`
DESCRIPTION = `"Crystal 1.11.2 (2024-02-27)\n\nLLVM: 16.0.6\nDefault target: aarch64-unknown-linux-gnu\n"`
LIBRARY_PATH = `"/usr/bin/../lib/crystal"`
LIBRARY_RPATH = `""`
LLVM_VERSION = `"16.0.6"`
PATH = `"lib:/build/crystal/src/crystal-1.11.2/src"`
VERSION = `"1.11.2"`

##
Class Method Summary

- .main(&)

  Defines the main routine run by normal Crystal programs:

- .main(argc : Int32, argv : Pointer(Pointer(UInt8)))

  Main method run by all Crystal programs at startup.

- .main_user_code(argc : Int32, argv : Pointer(Pointer(UInt8)))

  Executes the main user code.

##
Class Method Detail

def self.main(&) #

Defines the main routine run by normal Crystal programs:

- Initializes the GC
- Invokes the given block
- Handles unhandled exceptions
- Invokes `at_exit` handlers
- Flushes `STDOUT` and `STDERR`

This method can be invoked if you need to define a custom main (as in C main) function, doing all the above steps.

For example:

    fun main(argc : Int32, argv : UInt8**) : Int32
      Crystal.main do
        elapsed = Time.measure do
          Crystal.main_user_code(argc, argv)
        end
        puts "Time to execute program: #{elapsed}"
      end
    end

Note that the above is really just an example, almost the same can be accomplished with `at_exit`. But in some cases redefinition of C's main is needed.

def self.main(argc : Int32, argv : Pointer(Pointer(UInt8))) #

Main method run by all Crystal programs at startup.

This setups up the GC, invokes your program, rescuing any handled exception, and then runs `at_exit` handlers.

This method is automatically invoked for you, so you don't need to invoke it.

However, if you need to define a special main C function, you can redefine main and invoke `Crystal.main` from it:

    fun main(argc : Int32, argv : UInt8**) : Int32
      # some setup before Crystal main
      Crystal.main(argc, argv)
      # some cleanup logic after Crystal main
    end

The `Crystal.main` can also be passed as a callback:

    fun main(argc : Int32, argv : UInt8**) : Int32
      LibFoo.init_foo_and_invoke_main(argc, argv, ->Crystal.main(Int32, UInt8**))
    end

Note that before `Crystal.main` is invoked the GC is not setup yet, so nothing that allocates memory in Crystal (like `new` for classes) can be used.

def self.main_user_code(argc : Int32, argv : Pointer(Pointer(UInt8))) #

Executes the main user code. This normally is executed after initializing the GC and before executing `at_exit` handlers.

You should never invoke this method unless you need to redefine C's main function. See `Crystal.main` for more details.