Fibonacci in ...

dstr_sexp.rb

sexp = RubyParser.new.process(ruby)
find_dstrs(sexp)

# produces
[s(:dstr, "foo bar ", s(:evstr, s(:lvar, :baz)), s(:str, " qux"))]

evstr_sexp.rb

s(:evstr, s(:lvar, :baz))

fib.scm

(define fib
  (lambda (n)
    (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2))))))

find_dstrs.rb

# Find all dstrs "string literal with interpolation"
def find_dstrs(sexp)
  dstrs = []
  sexp.each do |sub_sexp|
    if Sexp === sub_sexp
      case sub_sexp.sexp_type
      when :block,:scope  # Lispers - this is the classical recursive step
        dstrs.concat find_dstrs(sub_sexp.sexp_body)
      when :dstr
        dstrs << sub_sexp
      end
    end
  end
  dstrs
end

node_excerpts.c

// from https://github.com/ruby/ruby/blob/trunk/node.c#L100-886
switch (nd_type(node)) {
  // ... snip ...
  case NODE_DSTR:
    ANN("string literal with interpolation");
    ANN("format: [nd_lit]");
    ANN("example: \"foo#{ bar }baz\"");
    goto dlit;
  // ... snip ...
  case NODE_LASGN:
    ANN("local variable assignment");
    ANN("format: [nd_vid](lvar) = [nd_value]");
    ANN("example: x = foo");
    goto asgn;
  // ... snip ...
}

ruby_parser_example.rb

require 'ruby_parser'
ruby = <<-RUBY
def string_foo_bar_baz(baz)
  baz ||= 10
  "foo bar \#{baz} qux"
end
RUBY
sexp = RubyParser.new.process(ruby)

pp sexp

shellcode_turing_machine.c

#define SHELLCODE_LENGTH 22
// Note: cltd is interesting at best!  It may produce broken solutions...
char shellcode[] = 
"\x99"                  /*  cltd                */
"\x52"                  /*  push   %edx         */
"\x68\x6e\x2f\x73\x68"  /*  push   $0x68732f6e  */
"\x68\x2f\x2f\x62\x69"  /*  push   $0x69622f2f  */
"\x89\xe3"              /*  mov    %esp,%ebx    */
"\x52"                  /*  push   %edx         */
"\x52"                  /*  push   %edx         */
"\x53"                  /*  push   %ebx         */
"\x53"                  /*  push   %ebx         */
"\xb0\x3b"              /*  mov    $0x3b,%al    */
"\xcd\x80"              /*  int    $0x80        */
;

int main(void) {
   int *ret;

   ret = (int *)&ret + 2;
   (*ret) = (int)shellcode;

   return(0);
}

simplest_possible_sexp_processor_example.rb

require 'sexp_processor'
class MyProcessor < SexpProcessor
  def initialize
    super
    self.strict = false
  end

  def process_until_empty(exp)
    process exp.shift until exp.empty?
  end

  def process_dstr(exp)
    puts "Found DSTR"
    pp exp
    exp.shift
    process_until_empty exp
    s() # an alias(-ish) for Sexp.new in SexpProcessor
  end
end

string_foo_bar_baz.rb

def string_foo_bar_baz(baz)
  baz ||= 10
  "foo bar #{baz} qux"
end

string_foo_bar_baz_sexp.rb

s(:defn,
 :string_foo_bar_baz,
 s(:args, :baz),
 s(:scope,
  s(:block,
   s(:op_asgn_or, s(:lvar, :baz), s(:lasgn, :baz, s(:lit, 10))),
   s(:dstr, "foo bar ", s(:evstr, s(:lvar, :baz)), :s(:str, " qux")))))