libtcc-ruby

require 'tcc'

# A quick one-line example
TCC::State.new.compile('main(){puts("Hello");return 2;}').run
# Hello
# => 2 (`run` returns exit code)


# Macros and runtime arguments
state = TCC::State.new
state.define_symbol('R', 'return r;')
state.compile('r;main(i,s)char**s;{for(;i--;)r+=atoi(s[i]);R}')
state.run(['10', '20', '30', '40']) # => 100
state.destroy # Optionally. Ruby GC can properly free internal memory without this.


# Write the executable to disk instead of keeping it in memory
state = TCC::State.new(TCC::OUTPUT_EXE)
state.compile('main(){puts("Hello");exit(0);}')
state.output_file('a.out')
system './a.out' # Hello


# Define a C function or variable and call or access it from Ruby side
state = TCC::State.new
state.compile 'int c; long plus(long a, char* b) { return a + atol(b) + c; }'
state.relocate # This is necessary before `get_function` or `get_symbol`,
               # but should not be used before `run`. Read libtcc.h for details.
plus = state.get_function 'plus', [:long, :string], :long # Check ffi wiki for available types
plus.call(120, '0800') # => 920
c = state.get_symbol('c') # <FFI::Pointer>
c.read_int # => 0
c.write_int(3)
plus.call(120, '0800') # => 923


# Call Ruby method from C code (using the chainning style)
TCC::State.new \
  .add_symbol('mult', FFI::Function.new(:int, [:int, :int], proc {|a, b| a * b })) \
  .compile('int main() {return mult(2, 3);}').run # => 6


# A longer example, sorting an array of custom struct in C
class Record < FFI::Struct
  layout :id, :int,
         :name, [:char, 28]
end

state = TCC::State.new.compile(<<'!').relocate
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

typedef struct {
  int  id;
  char name[28];
} Record;

static int cmp(const void *p1, const void *p2) {
  int d1 = ((Record*) p1)->id - ((Record*) p2)->id;
  if (d1 != 0) return d1;
  return strcmp(((Record*) p1)->name, ((Record*) p2)->name);
}

void sort_records(Record records[], size_t n) {
  qsort((void*)records, n, sizeof(Record), cmp);
}
!

N = 20
records = FFI::MemoryPointer.new(Record, N)
N.times.map {|i| Record.new(records[i]).tap{|r| r[:id], r[:name] = rand(1..12), "Name-#{rand.to_s[2, 7]}"}}

print_records = proc { puts N.times.map {|i| r = Record.new(records[i]); [r[:id], r[:name]] * "\t"}}

puts 'Unsorted:'
print_records.call
state.get_function('sort_records', [:pointer, :size_t], :void).call(records, N)

puts 'Sorted:'
print_records.call


# TCC::Error is raised if `TCC::State` encounters an error
state = TCC::State.new
state.compile('int a;')
state.compile('int a;') # TCC::Error: <string>:1: error: 'a' defined twice
state.destroy
state.compile('int a;') # TCC::Error: Cannot reuse a destroyed TCC::State


# Use low-level TCC API directly
raw_state = TCC.new
TCC.set_output_type(raw_state, TCC::OUTPUT_MEMORY)
TCC.compile_string raw_state, <<'!'
int main(int argc, char *argv[]) {
    int r = 0, i;
    for (i = 0; i < argc; ++i) r += atoi(argv[i]);
    return r;
}
!
argv = %w(10 20 12)
pointer = FFI::MemoryPointer.new(:pointer, argv.size).tap do |p|
    p.write_array_of_pointer %w(10 20 12).map{|s| FFI::MemoryPointer.from_string(s)}
end
TCC.run(raw_state, argv.size, pointer) # => 42
TCC.compile_string raw_state, 'main(){}' # => -1, indicates an error. No `TCC::Error` raised
pointer.free
TCC.delete(raw_state) # This is necessary