glaemscribe 1.1.14 → 1.2.0

data/lib/api/object_additions.rb

@@ -1,7 +1,9 @@
 # From http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-list/43424
 class Object
+=begin
   def deep_clone
     return @deep_cloning_obj if @deep_cloning
+      
     @deep_cloning_obj = clone
     @deep_cloning_obj.instance_variables.each do |var|
       val = @deep_cloning_obj.instance_variable_get(var)
@@ -19,4 +21,24 @@ class Object
     @deep_cloning_obj = nil
     deep_cloning_obj
   end
-end
+=end
+  
+  def deep_clone(cache={})
+    return cache[self] if cache.key?(self)
+
+    copy = clone()
+    cache[self] = copy
+
+    copy.instance_variables.each do |var|
+      val = instance_variable_get(var)
+      begin
+        val = val.deep_clone(cache)
+      rescue TypeError
+        next
+      end
+      copy.instance_variable_set(var, val)
+    end
+
+    return copy
+  end  
+end

data/lib/api/option.rb

@@ -25,24 +25,29 @@ module Glaemscribe
     
     class Option
       attr_reader   :mode
+      attr_reader   :line
       attr_reader   :name
       attr_reader   :type
       attr_reader   :default_value_name      
       attr_reader   :values
+      
+      attr_accessor :is_radio
 
-    
       class Type
         ENUM = "ENUM"
         BOOL = "BOOL"
       end
          
-      def initialize(mode, name, default_value_name, values, visibility = nil)
+      def initialize(mode,  name, default_value_name, values, line, visibility = nil)
         @mode               = mode
         @name               = name
         @default_value_name = default_value_name
         @type               = (values.keys.count == 0)?(Type::BOOL):(Type::ENUM)
         @values             = values
         @visibility         = visibility
+        @line               = line
+        @value_to_names = {}
+        @values.each { |vname, val| @value_to_names[val] = vname }
       end
       
       def default_value
@@ -63,6 +68,16 @@ module Glaemscribe
         end
       end
       
+      def value_name_for_value(value)
+        if @type == Type::BOOL
+          return "true"  if value == true  || value == "true"
+          return "false" if value == false || value == "false"
+          return nil
+        else
+          return @value_to_names[value]
+        end
+      end
+      
       def visible?
         if_eval = Eval::Parser.new()
         

data/lib/api/post_processor/resolve_virtuals.rb

@@ -50,19 +50,35 @@ module Glaemscribe
           # Try to replace
           last_trigger = @last_triggers[c]
           if last_trigger != nil
-            new_tokens[idx] = last_trigger.names.first # Take the first name of the non-virtual replacement.
+            new_tokens[idx] = last_trigger.names.first  # Take the first name of the non-virtual replacement.
+            token           = new_tokens[idx]           # Consider the token replaced, being itself a potential trigger for further virtuals (cascading virtuals)
           end
-        else
-          # Update states of virtual classes
-          charset.virtual_chars.each{|vc|
-            rc                  = vc[token]
-            @last_triggers[vc]  = rc if rc != nil 
-          }
-        end        
+        end
+        
+        # Update states of virtual classes
+        charset.virtual_chars.each{|vc|
+          rc                  = vc[token]
+          @last_triggers[vc]  = rc if rc != nil 
+        }
+      end
+      
+      def apply_sequences(charset,tokens)
+        ret = []
+        tokens.each { |token|
+          c = charset[token]
+          if c && c.sequence?
+            ret += c.sequence
+          else
+            ret << token
+          end
+        }
+        ret
       end
       
       def apply(tokens,charset)
-        
+        # Apply sequence chars
+        tokens = apply_sequences(charset,tokens)
+      
         # Clone the tokens so that we can perform ligatures AND diacritics without interferences
         new_tokens = tokens.clone
         

data/lib/api/resource_manager.rb

@@ -23,6 +23,7 @@ module Glaemscribe
   module API
     module ResourceManager
         
+      # The same structure is kept within the gem
       MODE_PATH     = File.dirname(__FILE__) + "/../../glaemresources/modes/"
       MODE_EXT      = "glaem"
     

data/lib/api/rule_group.rb

@@ -22,35 +22,92 @@
 
 module Glaemscribe
   module API
+    
+    class RuleGroupVar
+      attr_reader :name, :value
+      
+      def initialize(name, value, is_pointer)
+        @name       = name
+        @value      = value
+        @is_pointer = is_pointer
+      end
+      
+      def pointer?
+        is_pointer
+      end
+    end
+    
     class RuleGroup
   
-      VAR_NAME_REGEXP     = /{([0-9A-Z_]+)}/
-      VAR_DECL_REGEXP     = /^\s*{([0-9A-Z_]+)}\s+===\s+(.+?)\s*$/
-      RULE_REGEXP         = /^\s*(.*?)\s+-->\s+(.+?)\s*$/
-      CROSS_RULE_REGEXP   = /^\s*(.*?)\s+-->\s+([\s0-9,]+)\s+-->\s+(.+?)\s*$/
+      VAR_NAME_REGEXP             = /{([0-9A-Z_]+)}/
+      UNICODE_VAR_NAME_REGEXP_IN  = /^UNI_([0-9A-F]+)$/
+      UNICODE_VAR_NAME_REGEXP_OUT = /{UNI_([0-9A-F]+)}/
+      
+      VAR_DECL_REGEXP             = /^\s*{([0-9A-Z_]+)}\s+===\s+(.+?)\s*$/
+      POINTER_VAR_DECL_REGEXP     = /^\s*{([0-9A-Z_]+)}\s+<=>\s+(.+?)\s*$/
+      RULE_REGEXP                 = /^\s*(.*?)\s+-->\s+(.+?)\s*$/
+      
+      CROSS_SCHEMA_REGEXP         = /[0-9]+(\s*,\s*[0-9]+)*/
+      
+      CROSS_RULE_REGEXP           = /^\s*(.*?)\s+-->\s+(#{CROSS_SCHEMA_REGEXP}|#{VAR_NAME_REGEXP}|identity)\s+-->\s+(.+?)\s*$/
   
-      attr_reader :root_code_block, :name, :mode, :in_charset, :rules
+      attr_reader :root_code_block, :name, :mode, :in_charset, :rules, :macros
   
       def initialize(mode,name)
         @name             = name
         @mode             = mode
+        @macros           = {}
         @root_code_block  = IfTree::CodeBlock.new       
       end
   
-      def add_var(var_name, value)
-        @vars[var_name] = value
+      def add_var(var_name, value, is_pointer)
+        @vars[var_name] = RuleGroupVar.new(var_name, value, is_pointer)
       end
-  
+      
       # Replace all vars in expression
-      def apply_vars(line, string)
-        ret = string.gsub(VAR_NAME_REGEXP) { |cap_var|
-          rep = @vars[$1]
-          if !rep
-            @mode.errors << Glaeml::Error.new(line, "In expression: #{string}: failed to evaluate variable: #{cap_var}.") 
+      def apply_vars(line, string, allow_unicode_vars=false)
+        
+        ret               = string
+        stack_depth       = 0
+        had_replacements  = true
+        
+        while had_replacements
+          
+          had_replacements = false
+          ret = ret.gsub(VAR_NAME_REGEXP) { |cap_var|
+            vname = $1
+            v     = @vars[vname]
+            if !v
+              if vname =~ UNICODE_VAR_NAME_REGEXP_IN
+                # A unicode variable.
+                if allow_unicode_vars
+                  # Just keep this variable intact, it will be replaced at the last moment of the parsing
+                  rep = cap_var
+                else
+                  @mode.errors << Glaeml::Error.new(line, "In expression: #{string}: making wrong use of unicode variable: #{cap_var}. Unicode vars can only be used in source members of a rule or in the definition of another variable.") 
+                  return nil
+                end
+              else
+                @mode.errors << Glaeml::Error.new(line, "In expression: #{string}: failed to evaluate variable: #{cap_var}.") 
+                return nil
+              end
+            else
+              rep = v.value
+              # Only count replacements on non unicode vars
+              had_replacements = true
+            end
+            rep
+          }
+          stack_depth += 1
+                           
+          break if !had_replacements
+          
+          if stack_depth > 16
+            @mode.errors << Glaeml::Error.new(line, "In expression: #{string}: evaluation stack overflow.") 
             return nil
           end
-          rep
-        }
+        end
+                
         ret
       end
       
@@ -60,6 +117,58 @@ module Glaemscribe
             term.code_lines.each{ |cl|
               finalize_code_line(cl) 
             } 
+          elsif(term.is_macro_deploy?)
+                      
+            # Ok this is a bit dirty but I don't want to rewrite the error managamenet
+            # So add an error and if it's still the last (meaning there were no error) one remove it
+            possible_error = Glaeml::Error.new(term.line, ">> Macro backtrace : #{term.macro.name}")
+            @mode.errors << possible_error
+            
+            # First, test if variable is pushable
+            arg_values = []
+            term.macro.arg_names.each_with_index { |arg_name, i|
+              
+              var_value = nil
+              
+              if @vars[arg_name]
+                @mode.errors << Glaeml::Error.new(term.line, "Local variable #{arg_name} hinders a variable with the same name in this context. Use only local variable names in macros!")
+              else
+                # Evaluate local var
+                var_value_ex  = term.arg_value_expressions[i]
+                var_value     = apply_vars(term.line, var_value_ex, true)      
+                
+                if !var_value
+                  @mode.errors << Glaeml::Error.new(term.line, "Thus, variable {#{var_name}} could not be declared.")
+                end              
+              end
+            
+              arg_values << {name: arg_name, val: var_value}
+            }
+            
+            # We push local vars after the whole loop to avoid interferences between them when evaluating them
+            arg_values.each { |v| 
+              if v[:val]
+                add_var(v[:name],v[:val],false)
+              end
+            }
+        
+            descend_if_tree(term.macro.root_code_block, trans_options)
+            
+            # Remove the local vars from the scope (only if they were leggit)
+            arg_values.each { |v| 
+              if v[:val]
+                @vars[v[:name]] = nil
+              end
+            }
+                      
+            if mode.errors.last == possible_error
+              # Remove the error scope if there were no errors
+              mode.errors.pop
+            else
+              # Add another one to close the context
+              @mode.errors << Glaeml::Error.new(term.line, "<< Macro backtrace : #{term.macro.name}")
+            end
+                        
           else
             term.if_conds.each{ |if_cond|
               
@@ -81,8 +190,8 @@ module Glaemscribe
             
       def finalize_rule(line, match_exp, replacement_exp, cross_schema = nil)
         
-        match                 = apply_vars(line, match_exp)
-        replacement           = apply_vars(line, replacement_exp)
+        match                 = apply_vars(line, match_exp, true)
+        replacement           = apply_vars(line, replacement_exp, false)
         
         return if !match || !replacement # Failed
               
@@ -102,20 +211,42 @@ module Glaemscribe
 
             var_name      = $1
             var_value_ex  = $2
-            var_value     = apply_vars(code_line.line, var_value_ex)
+            var_value     = apply_vars(code_line.line, var_value_ex, true)
         
             if !var_value
               @mode.errors << Glaeml::Error.new(code_line.line, "Thus, variable {#{var_name}} could not be declared.")
               return
             end
         
-            add_var(var_name,var_value)
+            add_var(var_name, var_value, false)
  
+          elsif code_line.expression =~ POINTER_VAR_DECL_REGEXP
+            
+            var_name      = $1
+            var_value_ex  = $2
+       
+            add_var(var_name, var_value_ex, true)
+            
           elsif code_line.expression =~ CROSS_RULE_REGEXP
         
             match         = $1
             cross         = $2
-            replacement   = $3      
+            var_name      = $4
+            replacement   = $5      
+            
+            if var_name
+              # This was a variable declaration           
+              var_value = apply_vars(code_line.line, cross, false)
+              if !var_value
+                @mode.errors << Glaeml::Error.new(code_line.line, "Thus, variable {#{var_name}} could not be declared.")
+                return
+              end
+              cross = var_value
+            end
+            
+            if cross == "identity"
+              cross = nil              
+            end
       
             finalize_rule(code_line.line, match, replacement, cross)
       
@@ -139,11 +270,24 @@ module Glaemscribe
         @in_charset       = {}
         @rules            = []
         
-        add_var("NULL","")
+        add_var("NULL","",false)
   
-        add_var("UNDERSCORE", SPECIAL_CHAR_UNDERSCORE)
-        add_var("NBSP",       SPECIAL_CHAR_NBSP)
-        
+        # Characters that are not easily entered or visible in a text editor
+        add_var("NBSP",           "{UNI_A0}",   false)
+        add_var("WJ",             "{UNI_2060}", false)
+        add_var("ZWSP",           "{UNI_200B}", false)
+        add_var("ZWNJ",           "{UNI_200C}", false)        
+
+        # The following characters are used by the mode syntax.
+        # Redefine some convenient tools.
+        add_var("UNDERSCORE",     "{UNI_5F}",  false)
+        add_var("ASTERISK",       "{UNI_2A}",  false)
+        add_var("COMMA",          "{UNI_2C}",  false)
+        add_var("LPAREN",         "{UNI_28}",  false)
+        add_var("RPAREN",         "{UNI_29}",  false)
+        add_var("LBRACKET",       "{UNI_5B}",  false)
+        add_var("RBRACKET",       "{UNI_5D}",  false)
+       
         descend_if_tree(@root_code_block, trans_options)
                             
         # Now that we have selected our rules, create the in_charset of the rule_group 
@@ -151,8 +295,8 @@ module Glaemscribe
           r.sub_rules.each { |sr|
             sr.src_combination.join("").split(//).each{ |inchar|
               # Add the character to the map of input characters
-              # Ignore '_' (bounds of word) and '|' (word breaker)
-              @in_charset[inchar] = self if inchar != WORD_BREAKER && inchar != WORD_BOUNDARY
+              # Ignore '\u0000' (bounds of word) and '|' (word breaker)
+              @in_charset[inchar] = self if inchar != WORD_BREAKER && inchar != WORD_BOUNDARY_TREE
             }
           }
         }

data/lib/api/sheaf_chain_iterator.rb

@@ -108,7 +108,7 @@ module Glaemscribe
         return false
       end
   
-      # Calculate all cominations for the chain
+      # Calculate all cominations for the chain, for the current iterator value
       def combinations
         resolved = []
         @iterators.each_with_index{ |counter, index|

data/lib/api/transcription_processor.rb

@@ -43,8 +43,8 @@ module Glaemscribe
         @transcription_tree = TranscriptionTreeNode.new(nil,nil)
         
         # Add WORD_BOUNDARY and WORD_BREAKER in the tree
-        @transcription_tree.add_subpath(WORD_BOUNDARY,  [""])
-        @transcription_tree.add_subpath(WORD_BREAKER,   [""])
+        @transcription_tree.add_subpath(WORD_BOUNDARY_TREE,   [""])
+        @transcription_tree.add_subpath(WORD_BREAKER,         [""])
         
         rule_groups.each{ |rgname, rg| 
           rg.finalize(trans_options) 
@@ -110,7 +110,7 @@ module Glaemscribe
       
       def transcribe_word(word)
         res = []
-        word = WORD_BOUNDARY + word + WORD_BOUNDARY
+        word = WORD_BOUNDARY_TREE + word + WORD_BOUNDARY_TREE
         while word.length != 0
           r, len = @transcription_tree.transcribe(word)       
           word = word[len..-1]

data/lib/api/tts.rb

@@ -0,0 +1,51 @@
+module Glaemscribe
+  module API
+    
+    class TTS
+  
+      TTS_ENGINE_PATH     = File.dirname(__FILE__) + "/../../lib_espeak/espeakng.for.glaemscribe.nowasm.sync.js"
+      TTS_MODULE_PATH     = File.dirname(__FILE__) + "/../../lib_espeak/glaemscribe_tts.js"
+      
+      def self.loaded?
+        !@context.nil?
+      end
+      
+      def self.load_engine
+        return if @context
+        
+        @context                    = ::MiniRacer::Context.new
+        
+        @context.attach 'console.log',  proc{|o| puts o}
+        @context.attach 'print',        proc{|o| puts o}
+        
+        espeak_lib                  = File.open(TTS_ENGINE_PATH,"rb").read
+        @context.eval(espeak_lib)
+
+        tts_module                  = File.open(TTS_MODULE_PATH,"rb").read    
+        @context.eval(tts_module)
+
+        @voice_list = @context.eval("Glaemscribe.TTS.voice_list()")
+#        puts "TTS Engine loaded."
+      end
+      
+      def self.voice_list
+        load_engine if !@context
+        @voice_list
+      end
+  
+      def self.ipa(text, voice, has_raw_mode)
+        load_engine if !@context
+        @context.eval("var esp = new Glaemscribe.TTS(); esp.synthesize_ipa(#{text.inspect},{voice:'#{voice}', has_raw_mode: #{has_raw_mode}})")
+      end
+  
+      def self.wav(text, voice, has_raw_mode)
+        load_engine if !@context
+        @context.eval("var esp = new Glaemscribe.TTS(); esp.synthesize_wav(#{text.inspect},{voice:'#{voice}', has_raw_mode: #{has_raw_mode}})")
+      end
+  
+      def self.option_name_to_voice(option_name)
+        option_name.downcase.gsub(/^espeak_voice_/,'').gsub('_','-')
+      end
+    end
+  end
+end