formosa 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2007-07-29
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,23 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/formosa.rb
+lib/formosa/version.rb
+lib/formosa/syllable_utility.rb
+lib/ext/native_syllable_composer/HoloVowels.h
+lib/ext/native_syllable_composer/LibHolo.h
+lib/ext/native_syllable_composer/compose.cpp
+lib/ext/native_syllable_composer/compose.h
+lib/ext/native_syllable_composer/extconf.rb
+lib/ext/native_syllable_composer/native_syllable_composer.c
+scripts/txt2html
+setup.rb
+test/test_formosa.rb
+test/test_helper.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,18 @@
+Formosa is a Ruby library for processing Taiwanese languages. Major languages 
+spoken in Taiwan include Holo, Hakka, Mandarin and those of the indigenous
+people. Formosa is the Ruby branch of the lib-formosa project
+(http://code.google.com/p/lib-formosa/).
+
+Currently, we focus on the processing of the Holo (Southern Min) language,
+with necessary tools such as SyllableComposer available for general use.
+
+The following example shows how to use Formosa:
+
+  $KCODE="u"          # set the Ruby environment to use UTF-8
+  require "rubygems"
+  require "formosa"
+  include Formosa::Holo
+  poj = SyllableType::POJ
+  tl = SyllableType::TL
+  SyllableUtility.compose_syllable(poj, tl, "goa2")  # => guá
+  SyllableUtility.compose_syllable(tl, poj, "gua2")  # => goá

data/Rakefile

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'formosa', 'version')
+
+AUTHOR = 'Lukhnos D. Liu'  # can also be an array of Authors
+EMAIL = "lukhnos@gmail.com"
+DESCRIPTION = "A collection of libraries for Taiwanese languages processing"
+GEM_NAME = 'formosa' # what ppl will type to install your gem
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}"
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  @rubyforge_username ||= @config["username"]
+end
+
+RUBYFORGE_PROJECT = 'formosa' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "formosa"
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Formosa::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'formosa documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  # p.spec_extras = []
+  p.spec_extras = {
+     :extensions => ['lib/ext/native_syllable_composer/extconf.rb'],
+   }
+
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+
+desc 'Generate website files'
+task :website_generate do
+  Dir['website/**/*.txt'].each do |txt|
+    sh %{ ruby scripts/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]
+
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+

data/lib/ext/native_syllable_composer/HoloVowels.h

@@ -0,0 +1,242 @@
+// HoloVowels.h: Holo Vowel character composer for the Holo dialects
+//
+// Copyright (c) 2007 The OpenVanilla Project (http://openvanilla.org)
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. Neither the name of OpenVanilla nor the names of its contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// This module follows the POJ/TL convention of tone notation.
+// The tone of any DT input must be re-mapped before feeding into
+// the ComposeHoloVowel() function
+//
+// TL does not compose nn and ou (TL uses oo--there's no ou), 
+// use the flag "composePOJOnlySymbols=false" when composing TL vowels.
+//
+// If you are feeding the ending N (in POJ) to this function, you
+// must explicity covert it into "nn" (lower case only). This is because
+// "n" can mean other things elsewhere.
+
+#ifndef __HoloVowels_h
+#define __HoloVowels_h
+
+#include <string>
+
+namespace LibHolo {
+
+    using namespace std;
+    
+    string ComposeHoloVowel(const string& vowel, unsigned int tone, bool composePOJOnlySymbols=true, bool useMiddleDotFallback=false);
+    
+	string GetToneASCIIRepresentation(unsigned int tone);
+	bool IsDiacriticSymbol(char c);
+};
+
+namespace LibHolo {
+
+    const char *holoVowelLookupTable="aeimnoquAEIMNOQU";
+    const unsigned int holoVowelRows = 16;
+    
+    #ifndef _MSC_VER
+    
+        static const char *holoNasel="ⁿ";
+        
+        // ou = o + U+0358 (default)
+        static const char *holoVowels[holoVowelRows * 9]= {
+            "a", "á", "à", "a", "â", "ǎ", "ā", "a̍", "a̋",
+            "e", "é", "è", "e", "ê", "ě", "ē", "e̍", "e̋",
+            "i", "í", "ì", "i", "î", "ǐ", "ī", "i̍", "i̋",
+            "m", "ḿ", "m̀", "m", "m̂", "m̌", "m̄", "m̍", "m̋",
+            "n", "ń", "ǹ", "n", "n̂", "ň", "n̄", "n̍", "n̋",
+            "o", "ó", "ò", "o", "ô", "ǒ", "ō", "o̍", "ő", 
+            "o͘", "ó͘", "ò͘", "o͘", "ô͘", "ǒ͘", "ō͘", "o̍͘", "ő͘",
+            "u", "ú", "ù", "u", "û", "ǔ", "ū", "u̍", "ű",
+            "A", "Á", "À", "a", "Â", "Ǎ", "Ā", "A̍", "A̋",
+            "E", "É", "È", "E", "Ê", "Ě", "Ē", "E̍", "E̋",
+            "I", "Í", "Ì", "I", "Î", "Ǐ", "Ī", "I̍", "I̋",
+            "M", "Ḿ", "M̀", "M", "M̂", "M̌", "M̄", "M̍", "M̋",
+            "N", "Ń", "Ǹ", "N", "N̂", "Ň", "N̄", "N̍", "N̋",
+            "O", "Ó", "Ò", "O", "Ô", "Ǒ", "Ō", "O̍", "Ő",
+            "O͘", "Ó͘", "Ò͘", "O͘", "Ô͘", "Ǒ͘", "Ō͘", "O̍͘", "Ő͘",
+            "U", "Ú", "Ù", "U", "Û", "Ǔ", "Ū", "U̍", "Ű"
+        };
+        
+        // Does not use U+0358 (fallback)
+        static const char *holoVowelsUsingFallback[holoVowelRows * 9]= {
+            "a", "á", "à", "a", "â", "ǎ", "ā", "a̍", "a̋",
+            "e", "é", "è", "e", "ê", "ě", "ē", "e̍", "e̋",
+            "i", "í", "ì", "i", "î", "ǐ", "ī", "i̍", "i̋",
+            "m", "ḿ", "m̀", "m", "m̂", "m̌", "m̄", "m̍", "m̋",
+            "n", "ń", "ǹ", "n", "n̂", "ň", "n̄", "n̍", "n̋",
+            "o·","ó·","ò·","o·","ô·","ǒ·","ō·","o̍·", "ő·",
+            "u", "ú", "ù", "u", "û", "ǔ", "ū", "u̍", "ű",
+            "A", "Á", "À", "a", "Â", "Ǎ", "Ā", "A̍", "A̋",
+            "E", "É", "È", "E", "Ê", "Ě", "Ē", "E̍", "E̋",
+            "I", "Í", "Ì", "I", "Î", "Ǐ", "Ī", "I̍", "I̋",
+            "M", "Ḿ", "M̀", "M", "M̂", "M̌", "M̄", "M̍", "M̋",
+            "N", "Ń", "Ǹ", "N", "N̂", "Ň", "N̄", "N̍", "N̋",
+            "O", "Ó", "Ò", "O", "Ô", "Ǒ", "Ō", "O̍", "Ő",
+            "O·","Ó·","Ò·","O·","Ô·","Ǒ·","Ō·","O̍·","Ő·",
+            "U", "Ú", "Ù", "U", "Û", "Ǔ", "Ū", "U̍", "Ű"
+        };
+    #endif
+    
+    // we don't use #ifndef ... #else, otherwise MSC will try to 
+    // peek into the above section, causing compiler to stop!
+    
+    #ifdef _MSC_VER
+        static const char *holoNasel="\xe2\x81\xbf";
+
+        // ou = o + U+0358 (default)
+        static const char *holoVowels[holoVowelRows * 9]= {
+            "a", "\xc3\xa1", "\xc3\xa0", "a", "\xc3\xa2", "\xc7\x8e", "\xc4\x81", "a\xcc\x8d", "a\xcc\x8b",
+            "e", "\xc3\xa9", "\xc3\xa8", "e", "\xc3\xaa", "\xc4\x9b", "\xc4\x93", "e\xcc\x8d", "e\xcc\x8b",
+            "i", "\xc3\xad", "\xc3\xac", "i", "\xc3\xae", "\xc7\x90", "\xc4\xab", "i\xcc\x8d", "i\xcc\x8b",
+            "m", "\xe1\xb8\xbf", "m\xcc\x80", "m", "m\xcc\x82", "m\xcc\x8c", "m\xcc\x84", "m\xcc\x8d", "m\xcc\x8b",
+            "n", "\xc5\x84", "\xc7\xb9", "n", "n\xcc\x82", "n\xcc\x8c", "n\xcc\x84", "n\xcc\x8d", "n\xcc\x8b",
+            "o", "\xc3\xb3", "\xc3\xb2", "o", "\xc3\xb4", "\xc7\x92", "\xc5\x8d", "o\xcc\x8d", "\xc5\x91", 
+            "o\xcd\x98", "\xc3\xb3\xcd\x98", "\xc3\xb2\xcd\x98", "o\xcd\x98", "\xc3\xb4\xcd\x98", "\xc7\x92\xcd\x98", "\xc5\x8d\xcd\x98", "o\xcc\x8d\xcd\x98", "o\xcc\x8b\xcd\x98",
+            "u", "\xc3\xba", "\xc3\xb9", "u", "\xc3\xbb", "\xc7\x94", "\xc5\xab", "u\xcc\x8d", "\xc5\xb1",
+            "A", "\xc3\x81", "\xc3\x80", "a", "\xc3\x82", "\xc7\x8d", "\xc4\x80", "A\xcc\x8d", "A\xcc\x8b",
+            "E", "\xc3\x89", "\xc3\x88", "E", "\xc3\x8a", "\xc4\x9a", "\xc4\x92", "E\xcc\x8d", "E\xcc\x8b",
+            "I", "\xc3\x8d", "\xc3\x8c", "I", "\xc3\x8e", "\xc7\x8f", "\xc4\xaa", "I\xcc\x8d", "I\xcc\x8b",
+            "M", "\xe1\xb8\xbe", "M\xcc\x80", "M", "M\xcc\x82", "M\xcc\x8c", "M\xcc\x84", "M\xcc\x8d", "M\xcc\x8b",
+            "N", "\xc5\x83", "\xc7\xb8", "N", "N\xcc\x82", "N\xcc\x8c", "N\xcc\x84", "N\xcc\x8d", "N\xcc\x8b",
+            "O", "\xc3\x93", "\xc3\x92", "O", "\xc3\x94", "\xc7\x91", "\xc5\x8c", "O\xcc\x8d", "\xc5\x90",
+            "O\xcd\x98", "\xc3\x93\xcd\x98", "\xc3\x92\xcd\x98", "O\xcd\x98", "\xc3\x94\xcd\x98", "\xc7\x91\xcd\x98", "\xc5\x8c\xcd\x98", "O\xcc\x8d\xcd\x98", "O\xcc\x8b\xcd\x98",
+            "U", "\xc3\x9a", "\xc3\x99", "U", "\xc3\x9b", "\xc7\x93", "\xc5\xaa", "U\xcc\x8d", "\xc5\xb0"
+        };
+    
+        // Does not use U+0358 (fallback)
+        static const char *holoVowelsUsingFallback[holoVowelRows * 9]= {
+            "a", "\xc3\xa1", "\xc3\xa0", "a", "\xc3\xa2", "\xc7\x8e", "\xc4\x81", "a\xcc\x8d", "a\xcc\x8b",
+            "e", "\xc3\xa9", "\xc3\xa8", "e", "\xc3\xaa", "\xc4\x9b", "\xc4\x93", "e\xcc\x8d", "e\xcc\x8b",
+            "i", "\xc3\xad", "\xc3\xac", "i", "\xc3\xae", "\xc7\x90", "\xc4\xab", "i\xcc\x8d", "i\xcc\x8b",
+            "m", "\xe1\xb8\xbf", "m\xcc\x80", "m", "m\xcc\x82", "m\xcc\x8c", "m\xcc\x84", "m\xcc\x8d", "m\xcc\x8b",
+            "n", "\xc5\x84", "\xc7\xb9", "n", "n\xcc\x82", "n\xcc\x8c", "n\xcc\x84", "n\xcc\x8d", "n\xcc\x8b",
+            "o\xc2\xb7","\xc3\xb3\xc2\xb7","\xc3\xb2\xc2\xb7","o\xc2\xb7","\xc3\xb4\xc2\xb7","\xc7\x92\xc2\xb7","\xc5\x8d\xc2\xb7","o\xcc\x8d\xc2\xb7", "o\xcc\x8b\xc2\xb7",
+            "u", "\xc3\xba", "\xc3\xb9", "u", "\xc3\xbb", "\xc7\x94", "\xc5\xab", "u\xcc\x8d", "\xc5\xb1",
+            "A", "\xc3\x81", "\xc3\x80", "a", "\xc3\x82", "\xc7\x8d", "\xc4\x80", "A\xcc\x8d", "A\xcc\x8b",
+            "E", "\xc3\x89", "\xc3\x88", "E", "\xc3\x8a", "\xc4\x9a", "\xc4\x92", "E\xcc\x8d", "E\xcc\x8b",
+            "I", "\xc3\x8d", "\xc3\x8c", "I", "\xc3\x8e", "\xc7\x8f", "\xc4\xaa", "I\xcc\x8d", "I\xcc\x8b",
+            "M", "\xe1\xb8\xbe", "M\xcc\x80", "M", "M\xcc\x82", "M\xcc\x8c", "M\xcc\x84", "M\xcc\x8d", "M\xcc\x8b",
+            "N", "\xc5\x83", "\xc7\xb8", "N", "N\xcc\x82", "N\xcc\x8c", "N\xcc\x84", "N\xcc\x8d", "N\xcc\x8b",
+            "O", "\xc3\x93", "\xc3\x92", "O", "\xc3\x94", "\xc7\x91", "\xc5\x8c", "O\xcc\x8d", "\xc5\x90",
+            "O\xc2\xb7","\xc3\x93\xc2\xb7","\xc3\x92\xc2\xb7","O\xc2\xb7","\xc3\x94\xc2\xb7","\xc7\x91\xc2\xb7","\xc5\x8c\xc2\xb7","O\xcc\x8d\xc2\xb7","O\xcc\x8b\xc2\xb7",
+            "U", "\xc3\x9a", "\xc3\x99", "U", "\xc3\x9b", "\xc7\x93", "\xc5\xaa", "U\xcc\x8d", "\xc5\xb0"
+        };
+    #endif
+    
+    
+    string ComposeHoloVowel(const string& vowel, unsigned int tone, bool composePOJOnlySymbols, bool useMiddleDotFallback)
+    {
+        string composed;
+        string coda;
+        
+        // if tone is out of range, return
+        if (tone > 9) return composed;
+        
+        // if tone is 0, treat as tone 1
+        unsigned int realtone = (tone == 0) ? 1 : tone;
+        
+        // then we substract realtone by 1 to get the real realtone... XD
+        realtone--;
+        
+        if (!vowel.length()) return composed;
+        
+		// we reject "q", only accept the real ou
+        if (vowel=="q" || vowel=="Q") return composed;
+        
+        if (vowel == "nn" || vowel=="Nn" || vowel=="Nn" || vowel=="NN") {
+            composed = composePOJOnlySymbols ? holoNasel : vowel;
+            return composed;
+        }
+     
+        // pick up the table to use   
+        const char **vowels = useMiddleDotFallback ? holoVowelsUsingFallback : holoVowels;
+        
+        // use the first character in the vowel string as the look-up character
+        char lookupChar = vowel[0];
+        coda = vowel.substr(1, vowel.length()-1);
+        
+        if (composePOJOnlySymbols)
+        {
+            if (vowel=="OU" || vowel=="Ou" || vowel=="OO" || vowel=="Oo") { lookupChar = 'Q'; coda = ""; }
+            else { if (vowel=="ou" || vowel=="oU" || vowel=="oo" || vowel=="oO") { lookupChar = 'q'; } coda = ""; }
+        }
+        
+        unsigned int s = strlen(holoVowelLookupTable);
+        unsigned int row;
+        
+        for (row=0; row<s; row++) if (holoVowelLookupTable[row] == lookupChar) break;
+    
+        // if not found, i reaches the end
+        if (row==s) return composed;
+        
+        // now we pick up the correct composed form
+        composed = vowels[row*9 + realtone];
+        return composed + coda;
+    }
+
+	string GetToneASCIIRepresentation(unsigned int tone)
+	{
+		switch(tone)
+		{
+			case 2: return string ("'");
+			case 3: return string ("`");
+			case 5: return string ("^");
+			case 6: return string ("/");
+			case 7: return string ("=");
+			case 8: return string ("|");
+			case 9: return string ("\"");
+		}
+		
+		return string();
+	}
+	
+	bool IsDiacriticSymbol(char c)
+	{
+		if (c=='\'' || c=='`' || c=='|' || c=='^' || c=='/' || c=='=' || c=='\"') return true;
+		return false;
+	}
+	
+	unsigned int ToneFromDiacriticSymbol(char c)
+	{
+		switch(c)
+		{
+			case '\'': return 2;
+			case '`': return 3;
+			case '^': return 5;
+			case '/': return 6;
+			case '=': return 7;
+			case '|': return 8;
+			case '\"': return 9;
+		}
+		return 0;
+	}
+}
+
+#endif  // of #ifndef __HoloVowels_h
+