Module: DsLisp::CommonLispOperators

Defined in:
lib/dslisprb.rb

Class Method Summary collapse

Class Method Details

.block(code) ⇒ Object 



96
97
98
 
# File 'lib/dslisprb.rb', line 96

def block(code)
  code[1..-1].map(&ToRuby.method(:to_ruby)).join(";")
end

.cond(code) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/dslisprb.rb', line 49

def cond(code)
  "(nil.tap { 
  " + code[1..-1].map{ |condition_code|
    "(break (#{ToRuby.to_ruby condition_code[1]}) if (aux = (#{ToRuby.to_ruby condition_code[0]}); aux != [] and aux != nil) )"
  }.join(";") + "})"
end

.defmacro(code) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/dslisprb.rb', line 109

def defmacro(code)
  name = code[1]
  arguments = code[2]
  impl = code[3][1]

  subsl = Kernel.lambda{|_code, rplmap|
    _code.map{|subcode|
      if Array === subcode
        subsl.call(subcode, rplmap)
      else
        rplmap[subcode] || subcode
      end
    }
  }

  CommonLispOperators.define_singleton_method(name) do |_code|
    rplmap = {}          
    (0..arguments.size-1).each do |i|
      rplmap[arguments[i]] = _code[i+1]
    end

    ToRuby.to_ruby subsl.call(impl, rplmap)
  end

  ""
end

.defun(code) ⇒ Object 



104
105
106
107
 
# File 'lib/dslisprb.rb', line 104

def defun(code)
  newcode = [:set, code[1], [:lambda, code[2], code[3]]] 
  ToRuby.to_ruby(newcode)
end

.if(code) ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/dslisprb.rb', line 56

def if(code)
  "(if (aux = (#{ToRuby.to_ruby code[1]}); aux != [] and aux != nil)
      #{ToRuby.to_ruby code[2]}
    else
      #{ToRuby.to_ruby code[3]}
    end
   )
   "
end

.lambda(code) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/dslisprb.rb', line 71

def lambda(code)
  arguments = code[1].select{|x| x != :"&optional"}.map{|x| Array === x ? x[0] : x}.map(&ToRuby.method(:name_convert)).map(&:to_s)
  x_optional = code[1].select{|x| x != :"&optional"}.map{|x|
      if Array === x
        ToRuby.to_ruby(x[1])
      else
        "nil"
      end
  }

  @count = (@count || 0) + 1
  oldargsvar = "oldargs_#{@count}"

  "(lambda{|*x|
      #{oldargsvar} = [ #{arguments.map{|z| "begin; #{z}; rescue; nil; end"}.join(",")} ] # save current bindings
      #{(0..arguments.size-1).map{|i| "#{arguments[i]} = x[#{i}] || #{x_optional[i]}" }.join(";")} 
      begin
        aux = #{ToRuby.to_ruby(code[2])}
      ensure
        #{(0..arguments.size-1).map{|i| "#{arguments[i]} = #{oldargsvar}[#{i}]" }.join(";")}
      end
      aux
    }.lisp_inner_code(#{code.lisp_inspect.inspect}))"
end

.let(code) ⇒ Object 



66
67
68
69
 
# File 'lib/dslisprb.rb', line 66

def let(code)
  newcode = [[:lambda, code[1].map(&:first), code[2]]] + code[1].map{|x|x[1]}
  ToRuby.to_ruby(newcode)
end

.quote(code) ⇒ Object 



45
46
47
 
# File 'lib/dslisprb.rb', line 45

def quote(code)
  code[1].inspect
end

.set(code) ⇒ Object 



100
101
102
 
# File 'lib/dslisprb.rb', line 100

def set(code)
  "#{ToRuby.name_convert(code[1])} = #{ToRuby.to_ruby(code[2])}"
end