qlang 0.0.27180000 → 0.0.27182000

data/lib/qlang/lexer/tokens.rb

@@ -1,45 +1,78 @@
 module Qlang
   module Lexer
     module Tokens
-      # FIRST TOKEN
-      NUM = '[0-9]+'
-      VAR = '[a-z]'
-      FUNCV = '[a-zA-Z]'
-      VARNUM = '[0-9a-z]'
+      # NUM
+      INT = /[0-9]+/
+      FLO = /[0-9]+\.[0-9]+/
+      E = /e/
+      PI = /pi/
+      NUM = /(#{FLO}|#{INT}|#{E}|#{PI})/
+
+      # FUNCTION
+      EMBEDDED_FUNC = /(sin|cos|tan|log)/
+      USER_FUNC = /[a-zA-Z]/
+      FUNCV = /(#{EMBEDDED_FUNC}|#{USER_FUNC})/
+
+      # VARIABLE
+      VAR = /([a-d]|[f-z])/
+      #VAR_MUL2 = /(?!pi)#{VAR}{2}/
+      # #VAR_MUL3 = /(?!#{EMBEDDED_FUNC})#{VAR}{3}/
+      # # FIX:
+      #VAR_MUL  = /(?!#{EMBEDDED_FUNC})#{VAR_MUL2}/
+
+      # # TERM
+      # TERM = /(#{NUM}|#{VAR_MUL}|#{VAR_MUL})/
+
+
+      # OPE
+      PLS = /\+/
+      SUB = /-/
+      MUL = /\*/
+      DIV = /\//
+      EXP = /(\*\*|\^)/
+      OPE = /(#{PLS}|#{SUB}|#{MUL}|#{DIV}|#{EXP})/
+
+      VARNUM = /(#{NUM}|#{VAR})/
       ANYSP = ' *'
-      ANYSTR = '.+'
-      NONL = '[^\r\n]'
-      LPRN = '\('
-      RPRN = '\)'
-      LBRC = '\{'
-      RBRC = '\}'
-      CLN = '\:'
-      SCLN = ';'
-      CMA = '\,'
-      SP = ' '
-
-      # SECOND TOKEN
-      class ::String
-        def line_by(char)
-          "#{ANYSP}#{self}(#{ANYSP}#{char}#{ANYSP}#{self})*#{ANYSP}"
+      ANYSTR = /.+/
+      NONL = /[^\r\n]/
+
+      LPRN = /\(/
+      RPRN = /\)/
+      PRN = /(#{LPRN}|#{RPRN})/
+
+      LBRC = /\{/
+      RBRC = /\}/
+      BRC = /(#{LBRC}|#{RBRC})/
+
+      CLN = /\:/
+      SCLN = /;/
+      CMA = /\,/
+      SP = / /
+
+      # TODO: what is better
+      class Util
+        def self.string_out(str, partition)
+        /#{ANYSP}#{str}(#{ANYSP}#{partition}#{ANYSP}#{str})*#{ANYSP}/
         end
-      end
-      NUMS_BY_CMA = NUM.line_by(CMA)
-      VARS_BY_CMA = VAR.line_by(CMA)
-      VARNUMS_BY_CMA = VARNUM.line_by(CMA)
-      NUMS_BY_SP = NUM.line_by(SP)
-
-      # THIRD TOKEN
-      class ::String
-        def func_call
-          "#{FUNCV}#{LPRN}#{ANYSP}#{self}#{ANYSP}#{RPRN}"
+
+        def self.func_call(args)
+          /#{FUNCV}#{LPRN}#{ANYSP}#{args}#{ANYSP}#{RPRN}/
         end
       end
-      FUNCCN =  NUMS_BY_CMA.func_call
-      FUNCCV = VARS_BY_CMA.func_call
-      FUNCCVN =  VARNUMS_BY_CMA.func_call
 
-      NUMS_BY_SP_BY_SCLN = NUMS_BY_SP.line_by(SCLN)
+      NUMS_BY_CMA = Util.string_out(NUM, CMA)
+      VARS_BY_CMA = Util.string_out(VAR, CMA)
+      VARNUMS_BY_CMA = Util.string_out(VARNUM, CMA)
+      NUMS_BY_SP = Util.string_out(NUM, SP)
+
+      FUNCCN =  Util.func_call(NUMS_BY_CMA)
+      FUNCCV = Util.func_call(VARS_BY_CMA)
+      FUNCCVN =  Util.func_call(VARNUMS_BY_CMA)
+
+      NUMS_BY_SP_BY_SCLN = Util.string_out(NUMS_BY_SP, SCLN)
+
+      FORMULA = /(#{OPE}|#{FUNCV}|#{VAR}|#{NUM}|#{PRN}|#{ANYSP})+/
     end
   end
 end

data/lib/qlang/lexer/wrap_lexer.rb

@@ -1,14 +1,13 @@
-require 'pry'
 module Qlang
   module Lexer
     class WrapLexer < Base
-      rule(%r@#{FUNCCV}#{ANYSP}=#{ANYSP}#{NONL}+@) { :def_func }
-      rule(%r@#{FUNCCN}@) { :eval_func }
+      rule(/#{FUNCCV}#{ANYSP}=#{ANYSP}#{FORMULA}+/) { :def_func }
+      rule(/#{FUNCCN}/) { :eval_func }
       rule(/S#{ANYSP}#{LPRN}#{ANYSTR}#{RPRN}\[#{ANYSTR}\]/) { :integral }
-      rule(/d\/d#{VAR} .*/) { :differential }
-      rule(%r@#{LPRN}#{NUMS_BY_SP}#{RPRN}@) { :vector }
-      rule(%r@#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}t@) { :tmatrix }
-      rule(%r@#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}@) { :matrix }
+      rule(/d\/d#{VAR} #{FORMULA}/) { :differential }
+      rule(/#{LPRN}#{NUMS_BY_SP}#{RPRN}/) { :vector }
+      rule(/#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}t/) { :tmatrix }
+      rule(/#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}/) { :matrix }
 
 
       rule(/\(/) { :LPRN }

data/lib/qlang/parser.rb

@@ -13,6 +13,9 @@ require 'qlang/parser/formula_parser'
 
 module Qlang
   module Parser
+    include Lexer::Tokens
+    SYM = '\w+'
+    ONEHASH = "#{ANYSP}#{SYM}#{CLN}#{ANYSP}#{VARNUM}#{ANYSP}" # sdf: 234
     def execute(lexed)
       time = Time.now
       until lexed.token_str =~ /\A(:NLIN\d|:R\d)+\z/
@@ -36,50 +39,64 @@ module Qlang
           when :def_func
             FuncParser.execute(token_val)
           end
-          lexed.parsed!(token_position, parsed)
+          lexed.parsed!(parsed, token_position)
 
-        when /:LPRN\d(:CONT\d):RPRN\d/
-          cont_token_with_num = $1
-          cont_lexed = Lexer::ContLexer.new(lexed.get_value(cont_token_with_num))
+        when /:LPRN(\d):CONT\d:RPRN(\d)/
+          tokens_range = $1.to_i..$2.to_i
+          token_val = lexed.lexeds[tokens_range.to_a[1]][:CONT]
 
-          cont = "(#{cont_lexed.values.join(' ')})"
-          lexed.squash_with_prn(cont_token_with_num, cont)
+          cont_lexed = Lexer::ContLexer.new(token_val)
+          cont = cont_lexed.values.join(' ')
+          lexed.parsed!(cont.parentheses, tokens_range)
 
-        when /:LBRC\d(:CONT\d):RBRC\d/
-          cont_token_with_num = $1
-          cont_lexed = Lexer::ContLexer.new(lexed.get_value(cont_token_with_num))
+        when /:LBRC(\d):CONT\d:RBRC(\d)/
+          tokens_range = $1.to_i..$2.to_i
+          token_val = lexed.lexeds[tokens_range.to_a[1]][:CONT]
 
-          case cont_lexed.token_str
-          when /(:SYM\d:CLN\d(:STR\d|:NUM\d|:R\d):CMA)*(:SYM\d:CLN\d(:STR\d|:NUM\d|:R\d))/
-            cont = ListParser.execute(cont_lexed)
-          else
-            cont = "{#{cont_lexed.values.join(' ')}}"
-          end
-          lexed.squash_with_prn(cont_token_with_num, cont)
+          cont = case token_val
+            when %r@#{ONEHASH}(#{CMA}#{ONEHASH})*@
+              ListParser.execute(token_val)
+            else
+              token_val
+            end
+
+          lexed.parsed!(cont, tokens_range)
 
-        when /:eval_func\d/
-          cont_token_with_num = $&
-          cont = lexed.get_value(cont_token_with_num)
-          lexed.squash_with_prn(cont_token_with_num, cont)
+        when /:eval_func(\d)/
+          token_val = lexed.get_value($1)
+          lexed.parsed!(token_val.parentheses, $1)
 
-        when /:differential\d/
-          cont_token_with_num = $&
-          cont = lexed.get_value(cont_token_with_num)
+        when /:differential(\d)/
+          token_position = $1.to_i
+          cont = lexed.get_value(token_position)
           cont =~ /(d\/d[a-zA-Z]) (.*)/
           cont = "#{$1}(#{FormulaParser.execute($2)})"
           # FIX: Refactor
           #cont.gsub!(/(d\/d[a-zA-Z]) (.*)/, "\1(\2)")
-          lexed.squash_with_prn(cont_token_with_num, cont)
-        when /:CONT\d/
-          lexed.ch_token($&, :R)
+          lexed.parsed!(cont.parentheses, token_position)
+        when /:CONT(\d)/
+          lexed.parsed!(lexed.get_value($1), $1)
         end
-
-        lexed.squash_to_cont($1, 2) if lexed.token_str =~ /(:CONT\d|:R\d)(:CONT\d|:R\d)/
+        lexed.squash!(($1.to_i)..($1.to_i+1)) if lexed.token_str =~ /(?::CONT|:R)(\d)(?::CONT|:R)(\d)/
       end
 
-      lexed.fix_r_txt!
-      lexed.values.join
+      LangEqualizer.execute(
+        lexed.values.join
+      )
     end
     module_function :execute
+
+    # FIXIT
+    class LangEqualizer
+      def self.execute(str)
+        case $meta_info.lang
+        when :ruby
+          str.gsub(/\^/, '**')
+        else
+          str
+        end
+      end
+    end
+
   end
 end

data/lib/qlang/parser/formula_parser.rb

@@ -10,7 +10,7 @@ module Qlang
             if ss.scan(rgx)
               item = case token
               when :EXP
-                $type == :Ruby ? '**' : '^'
+                $meta_info.lang == :ruby ? '**' : '^'
               when :MUL
                 sss = StringScanner.new(ss[0])
                 ary = []

data/lib/qlang/parser/func_parser.rb

@@ -6,7 +6,7 @@ module Qlang
       include Lexer::Tokens
       def execute(string)
         def_func, formula = string.split(/ *= */)
-        def_func =~ %r@(#{FUNCV})#{LPRN}#{ANYSP}(#{VARS_BY_CMA})#{ANYSP}#{RPRN}@
+        def_func =~ /(#{USER_FUNC})#{LPRN}#{ANYSP}(#{VARS_BY_CMA})#{ANYSP}#{RPRN}/
         FuncApi.execute($1, $2.split(' *,'), FormulaParser.execute(formula))
       end
       module_function :execute

data/lib/qlang/parser/list_parser.rb

@@ -3,8 +3,7 @@ module Qlang
     module ListParser
       include Base
       def execute(lexed)
-        lexed.fix_r_txt!
-        arys = lexed.split(',').map { |ary| [ary[0], ary[2]] }
+        arys = lexed.split(/ *, */).map { |e| e.split(/ *: */).map{|e2|e2.delete(' ')} }
         ListApi.execute(arys)
       end
       module_function :execute

data/lib/qlang/utils/langs.yml

@@ -0,0 +1,7 @@
+langs:
+  r: R
+  ruby: Ruby
+  python: Pyhton
+  haskell: Haskell
+  scala: Scala
+  js: Javascript

data/lib/qlang/utils/ruby_ext.rb

@@ -0,0 +1,46 @@
+class ::String
+  def parentheses
+    "(#{self})"
+  end
+
+  def braces
+    "{#{self}}"
+  end
+
+  def rm(str_or_rgx)
+    gsub(str_or_rgx, '')
+  end
+
+  def rm!(str_or_rgx)
+    gsub!(str_or_rgx, '')
+    self
+  end
+
+  def rms!(*str_or_rgxs)
+    str_or_rgxs.each do |str_or_rgx|
+      rm!(str_or_rgx)
+    end
+    self
+  end
+
+  def split_by_sp
+    split(/ +/)
+  end
+
+  # FIX:
+  def equalize!
+    rms!(/\A +/, / +\z/)
+    if self =~ /\A\(/ && self =~ /\)\z/
+      rms!(/\A\(/, /\)\z/)
+      rms!(/\A +/, / +\z/)
+    else
+      self
+    end
+  end
+end
+
+class ::Array
+  def join_by_sp
+    join(' ')
+  end
+end

data/lib/qlang/version.rb

@@ -1,3 +1,3 @@
 module Qlang
-  VERSION = "0.0.27180000"
+  VERSION = "0.0.27182000"
 end

data/spec/langs/Haskell/ex1_after.hs

@@ -0,0 +1,74 @@
+module Main where
+
+filter' :: (a -> Bool) -> [a] -> [a]
+filter' _ []                 = []
+filter' p (x:xs) | p x       = x : filter' p xs
+                 | otherwise = filter' p xs
+
+
+-- pattern match for Algebraic data type
+data Node = Leaf Integer | Branch Node Node deriving (Show)
+
+depth :: Node -> Integer
+depth node = case node of
+  Leaf _     -> 1
+  Branch a b -> 1 + max (depth a) (depth b)
+
+sumLeaf :: Node -> Integer
+sumLeaf node = case node of
+  Leaf x     -> x
+  Branch a b -> (sumLeaf a) + (sumLeaf b)
+
+-- Maybe monado
+
+--data Maybee a = Justt a | Nothingg deriving (Show)
+
+--return :: a -> Maybee a
+--return a = Maybee a
+
+--(>>=) :: Maybee a -> (a -> Maybee b) -> Maybee b
+--Nothingg >>= _  = Nothingg
+--Justt a >>=  f = f a
+
+add1 :: Maybe Int -> Maybe Int -> Maybe Int
+add1 mx my =
+  case mx of
+    Nothing -> Nothing
+    Just x  -> case my of
+                 Nothing -> Nothing
+                 Just y  -> Just (x + y)
+
+add2 :: Maybe Int -> Maybe Int -> Maybe Int
+add2 mx my =
+  mx >>= (\x ->
+    my >>= (\y ->
+      return (x + y)))
+
+add3 :: Maybe Int -> Maybe Int -> Maybe Int
+add3 mx my = do
+  x <- mx
+  y <- my
+  return (x + y)
+
+
+putResult x = putStrLn $ show x
+
+
+main = do putResult $ filter' (> 2) [1..10]
+
+          let tree = Branch (Leaf 3) (Branch (Leaf 2) (Leaf 4))
+          putResult $ depth tree
+          putResult $ sumLeaf tree
+
+          putResult $ (Just 1) `add1` Nothing
+          putResult $ Nothing `add1` (Just 3)
+          putResult $ (Just 1) `add1` (Just 3)
+          putResult $ Nothing `add1` Nothing
+          putResult $ (Just 1) `add2` Nothing
+          putResult $  Nothing `add2` (Just 3)
+          putResult $ (Just 1) `add2` (Just 3)
+          putResult $ Nothing `add2` Nothing
+          putResult $ (Just 1) `add3` Nothing
+          putResult $ Nothing `add3` (Just 3)
+          putResult $ (Just 1) `add3` (Just 3)
+          putResult $ Nothing `add3` Nothing

data/spec/langs/Haskell/ex1_before.hs

@@ -0,0 +1,74 @@
+module Main where
+
+filter' :: (a -> Bool) -> [a] -> [a]
+filter' _ []                 = []
+filter' p (x:xs) | p x       = x : filter' p xs
+                 | otherwise = filter' p xs
+
+
+-- pattern match for Algebraic data type
+data Node = Leaf Integer | Branch Node Node deriving (Show)
+
+depth :: Node -> Integer
+depth node = case node of
+  Leaf _     -> 1
+  Branch a b -> 1 + max (depth a) (depth b)
+
+sumLeaf :: Node -> Integer
+sumLeaf node = case node of
+  Leaf x     -> x
+  Branch a b -> (sumLeaf a) + (sumLeaf b)
+
+-- Maybe monado
+
+--data Maybee a = Justt a | Nothingg deriving (Show)
+
+--return :: a -> Maybee a
+--return a = Maybee a
+
+--(>>=) :: Maybee a -> (a -> Maybee b) -> Maybee b
+--Nothingg >>= _  = Nothingg
+--Justt a >>=  f = f a
+
+add1 :: Maybe Int -> Maybe Int -> Maybe Int
+add1 mx my =
+  case mx of
+    Nothing -> Nothing
+    Just x  -> case my of
+                 Nothing -> Nothing
+                 Just y  -> Just (x + y)
+
+add2 :: Maybe Int -> Maybe Int -> Maybe Int
+add2 mx my =
+  mx >>= (\x ->
+    my >>= (\y ->
+      return (x + y)))
+
+add3 :: Maybe Int -> Maybe Int -> Maybe Int
+add3 mx my = do
+  x <- mx
+  y <- my
+  return (x + y)
+
+
+putResult x = putStrLn $ show x
+
+
+main = do putResult $ filter' (> 2) [1..10]
+
+          let tree = Branch (Leaf 3) (Branch (Leaf 2) (Leaf 4))
+          putResult $ depth tree
+          putResult $ sumLeaf tree
+
+          putResult $ (Just 1) `add1` Nothing
+          putResult $ Nothing `add1` (Just 3)
+          putResult $ (Just 1) `add1` (Just 3)
+          putResult $ Nothing `add1` Nothing
+          putResult $ (Just 1) `add2` Nothing
+          putResult $  Nothing `add2` (Just 3)
+          putResult $ (Just 1) `add2` (Just 3)
+          putResult $ Nothing `add2` Nothing
+          putResult $ (Just 1) `add3` Nothing
+          putResult $ Nothing `add3` (Just 3)
+          putResult $ (Just 1) `add3` (Just 3)
+          putResult $ Nothing `add3` Nothing