Compiles a Cure expression to BEAM instructions using default state.

This is the main expression compilation entry point that handles conversion of all Cure expression types to equivalent BEAM bytecode instructions.

Arguments

• Expr - Expression AST node (various expr record types)

Returns

• {Instructions, State} - BEAM instructions and updated compilation state
• {error, Reason} - Compilation error details

Example

Expr = #binary_op_expr{op = '+', left = {literal, 5}, right = {literal, 3}},
{Instructions, _State} = cure_codegen:compile_expression(Expr).

Supported Expression Types

• Literals (integers, atoms, strings, booleans)
• Identifiers (variables, function references)
• Binary operations (arithmetic, logical, comparison)
• Function calls (local and remote)
• Control flow (if/else, pattern matching)
• Data structures (lists, tuples, records)
• Lambda expressions and blocks
• String interpolation
• Type annotations

Error Handling

Returns detailed error information for unsupported expressions, type mismatches, and compilation failures.

Compiles a finite state machine definition to BEAM runtime functions.

This function transforms a Cure FSM definition into executable BEAM code that integrates with the FSM runtime system. It generates helper functions for spawning, controlling, and querying FSM instances.

Arguments

• FSMDef - FSM definition AST node (#fsm_def{})
• State - Current compilation state

Returns

• {ok, {fsm, CompiledFSM}, NewState} - Successfully compiled FSM
• {error, Reason} - Compilation error details

Generated Functions

For an FSM named Counter, generates:

• Counter_spawn/0 - Spawn FSM with default initial state
• Counter_spawn/1 - Spawn FSM with custom initial data
• Counter_send/2 - Send event to FSM instance
• Counter_state/1 - Get current state of FSM instance
• Counter_stop/1 - Stop FSM instance gracefully
• Counter_definition/0 - Get compiled FSM definition

Example

FSM = #fsm_def{
    name = 'Counter',
    states = [idle, counting],
    initial = idle,
    state_defs = [IdleState, CountingState]
},
{ok, {fsm, CompiledFSM}, NewState} = compile_fsm_impl(FSM, State).

FSM Runtime Integration

• Compiles FSM to cure_fsm_runtime format
• Generates proper BEAM bytecode for FSM operations
• Integrates with gen_statem behavior patterns
• Handles state transitions, events, and timeouts
• Provides type-safe FSM interface functions

State Management

FSMs maintain state data through:

• Initial state setup from spawn parameters
• State data transformation during transitions
• Event payload integration with state data
• Timeout handling with state persistence

Compiles a single Cure function to BEAM bytecode using default options.

This function handles standalone function compilation, primarily used for testing and development. In normal compilation, functions are compiled as part of module compilation.

Arguments

• FunctionAST - Function AST node (function_def record or tuple format)

Returns

• {ok, CompiledFunction, State} - Successfully compiled function with state
• {error, Reason} - Compilation error details

Example

FuncAST = #function_def{
    name = add,
    params = [x, y],
    body = {binary_op, '+', {var, x}, {var, y}}
},
{ok, CompiledFunc, _State} = cure_codegen:compile_function(FuncAST).

Function Processing

• Converts function parameters to BEAM registers
• Compiles function body expressions to BEAM instructions
• Handles pattern matching in parameters
• Generates proper function entry and exit code
• Applies function-level optimizations

Limitations

• Creates minimal compilation state for standalone compilation
• May not have access to full module context for imports/types
• Primarily intended for testing individual functions

Compiles a single Cure module to BEAM bytecode using default options.

This function handles compilation of complete module definitions including exports, imports, function definitions, FSM definitions, and type definitions. It converts Cure module AST to BEAM-compatible Erlang forms.

Arguments

• ModuleAST - Module AST node (module_def record or tuple format)

Returns

• {ok, CompiledModule} - Successfully compiled module ready for BEAM
• {error, Reason} - Compilation error with details

Example

ModuleAST = #module_def{
    name = 'MyModule',
    exports = [{foo, 2}, {bar, 1}],
    items = [FuncDef1, FuncDef2]
},
{ok, BeamModule} = cure_codegen:compile_module(ModuleAST),
cure_codegen:write_beam_module(BeamModule, "MyModule.beam").

Module Processing

• Processes imports and builds import environment
• Validates and converts export specifications
• Compiles all module items (functions, FSMs, types)
• Generates proper BEAM module structure with attributes
• Handles both old and new AST formats for compatibility

Supported Module Items

• Function definitions (regular and Erlang functions)
• FSM definitions (compiled to gen_statem)
• Record and type definitions
• Import and export declarations

Compiles a complete Cure program to BEAM bytecode using default options.

This is a convenience function that calls compile_program/2 with default compilation options.

Arguments

• AST - List of top-level AST items (modules, functions, etc.)

Returns

• {ok, Modules} - Successfully compiled modules
• {error, {compilation_failed, Errors}} - Compilation failures

Example

AST = cure_parser:parse_file("program.cure"),
{ok, Modules} = cure_codegen:compile_program(AST),
lists:foreach(fun(Module) ->
    cure_codegen:write_beam_module(Module, filename(Module))
end, Modules).

Default Options

Uses standard compilation options: debug_info, optimization level 1, warnings enabled, strict types, and FSM integration.

Generates a BEAM bytecode file from a compiled Cure module.

This function converts the internal compiled module representation to standard Erlang abstract forms, then uses the Erlang compiler to produce a BEAM bytecode file compatible with the Erlang Virtual Machine.

Arguments

• Module - Compiled module data (map with functions, exports, etc.)
• OutputPath - File path where BEAM file should be written

Returns

• {ok, {ModuleName, OutputPath}} - Successfully generated BEAM file
• {error, Reason} - Generation error details

Example

{ok, CompiledModule} = cure_codegen:compile_module(ModuleAST),
{ok, {MyModule, "MyModule.beam"}} = 
    cure_codegen:generate_beam_file(CompiledModule, "MyModule.beam").

Process Steps

1. Form Conversion: Convert internal representation to Erlang forms
2. Erlang Compilation: Use Erlang compiler to generate bytecode
3. File Writing: Write binary BEAM data to specified path
4. Error Handling: Provide detailed errors at each step

BEAM Compatibility

Generated BEAM files are fully compatible with:

• Standard Erlang/OTP runtime
• Elixir and other BEAM languages
• BEAM development and debugging tools
• Hot code reloading and distribution

Error Types

• {write_failed, Reason} - File system errors
• {compile_failed, Errors, Warnings} - Erlang compiler errors
• Form conversion errors from convert_to_erlang_forms/1

Writes a compiled Cure module to a BEAM file.

This is a convenience function that calls generate_beam_file/2 to convert a compiled module to BEAM bytecode and write it to the specified path.

Arguments

• Module - Compiled module data from compile_module/1,2
• OutputPath - File path where BEAM file should be written

Returns

• {ok, {ModuleName, OutputPath}} - Successfully written BEAM file
• {error, Reason} - File writing or compilation error

Example

{ok, CompiledModule} = cure_codegen:compile_module(AST),
{ok, {MyModule, "MyModule.beam"}} = 
    cure_codegen:write_beam_module(CompiledModule, "MyModule.beam"),

%% Load and test the module
code:load_file(MyModule),
MyModule:function_name(args).

Use Cases

• Final step in Cure compilation pipeline
• Integration with build systems and tools
• Deployment of Cure modules to BEAM environments
• Testing and development workflows