calcula 0.1.0 → 1.0.0

data/lib/Exprs/ParamsExpr.rb

@@ -1,27 +1,33 @@
 require_relative "../Expr"
 
-module Calcula::Exprs
-  class ParamsExpr < Calcula::Expr
+# Expression for representing parameter lists (for functions)
+#
+# @author Paul T.
+class Calcula::Exprs::ParamsExpr < Calcula::Expr
 
-    # params: List[Token]
-    def initialize(params)
-      @params = params
-    end
+  # @param params [Array<Calcula::Token>] The tokens should all have type of ID
+  def initialize(params)
+    @params = params
+  end
 
-    def to_s()
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    case form
+    when :src then
       @params.collect { |e| e.text }.join(',')
+    when :tree, :ruby then
+      "(#{self})"
+    else
+      nil
     end
+  end
 
-    def to_tree()
-      "(#{to_s()})"
-    end
-
-    def exec(binding)
-      return to_s()
-    end
-
-    def children()
-      []
-    end
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    []
   end
 end

data/lib/Exprs/RatExpr.rb

@@ -0,0 +1,37 @@
+require_relative "../Expr"
+
+# Expression for representing fractions
+#
+# @author Paul T.
+class Calcula::Exprs::RatExpr < Calcula::Expr
+
+  # @param top [Calcula::Token]  The token should have the type of NUM
+  # @param bot [Calcula::Token]  The token should have the type of NUM
+  def initialize(top, bot)
+    @top = top
+    @bot = bot
+  end
+
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    case form
+    when :src then
+      "#{@top.text}//#{@bot.text}"
+    when :tree then
+      "(rat #{@top.text} #{@bot.text})"
+    when :ruby then
+      "Rational(#{@top.text}, #{@bot.text})"
+    else
+      nil
+    end
+  end
+
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    []
+  end
+end

data/lib/Exprs/UnaryExpr.rb

@@ -0,0 +1,84 @@
+require_relative "../Expr"
+
+# Expression for unary operators
+#
+# @author Paul T.
+class Calcula::Exprs::UnaryExpr < Calcula::Expr
+
+  # @param op [Calcula::Token] Should have type prefixed with `OP_`
+  # @param base [Calcula::Expr]
+  # @param prefixed [true, false]
+  def initialize(op, base, prefixed:)
+    @op = op
+    @base = base
+    @prefixed = prefixed
+  end
+
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    baseTxt = @base.to_s(form: form)
+    case form
+    when :src then
+      @prefixed ? "#{@op.text}#{baseTxt}" : "#{baseTxt}#{@op.text}"
+    when :tree then
+      "(#{@op.text} #{baseTxt})"
+    when :ruby then
+      if @prefixed then
+        case @op.id
+        when :OP_ADD then
+          "(#{baseTxt}).abs"
+        when :NOT then
+          "!(#{baseTxt})"
+        else
+          "#{@op.text}#{baseTxt}"
+        end
+      else
+        case @op.id
+        when :ROUND_DOLLAR then
+          "(#{baseTxt}).to_f.round(2)"
+        when :DISP then
+          "puts _ = #{baseTxt}\n_"
+        when :ASSERT then
+          "_ = #{baseTxt}\nif _ == false then\n  raise 'Equation #{@base.to_s} failed'\nend"
+        else "#{baseTxt}#{@op.text}"
+        end
+      end
+    else
+      nil
+    end
+  end
+
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    [@base]
+  end
+
+  # Creates a prefixed unary expression. Shorthand for
+  # `UnaryExpr.new(op, base, prefixed: true)`.
+  #
+  # @see Calcula::Exprs::UnaryExpr#initialize
+  # @see Calcula::Exprs::UnaryExpr#mkPostfix
+  # @param op [Calcula::Token] Should have type prefixed with `OP_`
+  # @param base [Calcula::Expr]
+  # @return [Calcula::Exprs::UnaryExpr] The newly created prefix unary expression
+  def self.mkPrefix(op, base)
+    new(op, base, prefixed: true)
+  end
+
+
+  # Creates a postfix unary expression. Shorthand for
+  # `UnaryExpr.new(op, base, prefixed: false)`.
+  #
+  # @see Calcula::Exprs::UnaryExpr#initialize
+  # @see Calcula::Exprs::UnaryExpr#mkPrefix
+  # @param op [Calcula::Token] Should have type prefixed with `OP_`
+  # @param base [Calcula::Expr]
+  # @return [Calcula::Exprs::UnaryExpr] The newly created postfix unary expression
+  def self.mkPostfix(op, base)
+    new(op, base, prefixed: false)
+  end
+end

data/lib/Lexer.rb

@@ -1,137 +1,176 @@
-class Array
+# A lexer for the Calcula language written in Ruby.
+#
+# @author Paul T.
+class Calcula::Lexer
 
-  # el: [T]
-  def ===(el)
-    return find_index(el) != nil
+  ZERO_TO_NINE = "0".."9"
+  LOWER_A_TO_Z = "a".."z"
+  UPPER_A_TO_Z = "A".."Z"
+
+  SINGLE_CHAR_TOKEN = {
+    "(" => :PAREN_O, ")" => :PAREN_C,
+    "[" => :SQUARE_O, "]" => :SQUARE_C,
+    "+" => :OP_ADD, "-" => :OP_SUB,
+    "%" => :OP_REM, "$" => :ROUND_DOLLAR,
+    "@" => :COMPOSE, ";" => :DISP,
+    "," => :COMMA, "\\" => :LAMBDA,
+    "=" => :OP_EQ,
+
+    " " => :WS, "\t" => :WS, "\r" => :WS,
+    "\f" => :WS, "\n" => :WS
+  }
+
+  # Constructs a new Lexer instance
+  #
+  # @param src [String] The source code
+  def initialize(src)
+    @src = src
+    @i = 0
+    @lineNum = 0
+    @linePos = 0
   end
-end
 
-module Calcula
-  class Lexer
-    ZERO_TO_NINE = "0".."9"
-    A_TO_Z = ("a".."z").to_a + ("A" .. "Z").to_a
+  # Raises a error with a seemingly useful message
+  #
+  # @raise [RuntimeError] Calling this method raises this error
+  # @param msg [String] The additional message or the reason of the error
+  def lexError(msg)
+    raise "Failed to lex past (L#{@lineNum + 1}:#{@linePos + 1}): #{if msg != "" then msg else "<no message>" end}"
+  end
 
-    # src: string
-    def initialize(src)
-      @src = src
-      @i = 0
-      @lineNum = 0
+  # Advances the line number and the column position based on the character found
+  #
+  # @param c [Character] The character used to determine the advancing rule
+  def advancePos(c)
+    @i += 1
+    if c == '\n' then
+      @lineNum += 1
       @linePos = 0
+    else
+      @linePos += 1
     end
+  end
 
-    # msg: string
-    def lexError(msg)
-      raise "Failed to lex past (L#{@lineNum + 1}:#{@linePos + 1}): #{if msg != "" then msg else "<no message>" end}"
-    end
-
-    # c: char
-    def advancePos(c)
-      @i += 1
-      if c == '\n' then
-        @lineNum += 1
-        @linePos = 0
-      else
-        @linePos += 1
-      end
+  # Consumes characters until the block yields false. The first character is
+  # consumed no matter what.
+  #
+  # @param pre_append [Optional, lambda] Executed before appending. If returns false, the process terminates and the consumed chars are returned
+  # @param post_append [Optional, lambda] Executed after appending. If returns false, the process terminates and the consumed chars are returned
+  # @yield [c] Predicate for whether or not character consumption should continue
+  # @yieldparam c [String (Char)] The current character
+  # @yieldreturn [true, false] true if consumption should continue, false otherwise
+  # @return [String] The characters being consumed
+  def consumeWhen(pre_append: ->(_c){ true }, post_append: ->(_c){ true })
+    advancePos(buf = @src[@i])
+    while @i < @src.length && yield(@src[@i]) do
+      break unless pre_append.call(@src[@i])
+      buf += @src[@i]
+      advancePos(@src[@i])
+      break unless post_append.call(@src[@i])
     end
+    buf
+  end
 
-    def lex()
-      len = @src.length
-      rst = []
-      while @i < len do
-        case (@src[@i])
-        when "(" then
-          advancePos(@src[@i])
-          rst << Token.new(:PAREN_O, "(")
-        when ")" then
-          advancePos(@src[@i])
-          rst << Token.new(:PAREN_C, ")")
-        when "[" then
-          advancePos(@src[@i])
-          rst << Token.new(:SQUARE_O, "[")
-        when "]" then
-          advancePos(@src[@i])
-          rst << Token.new(:SQUARE_C, "]")
-        when "+" then
-          advancePos(@src[@i])
-          rst << Token.new(:OP_ADD, "+")
-        when "-" then
-          advancePos(@src[@i])
-          rst << Token.new(:OP_SUB, "-")
-        when "*" then
-          advancePos(@src[@i])
-          if @src[@i] == "*" then
-            advancePos(@src[@i])
-            rst << Token.new(:OP_POW, "**")
-          else
-            rst << Token.new(:OP_MUL, "*")
-          end
-        when "/" then
-          advancePos(@src[@i])
-          rst << Token.new(:OP_DIV, "/")
-        when "=" then
-          advancePos(@src[@i])
-          rst << Token.new(:ASSIGN, "=")
-        when "%" then
-          advancePos(@src[@i])
-          rst << Token.new(:OP_REM, "%")
-        when "$" then
-          advancePos(@src[@i])
-          rst << Token.new(:ROUND_DOLLAR, "$")
-        when "@" then
-          advancePos(@src[@i])
-          rst << Token.new(:COMPOSE, "@")
-        when ";" then
-          advancePos(@src[@i])
-          rst << Token.new(:DISP, ";")
-        when "\\" then
-          advancePos(@src[@i])
-          rst << Token.new(:LAMBDA, "\\")
-        when "," then
-          advancePos(@src[@i])
-          rst << Token.new(:COMMA, ",")
-        when "#" then
-          advancePos(buf = @src[@i])
-          while @i < len && @src[@i] != "\n" do
-            buf += @src[@i]
-            advancePos(@src[@i])
-          end
-          rst << Token.new(:COMMENT, buf)
-        when ZERO_TO_NINE then
-          advancePos(buf = @src[@i])
-          inDecimals = false
-          while @i < len && (ZERO_TO_NINE === @src[@i] || "." == @src[@i]) do
-            if @src[@i] == "." then
-              if !inDecimals then
-                inDecimals = true
-              else
-                break
-              end
+  # Starts the lexing routine which converts the source code into a list of tokens
+  #
+  # @return [Array<Calcula::Token>] The tokens based on the source code
+  def lex
+    len = @src.length
+    rst = []
+    while @i < len do
+      case @src[@i]
+      when "*" then
+        rst << potentialDuplicateToken(:OP_MUL, :OP_POW)
+      when "/" then
+        rst << potentialDuplicateToken(:OP_DIV, :RAT)
+      when "#" then
+        rst << Calcula::Token.new(:COMMENT, consumeWhen { |c| c != "\n" })
+      when "!" then
+        rst << continuousConsume(:ASSERT, {"=" => :OP_NE})
+      when "<" then
+        rst << continuousConsume(:OP_LT, {"=" => :OP_LE})
+      when ">" then
+        rst << continuousConsume(:OP_GT, {"=" => :OP_GE})
+      when LOWER_A_TO_Z, UPPER_A_TO_Z then
+        txtSeq = consumeWhen { |c| isIdentChar? c }
+        case txtSeq
+        when "let", "and", "or", "not" then # The textual keywords
+          rst << Calcula::Token.new(txtSeq.upcase.to_sym, txtSeq)
+        else
+          rst << Calcula::Token.new(:ID, txtSeq)
+        end
+      when ZERO_TO_NINE then
+        inDecimals = false
+        txt = consumeWhen(pre_append: ->(c){
+          if c == "." then
+            if !inDecimals then
+              inDecimals = true
+            else
+              lexError("Numbers with two or more decimal points are illegal")
             end
-            buf += @src[@i]
-            advancePos(@src[@i])
-          end
-          rst << Token.new(:NUM, buf)
-        when A_TO_Z then
-          advancePos(buf = @src[@i])
-          while @i < len && (A_TO_Z === @src[@i] || "'" == @src[@i]) do
-            buf += @src[@i]
-            advancePos(@src[@i])
           end
-          rst << Token.new(:ID, buf)
-        when [" ", "\t", "\r", "\f", "\n"] then
-          advancePos(ws = @src[@i])
-          rst << Token.new(:WS, ws)
-        else lexError("Unrecognized token starting with '#{@src[@i]}'")
+          true
+        }) { |c| isNumericChar? c }
+        rst << Calcula::Token.new(:NUM, txt)
+      else
+        if (type = SINGLE_CHAR_TOKEN[chr = @src[@i]]) != nil then
+          advancePos(@src[@i])
+          rst << Calcula::Token.new(type, chr)
+        else
+          lexError("Unrecognized token starting with '#{@src[@i]}'")
         end
       end
-      return rst
     end
+    return rst
+  end
 
-    def reset()
-      @i = 0
-      @lineNum = 0
-      @linePos = 0
+  # Resets the lexing position
+  def reset
+    @i = 0
+    @lineNum = 0
+    @linePos = 0
+  end
+
+  # Checks to see if the character is part of a valid identifier
+  #
+  # @param c [String (Char)] The character
+  # @return [true, false] If the character is valid
+  def isIdentChar?(c)
+    LOWER_A_TO_Z === c || UPPER_A_TO_Z === c || "'" == c
+  end
+
+  # Checks to see if the character is numeric (including the decimal point)
+  #
+  # @param c [String (Char)] The character
+  # @return [true, false] If the character is valid
+  def isNumericChar?(c)
+    ZERO_TO_NINE === c || "." == c
+  end
+
+  # Checks if the two characters in sequence are the same and form a token by
+  # itself. Short hand for `continuousConsume(idSingle, {current_char => idDouble})`.
+  #
+  # @param idSingle [Symbol] If the first character itself is an individual token
+  # @param idDouble [Symbol] If both characters are interpreted as a token
+  # @return [Calcula::Token] The token with either `idSingle` or `idDouble` as type
+  def potentialDuplicateToken(idSingle, idDouble)
+    previous = @src[@i]
+    continuousConsume(idSingle, {previous => idDouble})
+  end
+
+  # Checks if the consecutive character forms another token
+  #
+  # @param idSingle [Symbol] The token type for the first character alone
+  # @param continuousTok [Hash{String (Char) => Symbol}] The consecutive character
+  # @return [Calcula::Token] The token found
+  def continuousConsume(idSingle, continuousTok)
+    advancePos(buf = @src[@i])
+    if (maybeId = continuousTok[@src[@i]]) == nil then
+      maybeId = idSingle
+    else
+      buf += @src[@i]
+      advancePos(@src[@i])
     end
+    return Calcula::Token.new(maybeId, buf)
   end
 end