fix line numbering. positions now map to start of token instead of end

diff --git a/cerise-c.m b/cerise-c.m
index 9727244eed5164e93172b64f9130b1c86fbdcb8d..f2eb820637363988163bba05ce4d310be4b819a4 100644 (file)
--- a/cerise-c.m
+++ b/cerise-c.m
@@ -189,6 +189,7 @@ AddTwoNums(a : int, b : int)
 
 Main()
 {
+    AddTwoNums(1,2) + 5
     TestLiterals()
     TestBoolOps()
     TestIntOps()

diff --git a/lib/lexer.rb b/lib/lexer.rb
index dba3890e5c8f9002b09a5003ab88b480e27c0d0c..bf101c9e24fb21ffa340499850422227c1de6acc 100644 (file)
--- a/lib/lexer.rb
+++ b/lib/lexer.rb
@@ -46,6 +46,7 @@ class Lexer
   def next
     while @data.skip(SPACE) do
     end
+    pos = @data.pos
     if not @data.eos?
       type = :eof
       if @data.scan(IDENT)
@@ -61,9 +62,9 @@ class Lexer
       elsif @data.scan(OPERATORS)
         type = @data.matched
       end
-      tok = Tok.new(@data.matched, @file, @data.pos, type) if type
+      tok = Tok.new(@data.matched, @file, pos, type) if type
     else
-      tok = Tok.new("EOF", @file, @data.pos, :eof)
+      tok = Tok.new("EOF", @file, pos, :eof)
     end
 #    pp tok
     tok

diff --git a/lib/parser.rb b/lib/parser.rb
index 6188d99062c8ccf3a9434f30898b3317674b90e0..146370b80aa5a798d2112f58fa6b2f9ff1835a6f 100644 (file)
--- a/lib/parser.rb
+++ b/lib/parser.rb
@@ -18,7 +18,6 @@ class Parser
 #    syms.add_builtin(:int,    0, :type, :int)
 #    syms.add_builtin(:string, 0, :type, :string)
 #    syms.add_builtin(:float,  0, :type, :float)
-
 #    syms.add_builtin(:Length, :func, nil, nil)
 #    syms.add_builtin(:Error,  :func, [:any, :void], nil)
 

diff --git a/lib/type_checker.rb b/lib/type_checker.rb
index 3915cddf2c860032690a15c5f8c0829dab188f59..d7af957170834663c03de1175bb999a6e6e39334 100644 (file)
--- a/lib/type_checker.rb
+++ b/lib/type_checker.rb
@@ -346,8 +346,6 @@ class TypeChecker
     error(expr.loc, "unimplemented")
   end
 
-
-
   def make_typevar()
     @typevar ||= 0
     var = "abcdefghijklmnopqrstuvwxyz"[@typevar]
@@ -366,103 +364,6 @@ class TypeChecker
     env[func.name][:value]
   end
 
-#  def check_apply(env, expr, type)
-#    # Handle global functions that haven't been typed yet but are
-#    # being called. We pause to infer their type.
-#    if untyped_global_func?(env, expr.func, type)
-#      value = env[expr.func.name][:value]
-#      env[expr.func.name][:value] = nil
-#      infer(@parser.syms, value)
-#      type = infer(env, expr.func)
-#    end
-#
-#    error(expr.loc, "object being applied is not a function (has type: #{type.to_s})") if not type.is_a? Array
-#    error(expr.loc, "wrong number of arguments to function call") if (type.length - 1) != expr.args.length
-#    type[0..-2].each_with_index do |t,i|
-#      check(env, expr.args[i], t)
-#    end
-#    expr.type = type.last
-#  end
-#
-#  def check_ifexpr(env, expr, type)
-#    check(env, expr.cond, :bool)
-#    check(env, expr.then, type)
-#    check(env, expr.else, type)
-#  end
-#
-#
-#  def verify(cond, loc, msg)
-#    error(loc, msg) if not cond
-#  end
-#
-#  def check_func(env, expr, type)
-#    env = env.clone
-#    verify((type.length-1) == expr.args.length, expr.loc,
-#      "incorrect number of arguments (#{expr.args.length}, expected #{(type.length-1)}")
-#    expr.args.each_with_index do |a,i|
-#      env.add_sym(a.name, a.loc, :arg, type[i])
-#    end
-#    check(env, expr.expr, type.last)
-#  end
-#
-#  def check_let(env, let, type)
-#    env = env.clone
-#    env.add_sym(let.var.name, let.var.loc, :var, let.var.type)
-#    check(env, let.expr, type)
-#  end
-
-#
-#  def infer_let(env, let)
-#    if let.body.nil?
-#      infer_decl(env, let)
-#    else
-#      infer_let_expr(env, let)
-#    end
-#  end
-#
-#  def infer_decl(env, let)
-#    env = env.clone
-#    # handle the binding
-#    if let.var.type
-#      check(env, let.expr, let.var.type)
-#    else
-#      let.var.type = infer(env, let.expr)
-#    end
-#    env.set_type(let.var.name, let.var.type)
-#    env[let.var.name][:value] = nil
-#    let.type = :void
-#  end
-#
-#  def infer_let_expr(env, let)
-#    env = env.clone
-#
-#    # handle the binding
-#    if let.var.type
-#      check(env, let.expr, let.var.type)
-#    else
-#      let.var.type = infer(env, let.expr)
-#    end
-#
-#    env.add_sym(let.var.name, let.var.loc, :var, let.var.type)
-#    let.type = infer(env, let.body)
-#  end
-#
-#  def infer_ifexpr(env, expr)
-#    check(env, expr, infer(env, expr.then))
-#  end
-#
-#  def infer_set(env, expr)
-#    error(expr.loc, "infer_set unimplemented")
-#  end
-#
-#  def assign_type(env, var, type)
-#    if var.class == IR::Var and (var.type.nil? or var.type == String) then
-#      var.type = type
-#      env[var.name][:type] = type
-#    end
-#  end
-
-
   def check_unary(env, expr, vtype)
     optype = UnaryOps[expr.op][TypesToBase[vtype]]
     error(expr.loc, "unknown unary operation '#{expr.op}' for operand type #{vtype}") if not optype