step13/0000755000000000000000000000000011137135304010671 5ustar rootrootstep13/Makefile0000644000000000000000000000074511137114502012334 0ustar rootroot all: parser parser: parser.o runtime.o parser.o: parser.s parser.s: parser.rb ruby parser.rb >parser.s parser2: parser2.o runtime.o parser2.o: parser2.s parser2.s: parser2.rb parser ruby parser2.rb >parser2.s parser2.rb: parser.l parser @./parser parser2.rb clean: @rm -f *~ *.o *.s parser parser2 testarray.s: testarray.rb ruby testarray.rb >testarray.s testarray.o: testarray.s testarray: testarray.o runtime.o gcc -o testarray testarray.o runtime.o step13/compiler.rb0000644000000000000000000001232311137134474013040 0ustar rootroot#!/bin/env ruby require 'emitter' DO_BEFORE= [ [:defun, :array, [:size],[:malloc,[:mul,:size,4]]] ] DO_AFTER= [] class Function attr_reader :args,:body def initialize args,body @args = args @body = body end end class Scope def initialize compiler,func @c = compiler @func = func end def get_arg a a = a.to_sym @func.args.each_with_index {|arg,i| return [:arg,i] if arg == a } return [:addr,a] end end class LocalVarScope def initialize locals, next_scope @next = next_scope @locals = locals end def get_arg a a = a.to_sym return [:lvar,@locals[a]] if @locals.include?(a) return @next.get_arg(a) if @next return [:addr,a] # Shouldn't get here normally end end class Compiler attr_reader :global_functions def initialize @e = Emitter.new @global_functions = {} @string_constants = {} end def get_arg(scope,a) return compile_exp(scope,a) if a.is_a?(Array) return [:int, a] if (a.is_a?(Fixnum)) return scope.get_arg(a) if (a.is_a?(Symbol)) lab = @string_constants[a] if !lab lab = @e.get_local @string_constants[a] = lab end return [:strconst,lab] end def output_constants @e.rodata { @string_constants.each { |c,l| @e.string(l,c) } } end def output_functions @global_functions.each do |name,func| @e.func(name) { compile_eval_arg(Scope.new(self,func),func.body) } end end def compile_defun scope,name, args, body @global_functions[name] = Function.new(args,body) return [:addr,name] end def compile_ifelse scope,cond, if_arm,else_arm = nil compile_exp(scope,cond) l_else_arm = @e.get_local l_end_if_arm = @e.get_local @e.jmp_on_false(l_else_arm) compile_exp(scope,if_arm) @e.jmp(l_end_if_arm) if else_arm @e.local(l_else_arm) compile_exp(scope,else_arm) if else_arm @e.local(l_end_if_arm) if else_arm return [:subexpr] end def compile_lambda scope,args, body compile_defun(scope,@e.get_local, args,body) end def compile_eval_arg scope,arg atype, aparam = get_arg(scope,arg) return aparam if atype == :int return @e.addr_value(aparam) if atype == :strconst @e.load_address(aparam) if atype == :addr @e.emit(:movl,"(%#{aparam.to_s})",@e.result_value) if atype == :indirect @e.load_arg(aparam) if atype == :arg @e.load_local_var(aparam) if atype == :lvar return @e.result_value end def compile_assign scope, left, right source = compile_eval_arg(scope, right) @e.pushl(source) atype, aparam = get_arg(scope,left) if atype == :indirect @e.popl(:eax) @e.emit(:movl,source,"(%#{aparam})") elsif atype == :lvar @e.popl(:eax) @e.save_to_local_var(source,aparam) elsif atype == :arg @e.popl(:eax) @e.save_to_arg(source,aparam) else raise "Expected an argument on left hand side of assignment" end return [:subexpr] end def compile_call scope,func, args @e.with_stack(args.length) do args.each_with_index do |a,i| param = compile_eval_arg(scope,a) @e.save_to_stack(param,i) end @e.call(compile_eval_arg(scope,func)) end return [:subexpr] end def compile_do(scope,*exp) exp.each { |e| source=compile_eval_arg(scope,e); @e.save_result(source); } return [:subexpr] end def compile_index scope,arr,index source = compile_eval_arg(scope, arr) @e.movl(source,:edx) source = compile_eval_arg(scope, index) @e.save_result(source) @e.sall(2,:eax) @e.addl(:eax,:edx) return [:indirect,:edx] end def compile_while(scope, cond, body) @e.loop do |br| var = compile_eval_arg(scope,cond) @e.jmp_on_false(br) compile_exp(scope,body) end return [:subexpr] end def compile_let(scope,varlist,*args) vars = {} varlist.each_with_index {|v,i| vars[v]=i} ls = LocalVarScope.new(vars,scope) @e.with_local(vars.size) { compile_do(ls,*args) } end def compile_exp(scope,exp) return if !exp || exp.size == 0 return compile_do(scope,*exp[1..-1]) if exp[0] == :do return compile_defun(scope,*exp[1..-1]) if (exp[0] == :defun) return compile_ifelse(scope,*exp[1..-1]) if (exp[0] == :if) return compile_lambda(scope,*exp[1..-1]) if (exp[0] == :lambda) return compile_assign(scope,*exp[1..-1]) if (exp[0] == :assign) return compile_while(scope,*exp[1..-1]) if (exp[0] == :while) return compile_index(scope,*exp[1..-1]) if (exp[0] == :index) return compile_let(scope,*exp[1..-1]) if (exp[0] == :let) return compile_call(scope,exp[1],exp[2]) if (exp[0] == :call) return compile_call(scope,exp[0],exp[1..-1]) if (exp.is_a? Array) STDERR.puts "Somewhere calling #compile_exp when they should be calling #compile_eval_arg? #{exp.inspect}" res = compile_eval_arg(scope,exp[0]) @e.save_result(res) return [:subexpr] end def compile_main(exp) @e.main do # We should allow arguments to main # so argc and argv get defined, but # that is for later. @main = Function.new([],[]) compile_eval_arg(Scope.new(self,@main),exp) end output_functions output_constants end def compile(exp) compile_main([:do, DO_BEFORE, exp, DO_AFTER]) end end step13/parser.l0000644000000000000000000000150211137114502012335 0ustar rootroot (do (defun parse_quoted (c) (while (and (ne (assign c (getchar)) -1) (ne c 34)) (do (putchar c)) ) ) (defun parse (c sep) (while (and (ne (assign c (getchar)) -1) (ne c 41)) (do (if (eq c 40) (do (printf "[") (parse 0 0) (printf "]") (assign sep 1) ) (if (eq c 34) (do (putchar 34) (parse_quoted 0) (putchar 34) (assign sep 1) ) (do (if (and (isspace c) sep) (do (printf ",") (assign sep 0) ) ) (if (and (isalnum c) (not sep)) (do (assign sep 1) (if (not (isdigit c)) (printf ":")) ) ) (putchar c) ) ) ) ) ) ) (puts "require 'compiler'\\n") (puts "prog = [:do,") (parse 0 0) (puts "]\n\n") (puts "Compiler.new.compile(prog)") ) step13/parser.rb0000644000000000000000000000237011137114502012511 0ustar rootroot require 'compiler' prog = [:do, [:defun, :parse_quoted, [:c], [:while, [:and, [:ne, [:assign, :c, [:getchar]], -1], [:ne, :c, 34]], [:do, [:putchar, :c] ] ] ], [:defun, :parse, [:c,:sep], [:while, [:and, [:ne, [:assign, :c, [:getchar]], -1], [:ne, :c, 41]], [:do, [:if, [:eq,:c, 40], [:do, [:printf, "["], [:parse,0,0], [:printf, "]"], [:assign, :sep, 1] ], [:if, [:eq, :c, 34], [:do, [:putchar,34], [:parse_quoted,0], [:putchar,34], [:assign, :sep, 1] ], [:do, [:if, [:and, [:isspace, :c], :sep], [:do, [:printf, ","], [:assign, :sep, 0] ] ], [:if, [:and, [:isalnum, :c], [:not, :sep]], [:do, [:assign, :sep, 1], [:if, [:not, [:isdigit, :c]],[:printf,":"]] ] ], [:putchar, :c] ] ] ] ] ] ], [:puts, "require 'compiler'\\n"], [:puts, "prog = [:do,"], [:parse, 0,0], [:puts, "]\\n"], [:puts, "Compiler.new.compile(prog)"] ] Compiler.new.compile(prog) step13/testarray.rb0000644000000000000000000000042311137135020013226 0ustar rootroot require 'compiler' prog = [:let, [:i], [:assign, :i, [:array, 2]], [:printf, "i=%p\n",:i], [:assign, [:index, :i, 0], 2], [:assign, [:index, :i, 1], 42], [:printf, "i[0]=%ld, i[1]=%ld\\n",[:index,:i,0],[:index,:i,1]] ] Compiler.new.compile(prog) step13/runtime.c0000644000000000000000000000132711137114502012520 0ustar rootroot signed int add(signed int a, signed int b) { return a + b; } signed int sub(signed int a, signed int b) { return a - b; } signed int div(signed int a, signed int b) { return a / b; } signed int mul(signed int a, signed int b) { return a * b; } signed int ne(signed int a, signed int b) { return a != b; } signed int eq(signed int a, signed int b) { return a == b; } signed int not(signed int a) { return !a; } // Note that our "and" won't shortcircuit, as the // evaluation happens before this function is called. signed int and(signed int a, signed int b) { return a && b; } signed int gt(signed int a, signed int b) { return a > b; } signed int lt(signed int a, signed int b) { return a < b; } step13/emitter.rb0000644000000000000000000000573211137131343012675 0ustar rootroot class Emitter PTR_SIZE = 4 # Point size in bytes. We are evil and assume 32bit arch. for now attr_accessor :seq def initialize @seq = 0 end def export(label,type=nil) puts ".globl #{label}" puts "\t.type\t#{label}, @#{type.to_s}" end def rodata emit(".section",".rodata") yield end def local_arg(aparam) "#{PTR_SIZE*(aparam+2)}(%ebp)" end def local_var(aparam) # FIXME: The +2 instead of +1 is ecause %ecx is pushed onto the stack in "main". It's really only needed there. "-#{PTR_SIZE*(aparam+2)}(%ebp)" end def label(l) puts "#{l.to_s}:" l end def local(l=nil) l = get_local if !l label(l) end def int_value param return "$#{param.to_i}" end def addr_value param return "$#{param.to_s}" end def result_value return :eax end def to_operand_value src return int_value(src) if src.is_a?(Fixnum) return "%#{src.to_s}" if src.is_a?(Symbol) return src.to_s end # Store "param" in stack slot "i" def save_to_stack param,i movl(param,"#{i>0 ? i*4 : ""}(%esp)") end def save_result(param) movl(param,:eax) if param != :eax end def load_arg(aparam) movl(local_arg(aparam),:eax) end def load_local_var(aparam) movl(local_var(aparam),:eax) end def save_to_local_var(arg,aparam) movl(arg,local_var(aparam)) end def save_to_arg(arg,aparam) movl(arg,local_arg(aparam)) end def load_address(label) save_result(addr_value(label)) end def with_local(args) # FIXME: The "+1" is a hack because main contains a pushl %ecx with_stack(args+1) { yield } end def with_stack(args) # gcc does 4 bytes regardless of arguments, and then jumps up 16 at a time # We will do the same, but assume its tied to pointer size adj = PTR_SIZE + (((args+0.5)*PTR_SIZE/(4.0*PTR_SIZE)).round) * (4*PTR_SIZE) subl(adj,:esp) yield addl(adj,:esp) end def emit op,*args puts "\t#{op}\t"+args.collect{|a|to_operand_value(a)}.join(', ') end def method_missing(sym,*args) emit(sym,*args) end def call loc if loc.is_a?(Symbol) emit(:call,"*"+to_operand_value(loc)) else emit(:call,loc) end end def string l,str local(l) emit(".string","\"#{str}\"") end def jmp_on_false(label,op=:eax) testl(op,op) je(label) end def get_local @seq +=1 ".L#{@seq-1}" end def loop br = get_local l = local yield(br) jmp(l) local(br) end def func name export(name,:function) if name.to_s[0] != ?. label(name) pushl(:ebp) movl(:esp,:ebp) yield leave ret emit(".size",name.to_s, ".-#{name}") end def main puts ".text" export(:main,:function) label(:main) leal("4(%esp)",:ecx) andl(-16,:esp) pushl("-4(%ecx)") pushl(:ebp) movl(:esp,:ebp) pushl(:ecx) yield popl(:ecx) popl(:ebp) leal("-4(%ecx)",:esp) ret() emit(".size","main",".-main") end end