latex-to-unicode 0.1.1

data/lib/latex-to-unicode.rb

@@ -0,0 +1,20 @@
+require 'treetop'
+require File.dirname(__FILE__) + '/data.rb'
+require File.dirname(__FILE__) + '/latex_grammar.rb'
+
+module LatexToUnicode
+  def self.preprocess(str)
+    str = str.gsub(/\s/, '')
+    str = translate(str, ALIASES)
+    str = translate(str, WHITESPACE)
+    str = translate(str, SYMBOLS)
+  end
+  def self.convert(str)
+    m = LatexParser.new.parse(preprocess(str))
+    if m
+      m.value
+    else
+      raise ArgumentError, "Parsing failed."
+    end
+  end
+end

data/lib/latex_grammar.rb

@@ -0,0 +1,815 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require File.dirname(__FILE__) + '/data.rb'
+require File.dirname(__FILE__) + '/translate.rb'
+
+module LatexToUnicode
+  module Latex
+    include Treetop::Runtime
+
+    def root
+      @root ||= :expression
+    end
+
+    module Expression0
+      def value
+        elements.map {|x| x.value }.join
+      end
+    end
+
+    def _nt_expression
+      start_index = index
+      if node_cache[:expression].has_key?(index)
+        cached = node_cache[:expression][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        i1 = index
+        r2 = _nt_frac
+        if r2
+          r1 = r2
+        else
+          r3 = _nt_sqrt
+          if r3
+            r1 = r3
+          else
+            r4 = _nt_combining
+            if r4
+              r1 = r4
+            else
+              r5 = _nt_unary
+              if r5
+                r1 = r5
+              else
+                r6 = _nt_grouped
+                if r6
+                  r1 = r6
+                else
+                  r7 = _nt_atom
+                  if r7
+                    r1 = r7
+                  else
+                    @index = i1
+                    r1 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Expression0)
+
+      node_cache[:expression][start_index] = r0
+
+      r0
+    end
+
+    module Frac0
+      def n
+        elements[1]
+      end
+
+      def d
+        elements[2]
+      end
+    end
+
+    module Frac1
+      def value
+        LatexToUnicode::translate_fraction(n.value, d.value)
+      end
+    end
+
+    def _nt_frac
+      start_index = index
+      if node_cache[:frac].has_key?(index)
+        cached = node_cache[:frac][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('\frac', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
+        @index += 5
+      else
+        terminal_parse_failure('\frac')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        r2 = _nt_element
+        s0 << r2
+        if r2
+          r3 = _nt_element
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Frac0)
+        r0.extend(Frac1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:frac][start_index] = r0
+
+      r0
+    end
+
+    module Sqrt0
+      def atom
+        elements[1]
+      end
+    end
+
+    module Sqrt1
+      def n
+        elements[1]
+      end
+
+      def element
+        elements[3]
+      end
+    end
+
+    module Sqrt2
+      def value
+        LatexToUnicode::translate_sqrt(element.value, n.text_value)
+      end
+    end
+
+    module Sqrt3
+      def element
+        elements[1]
+      end
+    end
+
+    module Sqrt4
+      def value
+        LatexToUnicode::translate_sqrt(element.value, 2)
+      end
+    end
+
+    def _nt_sqrt
+      start_index = index
+      if node_cache[:sqrt].has_key?(index)
+        cached = node_cache[:sqrt][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      i1, s1 = index, []
+      if has_terminal?('\sqrt[', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
+        @index += 6
+      else
+        terminal_parse_failure('\sqrt[')
+        r2 = nil
+      end
+      s1 << r2
+      if r2
+        s3, i3 = [], index
+        loop do
+          i4, s4 = index, []
+          i5 = index
+          if has_terminal?(']', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(']')
+            r6 = nil
+          end
+          if r6
+            r5 = nil
+          else
+            @index = i5
+            r5 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s4 << r5
+          if r5
+            r7 = _nt_atom
+            s4 << r7
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(Sqrt0)
+          else
+            @index = i4
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        if s3.empty?
+          @index = i3
+          r3 = nil
+        else
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        end
+        s1 << r3
+        if r3
+          if has_terminal?(']', false, index)
+            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(']')
+            r8 = nil
+          end
+          s1 << r8
+          if r8
+            r9 = _nt_element
+            s1 << r9
+          end
+        end
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(Sqrt1)
+        r1.extend(Sqrt2)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        i10, s10 = index, []
+        if has_terminal?('\sqrt', false, index)
+          r11 = instantiate_node(SyntaxNode,input, index...(index + 5))
+          @index += 5
+        else
+          terminal_parse_failure('\sqrt')
+          r11 = nil
+        end
+        s10 << r11
+        if r11
+          r12 = _nt_element
+          s10 << r12
+        end
+        if s10.last
+          r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+          r10.extend(Sqrt3)
+          r10.extend(Sqrt4)
+        else
+          @index = i10
+          r10 = nil
+        end
+        if r10
+          r0 = r10
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+
+      node_cache[:sqrt][start_index] = r0
+
+      r0
+    end
+
+    module Combining0
+      def combining_command
+        elements[0]
+      end
+
+      def element
+        elements[1]
+      end
+    end
+
+    module Combining1
+      def value
+        LatexToUnicode::translate_combining(element.value, 
+          combining_command.text_value[1..-1].to_sym)
+      end
+    end
+
+    def _nt_combining
+      start_index = index
+      if node_cache[:combining].has_key?(index)
+        cached = node_cache[:combining][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_combining_command
+      s0 << r1
+      if r1
+        r2 = _nt_element
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Combining0)
+        r0.extend(Combining1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:combining][start_index] = r0
+
+      r0
+    end
+
+    def _nt_combining_command
+      start_index = index
+      if node_cache[:combining_command].has_key?(index)
+        cached = node_cache[:combining_command][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      if has_terminal?('\hat', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
+        @index += 4
+      else
+        terminal_parse_failure('\hat')
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        if has_terminal?('\breve', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
+          @index += 6
+        else
+          terminal_parse_failure('\breve')
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          if has_terminal?('\grave', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 6))
+            @index += 6
+          else
+            terminal_parse_failure('\grave')
+            r3 = nil
+          end
+          if r3
+            r0 = r3
+          else
+            if has_terminal?('\bar', false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
+              @index += 4
+            else
+              terminal_parse_failure('\bar')
+              r4 = nil
+            end
+            if r4
+              r0 = r4
+            else
+              if has_terminal?('\check', false, index)
+                r5 = instantiate_node(SyntaxNode,input, index...(index + 6))
+                @index += 6
+              else
+                terminal_parse_failure('\check')
+                r5 = nil
+              end
+              if r5
+                r0 = r5
+              else
+                if has_terminal?('\acute', false, index)
+                  r6 = instantiate_node(SyntaxNode,input, index...(index + 6))
+                  @index += 6
+                else
+                  terminal_parse_failure('\acute')
+                  r6 = nil
+                end
+                if r6
+                  r0 = r6
+                else
+                  if has_terminal?('\tilde', false, index)
+                    r7 = instantiate_node(SyntaxNode,input, index...(index + 6))
+                    @index += 6
+                  else
+                    terminal_parse_failure('\tilde')
+                    r7 = nil
+                  end
+                  if r7
+                    r0 = r7
+                  else
+                    if has_terminal?('\vec', false, index)
+                      r8 = instantiate_node(SyntaxNode,input, index...(index + 4))
+                      @index += 4
+                    else
+                      terminal_parse_failure('\vec')
+                      r8 = nil
+                    end
+                    if r8
+                      r0 = r8
+                    else
+                      if has_terminal?('\dot', false, index)
+                        r9 = instantiate_node(SyntaxNode,input, index...(index + 4))
+                        @index += 4
+                      else
+                        terminal_parse_failure('\dot')
+                        r9 = nil
+                      end
+                      if r9
+                        r0 = r9
+                      else
+                        if has_terminal?('\ddot', false, index)
+                          r10 = instantiate_node(SyntaxNode,input, index...(index + 5))
+                          @index += 5
+                        else
+                          terminal_parse_failure('\ddot')
+                          r10 = nil
+                        end
+                        if r10
+                          r0 = r10
+                        else
+                          if has_terminal?('\mathring', false, index)
+                            r11 = instantiate_node(SyntaxNode,input, index...(index + 9))
+                            @index += 9
+                          else
+                            terminal_parse_failure('\mathring')
+                            r11 = nil
+                          end
+                          if r11
+                            r0 = r11
+                          else
+                            @index = i0
+                            r0 = nil
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      node_cache[:combining_command][start_index] = r0
+
+      r0
+    end
+
+    module Unary0
+      def unary_command
+        elements[0]
+      end
+
+      def element
+        elements[1]
+      end
+    end
+
+    module Unary1
+      def value
+        set = case (cmd = unary_command.text_value)
+              when '_'   then LatexToUnicode::SUBSCRIPTS
+              when '^'   then LatexToUnicode::SUPERSCRIPTS
+              else
+                LatexToUnicode.const_get cmd[1..-1].upcase
+              end
+        LatexToUnicode::translate(element.value, set)
+      end
+    end
+
+    def _nt_unary
+      start_index = index
+      if node_cache[:unary].has_key?(index)
+        cached = node_cache[:unary][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_unary_command
+      s0 << r1
+      if r1
+        r2 = _nt_element
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Unary0)
+        r0.extend(Unary1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:unary][start_index] = r0
+
+      r0
+    end
+
+    def _nt_unary_command
+      start_index = index
+      if node_cache[:unary_command].has_key?(index)
+        cached = node_cache[:unary_command][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      if has_terminal?('^', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('^')
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        if has_terminal?('_', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('_')
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          if has_terminal?('\bb', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 3))
+            @index += 3
+          else
+            terminal_parse_failure('\bb')
+            r3 = nil
+          end
+          if r3
+            r0 = r3
+          else
+            if has_terminal?('\bf', false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 3))
+              @index += 3
+            else
+              terminal_parse_failure('\bf')
+              r4 = nil
+            end
+            if r4
+              r0 = r4
+            else
+              if has_terminal?('\cal', false, index)
+                r5 = instantiate_node(SyntaxNode,input, index...(index + 4))
+                @index += 4
+              else
+                terminal_parse_failure('\cal')
+                r5 = nil
+              end
+              if r5
+                r0 = r5
+              else
+                if has_terminal?('\frak', false, index)
+                  r6 = instantiate_node(SyntaxNode,input, index...(index + 5))
+                  @index += 5
+                else
+                  terminal_parse_failure('\frak')
+                  r6 = nil
+                end
+                if r6
+                  r0 = r6
+                else
+                  if has_terminal?('\it', false, index)
+                    r7 = instantiate_node(SyntaxNode,input, index...(index + 3))
+                    @index += 3
+                  else
+                    terminal_parse_failure('\it')
+                    r7 = nil
+                  end
+                  if r7
+                    r0 = r7
+                  else
+                    if has_terminal?('\mono', false, index)
+                      r8 = instantiate_node(SyntaxNode,input, index...(index + 5))
+                      @index += 5
+                    else
+                      terminal_parse_failure('\mono')
+                      r8 = nil
+                    end
+                    if r8
+                      r0 = r8
+                    else
+                      @index = i0
+                      r0 = nil
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      node_cache[:unary_command][start_index] = r0
+
+      r0
+    end
+
+    def _nt_element
+      start_index = index
+      if node_cache[:element].has_key?(index)
+        cached = node_cache[:element][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_grouped
+      if r1
+        r0 = r1
+      else
+        r2 = _nt_atom
+        if r2
+          r0 = r2
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+
+      node_cache[:element][start_index] = r0
+
+      r0
+    end
+
+    module Grouped0
+      def expression
+        elements[1]
+      end
+
+    end
+
+    module Grouped1
+      def value
+        expression.value
+      end
+    end
+
+    def _nt_grouped
+      start_index = index
+      if node_cache[:grouped].has_key?(index)
+        cached = node_cache[:grouped][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('{', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        terminal_parse_failure('{')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        r2 = _nt_expression
+        s0 << r2
+        if r2
+          if has_terminal?('}', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('}')
+            r3 = nil
+          end
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Grouped0)
+        r0.extend(Grouped1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:grouped][start_index] = r0
+
+      r0
+    end
+
+    module Atoms0
+      def value
+        text_value
+      end
+    end
+
+    def _nt_atoms
+      start_index = index
+      if node_cache[:atoms].has_key?(index)
+        cached = node_cache[:atoms][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        r1 = _nt_atom
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Atoms0)
+      end
+
+      node_cache[:atoms][start_index] = r0
+
+      r0
+    end
+
+    module Atom0
+      def value
+        text_value
+      end
+    end
+
+    def _nt_atom
+      start_index = index
+      if node_cache[:atom].has_key?(index)
+        cached = node_cache[:atom][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      if has_terminal?('\G[^{}\\^_]', true, index)
+        r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r0.extend(Atom0)
+        @index += 1
+      else
+        r0 = nil
+      end
+
+      node_cache[:atom][start_index] = r0
+
+      r0
+    end
+
+  end
+
+  class LatexParser < Treetop::Runtime::CompiledParser
+    include Latex
+  end
+
+end