ve 0.0.3 → 0.0.4

data/java/gradlew.bat

@@ -0,0 +1,104 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

data/java/pom.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>uk.co.birchlabs.ve</groupId>
+    <artifactId>ve</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <name>main source</name>
+    <url>http://maven.apache.org</url>
+
+    <repositories>
+        <repository>
+            <id>Atilika Open Source repository</id>
+            <url>http://www.atilika.org/nexus/content/repositories/atilika</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.atilika.kuromoji</groupId>
+            <artifactId>kuromoji</artifactId>
+            <version>0.7.7</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <slf4jVersion>1.7.21</slf4jVersion>
+        <asyncHttpClientVersion>2.0.6</asyncHttpClientVersion>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

data/java/readme.md

@@ -0,0 +1,103 @@
+# Setup and usage
+
+## Integrating into build
+
+I've used Maven for managing the build. Unfortunately, I am no expert on Maven so I can't help much on integration (but will try my best). There's very little complexity to this project, thankfully. For starters, here is `ve`'s package description as listed in `pom.xml`:
+
+```
+<groupId>uk.co.birchlabs.ve</groupId>
+<artifactId>ve</artifactId>
+<version>1.0-SNAPSHOT</version>
+```
+
+You could either:
+
+  * Install this to your global Maven repository (see [the instructions I wrote](https://github.com/shirakaba/sen-mavenized/blob/master/README.md) for a similar project if you don't already know how), and add the `ve` package as a `<dependency>` to your project; or...
+
+  * ~~Give up on modularity and just drag the files straight into your project.~~
+  
+  * Add this project as a git submodule and import it using gradle
+    ```groovy
+    // settings.gradle
+    include ':ve'
+    project(':ve').projectDir = new File('ve/java')
+    ...
+    // build.gradle
+    dependencies {
+        implementation project(':ve')
+    }
+    ```
+  
+No matter how you go about integrating it, please adhere to the rules of the software license.
+
+*Useful info: [official guide to POMs](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html).*
+*Note: I would be very interested if someone could teach me how to put this package on the Maven central repository, to make integration much easier for everyone.*
+  
+## Importing into source
+
+Import via: `import uk.co.birchlabs.ve`
+
+Ve has a dependency on a tokenizer. As [kuromoji](https://github.com/atilika/kuromoji) is the most convenient/portable Mecab interface for Java, I coded it to accept Tokens in the format of the Kuromoji Token class.
+
+*Fun fact: An older (not-to-be-released) version of this project was hooked up with [Sen](https://github.com/shirakaba/sen-mavenized), but its installation turned out to be much, much harder than kuromoji's. If you really want to use Sen (or any other non-Kuromoji Mecab interface) with Ve, I advise you to make a simple tool to convert those incompatible Tokens to Kuromoji-style ones for input into Ve.*
+
+In all, I import:
+
+```
+import uk.co.birchlabs.ve
+import org.atilika.kuromoji.Token;
+import org.atilika.kuromoji.Tokenizer;
+```
+
+## Usage
+
+Here's a line-by-line explanation of the `coreUsage` test I provided, detailing `Ve`'s core feature: parsing collections of Tokens into Words (more lexically meaningful groupings of Tokens, using Kim's special recipe).
+
+``` java
+// Some nonsense Japanese with interesting word boundaries.
+String stringOfJapanese = "お金がなければいけないです。";
+// Output the Kuromoji-style Tokens as a List
+List<Token> tokensList = Tokenizer.builder().build().tokenize(stringOfJapanese);
+// Convert to a basic Token array (I haven't adapted Ve to accept Lists of Tokens)
+Token[] tokensArray = tokensList.toArray(new Token[tokensList.size()]);
+// Create a parser instance from the array of Kuromoji-style Tokens.
+Parse parser = new Parse(tokensArray);
+// Get the Tokens out as 'Words'.
+List<Word> words = parser.words();
+// The .toString() method of each Word is generally the most useful. It shows the surface form of the Tokens.
+// Output: [お金, が, なければいけない, です, 。]
+System.out.println(words);
+```
+
+Note that each Word object stores all its constituent Tokens (unchanged from how they were passed in) losslessly, in order of their appearance in the Word! Think of the possibilities :D
+
+# How to run the tests (to prove that it works)
+
+These tests auto-pass; they purely exist to show you the command-line output of Ve's `parse` function.
+
+## If using an IDE such as IntelliJ
+
+1. Open `ve/java` in the IDE (the folder containing `pom.xml`)
+
+2. Open `test/java/ve/VeTest.java`
+
+3. Run the JUnit `coreUsage()` test by clicking the 'play' button beside it.
+
+## If using the command line
+
+1. `cd` into the `ve/java` directory
+
+2. Run the command:
+  * `mvn test` (whole test suite); or:
+  * `mvn test -Dtest=VeTest,coreUsage` (single test)
+
+# License
+
+Java port of Ve © 2017 Jamie Birch, whose many horcruxes can be found across:
+ * [Github] [shirakaba](https://github.com/shirakaba)
+ * [Twitter] [@LinguaBrowse](https://twitter.com/LinguaBrowse)
+ * [Reddit] [r/LinguaBrowse](https://www.reddit.com/r/LinguaBrowse/)
+ * [Tumblr] [#LinguaBrowse](https://linguabrowse.tumblr.com/)
+ * [Facebook] [LinguaBrowse](https://www.facebook.com/LinguaBrowse/)
+
+This is under the MIT license; a copy is provided at the root of this repository.

data/java/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 've'

data/java/src/main/java/ve/Grammar.java

@@ -0,0 +1,10 @@
+package ve;
+
+/** Copyright © 2017 Jamie Birch: [GitHub] shirakaba | [Twitter] LinguaBrowse
+ * Released under MIT license (see LICENSE.txt at root of repository).
+ **/
+public enum Grammar {
+    Auxiliary,
+    Nominal,
+    Unassigned
+}

data/java/src/main/java/ve/Parse.java

@@ -0,0 +1,336 @@
+package ve;
+
+import org.atilika.kuromoji.Token;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/** Copyright © 2017 Jamie Birch: [GitHub] shirakaba | [Twitter] LinguaBrowse
+  * Released under MIT license (see LICENSE.txt at root of repository).
+  *
+  * A Java port of Kim Ahlström's Ruby code for Ve's Parse (which identifies word boundaries).
+  **/
+public class Parse {
+    private final Token[] tokenArray;
+    private static final String NO_DATA = "*";
+
+    private static final int POS1 = 0;
+    private static final int POS2 = 1;
+    private static final int POS3 = 2;
+    private static final int POS4 = 3;
+    private static final int CTYPE = 4;
+    private static final int CFORM = 5;
+    private static final int BASIC = 6;
+    private static final int READING = 7;
+    private static final int PRONUNCIATION = 8;
+
+    public Parse(Token[] tokenArray) {
+        if(tokenArray.length == 0) throw new UnsupportedOperationException("Cannot parse an empty array of tokens.");
+
+        this.tokenArray = tokenArray;
+    }
+
+    /**
+     * @return List of all words in the instance's tokenArray, or an empty list if tokenArray was empty.
+     *         Ve returns an asterisk if no word was recognised.
+     *  */
+    public List<Word> words(){
+        List<Word> wordList = new ArrayList<>();
+        Token current = null, previous = null, following = null;
+
+        for(int i = 0; i < tokenArray.length; i++){
+            int finalSlot = wordList.size() - 1;
+            current = tokenArray[i];
+            Pos pos = null; // could make this TBD instead.
+            Grammar grammar = Grammar.Unassigned;
+            boolean eat_next = false,
+                    eat_lemma = true,
+                    attach_to_previous = false,
+                    also_attach_to_lemma = false,
+                    update_pos = false;
+
+            String[] currentPOSArray = Arrays.copyOfRange(current.getAllFeaturesArray(), POS1, POS4 +1);
+
+            if(currentPOSArray.length == 0 || currentPOSArray[POS1].equals(NO_DATA))
+                throw new IllegalStateException("No Pos data found for token.");
+
+            switch (currentPOSArray[POS1]){
+                case MEISHI:
+//                case MICHIGO:
+                    pos = Pos.Noun;
+                    if(currentPOSArray[POS2].equals(NO_DATA)) break;
+                    switch (currentPOSArray[POS2]){
+                        case KOYUUMEISHI:
+                            pos = Pos.ProperNoun;
+                            break;
+                        case DAIMEISHI:
+                            pos = Pos.Pronoun;
+                            break;
+                        case FUKUSHIKANOU:
+                        case SAHENSETSUZOKU:
+                        case KEIYOUDOUSHIGOKAN:
+                        case NAIKEIYOUSHIGOKAN:
+                            // Refers to line 213 of Ve.
+                            if(currentPOSArray[POS3].equals(NO_DATA)) break;
+                            if(i == tokenArray.length -1) break; // protects against array overshooting.
+                            following = tokenArray[i+1];
+                            switch(following.getAllFeaturesArray()[CTYPE]){
+                                case SAHEN_SURU:
+                                    pos = Pos.Verb;
+                                    eat_next = true;
+                                    break;
+                                case TOKUSHU_DA:
+                                    pos = Pos.Adjective;
+                                    if(Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS2].equals(TAIGENSETSUZOKU)){
+                                        eat_next = true;
+                                        eat_lemma = false;
+                                    }
+                                    break;
+                                case TOKUSHU_NAI:
+                                    pos = Pos.Adjective;
+                                    eat_next = true;
+                                    break;
+                                default:
+                                    if(Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS1].equals(JOSHI)
+                                            && following.getSurfaceForm().equals(NI))
+                                        pos = Pos.Adverb; // Ve script redundantly (I think) also has eat_next = false here.
+                                    break;
+                            }
+
+                            break;
+                        case HIJIRITSU:
+                        case TOKUSHU:
+                            // Refers to line 233 of Ve.
+                            if(currentPOSArray[POS3].equals(NO_DATA)) break;
+                            if(i == tokenArray.length -1) break; // protects against array overshooting.
+                            following = tokenArray[i+1];
+
+                            switch(currentPOSArray[POS3]){
+                                case FUKUSHIKANOU:
+                                    if(Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS1].equals(JOSHI)
+                                        && following.getSurfaceForm().equals(NI)){
+                                        pos = Pos.Adverb;
+                                        eat_next = false; // Changed this to false because 'case JOSHI' has 'attach_to_previous = true'.
+                                    }
+                                    break;
+                                case JODOUSHIGOKAN:
+                                    if(following.getAllFeaturesArray()[CTYPE].equals(TOKUSHU_DA)){
+                                        pos = Pos.Verb;
+                                     grammar = Grammar.Auxiliary;
+                                        if(following.getAllFeaturesArray()[CFORM].equals(TAIGENSETSUZOKU)) eat_next = true;
+                                    }
+                                    else if (Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS1].equals(JOSHI)
+                                        && Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS3].equals(FUKUSHIKA)){
+                                        pos = Pos.Adverb;
+                                        eat_next = true;
+                                    }
+                                    break;
+                                case KEIYOUDOUSHIGOKAN:
+                                    pos = Pos.Adjective;
+                                    if(following.getAllFeaturesArray()[CTYPE].equals(TOKUSHU_DA) && following.getAllFeaturesArray()[CTYPE].equals(TAIGENSETSUZOKU)
+                                            || Arrays.copyOfRange(following.getAllFeaturesArray(), POS1, POS4 +1)[POS2].equals(RENTAIKA))
+                                        eat_next = true;
+                                    break;
+                                default:
+                                    break;
+                            }
+                            break;
+                        case KAZU:
+                            // TODO: "recurse and find following numbers and add to this word. Except non-numbers like 幾"
+                            // Refers to line 261.
+                            pos = Pos.Number;
+                            if(wordList.size() > 0 && wordList.get(finalSlot).getPart_of_speech().equals(Pos.Number)){
+                                attach_to_previous = true;
+                                also_attach_to_lemma = true;
+                            }
+                            break;
+                        case SETSUBI:
+                            // Refers to line 267.
+                            if(currentPOSArray[POS3].equals(JINMEI)) pos = Pos.Suffix;
+                            else{
+                                if(currentPOSArray[POS3].equals(TOKUSHU) && current.getAllFeaturesArray()[BASIC].equals(SA)){
+                                    update_pos = true;
+                                    pos = Pos.Noun;
+                                }
+                                else also_attach_to_lemma = true;
+                                attach_to_previous = true;
+                            }
+                            break;
+                        case SETSUZOKUSHITEKI:
+                            pos = Pos.Conjunction;
+                            break;
+                        case DOUSHIHIJIRITSUTEKI:
+                            pos = Pos.Verb;
+                            grammar = Grammar.Nominal; // not using.
+                            break;
+                        default:
+                            // Keep Pos as Noun, as it currently is.
+                            break;
+                    }
+                    break;
+                case SETTOUSHI:
+                    // TODO: "elaborate this when we have the "main part" feature for words?"
+                    pos = Pos.Prefix;
+                    break;
+                case JODOUSHI:
+                    // Refers to line 290.
+                    pos = Pos.Postposition;
+                    final List<String> qualifyingList1 = Arrays.asList(TOKUSHU_TA, TOKUSHU_NAI, TOKUSHU_TAI, TOKUSHU_MASU, TOKUSHU_NU);
+                    if(previous == null || !Arrays.copyOfRange(previous.getAllFeaturesArray(), POS1, POS4 +1)[POS2].equals(KAKARIJOSHI)
+                            && qualifyingList1.contains(current.getAllFeaturesArray()[CTYPE]))
+                        attach_to_previous = true;
+                    else if (current.getAllFeaturesArray()[CTYPE].equals(FUHENKAGATA) && current.getAllFeaturesArray()[BASIC].equals(NN))
+                        attach_to_previous = true;
+                    else if (current.getAllFeaturesArray()[CTYPE].equals(TOKUSHU_DA) || current.getAllFeaturesArray()[CTYPE].equals(TOKUSHU_DESU)
+                            && !current.getSurfaceForm().equals(NA))
+                        pos = Pos.Verb;
+                    break;
+                case DOUSHI:
+                    // Refers to line 299.
+                    pos = Pos.Verb;
+                    switch (currentPOSArray[POS2]){
+                        case SETSUBI:
+                            attach_to_previous = true;
+                            break;
+                        case HIJIRITSU:
+                            if(!current.getAllFeaturesArray()[CFORM].equals(MEIREI_I)) attach_to_previous = true;
+                        default:
+                            break;
+                    }
+                    break;
+                case KEIYOUSHI:
+                    pos = Pos.Adjective;
+                    break;
+                case JOSHI:
+                    // Refers to line 309.
+                    pos = Pos.Postposition;
+                    final List<String> qualifyingList2 = Arrays.asList(TE, DE, BA); // added NI
+                    if(currentPOSArray[POS2].equals(SETSUZOKUJOSHI) && qualifyingList2.contains(current.getSurfaceForm())
+                            || current.getSurfaceForm().equals(NI))
+                        attach_to_previous = true;
+                    break;
+                case RENTAISHI:
+                    pos = Pos.Determiner;
+                    break;
+                case SETSUZOKUSHI:
+                    pos = Pos.Conjunction;
+                    break;
+                case FUKUSHI:
+                    pos = Pos.Adverb;
+                    break;
+                case KIGOU:
+                    pos = Pos.Symbol;
+                    break;
+                case FIRAA:
+                case KANDOUSHI:
+                    pos = Pos.Interjection;
+                    break;
+                case SONOTA:
+                    pos = Pos.Other;
+                    break;
+                default:
+                    pos = Pos.TBD;
+                    // C'est une catastrophe
+            }
+
+            if(attach_to_previous && wordList.size() > 0){
+                // these sometimes try to add to null readings.
+                wordList.get(finalSlot).getTokens().add(current);
+                wordList.get(finalSlot).appendToWord(current.getSurfaceForm());
+                wordList.get(finalSlot).appendToReading(getFeatureSafely(current, READING));
+                wordList.get(finalSlot).appendToTranscription(getFeatureSafely(current, PRONUNCIATION));
+                if(also_attach_to_lemma) wordList.get(finalSlot).appendToLemma(current.getAllFeaturesArray()[BASIC]); // lemma == basic.
+                if(update_pos) wordList.get(finalSlot).setPart_of_speech(pos);
+            }
+            else {
+                Word word = new Word(current.getReading(),
+                        getFeatureSafely(current, PRONUNCIATION),
+                        grammar,
+                        current.getAllFeaturesArray()[BASIC],
+                        pos,
+                        current.getSurfaceForm(),
+                        current);
+                if(eat_next){
+                    if(i == tokenArray.length -1) throw new IllegalStateException("There's a path that allows array overshooting.");
+                    following = tokenArray[i+1];
+                    word.getTokens().add(following);
+                    word.appendToWord(following.getSurfaceForm());
+                    word.appendToReading(following.getReading());
+                    word.appendToTranscription(getFeatureSafely(following, PRONUNCIATION));
+                    if (eat_lemma) word.appendToLemma(following.getAllFeaturesArray()[BASIC]);
+                }
+                wordList.add(word);
+            }
+            previous = current;
+
+        }
+
+        return wordList;
+    }
+
+    /** Return an asterisk if pronunciation field isn't in array (READING and PRONUNCIATION fields are left undefined,
+      * rather than as "*" by MeCab). Other feature fields are guaranteed to be safe, however. */
+    private String getFeatureSafely(Token token, int feature) {
+        if(feature > PRONUNCIATION) throw new IllegalStateException("Asked for a feature out of bounds.");
+        return token.getAllFeaturesArray().length >= feature + 1 ? token.getAllFeaturesArray()[feature] : "*";
+    }
+
+    // POS1
+    private static final String MEISHI = "名詞";
+    private static final String KOYUUMEISHI = "固有名詞";
+    private static final String DAIMEISHI = "代名詞";
+    private static final String JODOUSHI = "助動詞";
+    private static final String KAZU = "数";
+    private static final String JOSHI = "助詞";
+    private static final String SETTOUSHI = "接頭詞";
+    private static final String DOUSHI = "動詞";
+    private static final String KIGOU = "記号";
+    private static final String FIRAA = "フィラー";
+    private static final String SONOTA = "その他";
+    private static final String KANDOUSHI = "感動詞";
+    private static final String RENTAISHI = "連体詞";
+    private static final String SETSUZOKUSHI = "接続詞";
+    private static final String FUKUSHI = "副詞";
+    private static final String SETSUZOKUJOSHI = "接続助詞";
+    private static final String KEIYOUSHI = "形容詞";
+    private static final String MICHIGO = "未知語";
+
+    // POS2_BLACKLIST and inflection types
+    private static final String HIJIRITSU = "非自立";
+    private static final String FUKUSHIKANOU = "副詞可能";
+    private static final String SAHENSETSUZOKU = "サ変接続";
+    private static final String KEIYOUDOUSHIGOKAN = "形容動詞語幹";
+    private static final String NAIKEIYOUSHIGOKAN = "ナイ形容詞語幹";
+    private static final String JODOUSHIGOKAN = "助動詞語幹";
+    private static final String FUKUSHIKA = "副詞化";
+    private static final String TAIGENSETSUZOKU = "体言接続";
+    private static final String RENTAIKA = "連体化";
+    private static final String TOKUSHU = "特殊";
+    private static final String SETSUBI = "接尾";
+    private static final String SETSUZOKUSHITEKI = "接続詞的";
+    private static final String DOUSHIHIJIRITSUTEKI = "動詞非自立的";
+    private static final String SAHEN_SURU = "サ変・スル";
+    private static final String TOKUSHU_TA = "特殊・タ";
+    private static final String TOKUSHU_NAI = "特殊・ナイ";
+    private static final String TOKUSHU_TAI = "特殊・タイ";
+    private static final String TOKUSHU_DESU = "特殊・デス";
+    private static final String TOKUSHU_DA = "特殊・ダ";
+    private static final String TOKUSHU_MASU = "特殊・マス";
+    private static final String TOKUSHU_NU = "特殊・ヌ";
+    private static final String FUHENKAGATA = "不変化型";
+    private static final String JINMEI = "人名";
+    private static final String MEIREI_I = "命令ｉ";
+    private static final String KAKARIJOSHI = "係助詞";
+    private static final String KAKUJOSHI = "格助詞";
+
+    // etc
+    private static final String NA = "な";
+    private static final String NI = "に";
+    private static final String TE = "て";
+    private static final String DE = "で";
+    private static final String BA = "ば";
+    private static final String NN = "ん";
+    private static final String SA = "さ";
+
+}