oroti.oro

#
# Copyright (c) 2019 Esrille Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

ライブラリ: ファイル、プログラム

全角半角表 = str.maketrans('ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ'
                   'ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ'
                   '０１２３４５６７８９：；！＋－＊／％＜＞＆｜＾～＝（）［］｛｝',
                   'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                   'abcdefghijklmnopqrstuvwxyz'
                   '0123456789:;!+-*/%<>&|^~=()[]{}',
                   '\n')


主体: 出力
－－－－－
出力を　はじめにととのえます、とは。
    0を出力のインデントにいれます。
    0を出力のモードにいれます。
    「」を出力の主体にいれます。
    0を出力の改行数にいれます。
    「」を出力のメソッドターゲットにいれます。
    「」を出力のメソッド名にいれます。
    0を出力のメソッドインデントにいれます。
    []を出力のメソッド引数にいれます。
    {}を出力のキーワード引数にいれます。
    []を出力の文字列集にいれます。
    0を出力の文字列カウントにいれます。

出力を（桁）桁だけ　ずらします、とは。
    出力のインデント + 桁を出力のインデントにいれます。

出力を　リセットします、とは。
    0を出力のインデントにいれます。
    0を出力のモードにいれます。
    「」を出力の主体にいれます。

出力の　モードをリセットします、とは。
    0を出力のモードにいれます。

出力を(行)に　あわせます、とは。
    0をスペースにいれます。
    行でしたら、そして、行[0] == 「　」でしたら、くりかえします。
        スペース + 2をスペースにいれます。
        行[1:]を行にいれます。
    行のながさを出力のインデントにいれます。
    行 = 行.lstrip()
    出力のインデント - 行のながさを出力のインデントにいれます。
    出力のインデント + スペースを出力のインデントにいれます。
    出力の主体でしたら、
        出力のインデント + 4を出力のインデントにいれます。
    出力のモード == 2でしたら、
        出力のインデント + 4を出力のインデントにいれます。

出力を　フラッシュします、とは。
    出力のメソッド名でしたら、そして、出力のインデント <= 出力のメソッドインデントでしたら、
        出力のメソッドターゲット + 「.」 + 出力のメソッド名 + 「(」をバッファーにいれます。
        「」をくぎりにいれます。
        出力のメソッド引数のそれぞれの引数について、くりかえします。
            バッファー + くぎり + 引数をバッファーにいれます。
            「, 」をくぎりにいれます。
        出力のキーワード引数を項目でみまして、それぞれのなまえ、値について、くりかえします。
            バッファー + くぎり + なまえ + 「=」 + 値をバッファーにいれます。
            「, 」をくぎりにいれます。
        バッファー + 「)」をバッファーにいれます。
        出力でバッファーをもどしまして、バッファーにいれます。
        バッファーをうちだします。
        「」を出力のメソッド名にいれます。
        []を出力のメソッド引数にいれます。
        {}を出力のキーワード引数にいれます。
        真をかえします。
    偽をかえします。

出力に（主体）を　クラスとしてかきだします、とは。
    出力をフラッシュしましたら、
        おくりだします。
    チェック: 主体 != 「」
    出力の主体でしたら、
        出力のインデント - 4を出力のインデントにいれます。
    出力のモード == 2でしたら、
        出力のインデント - 4を出力のインデントにいれます。
    主体を出力の主体にいれます。
    出力を2行だけあけます。
    0を出力のモードにいれます。
    出力に「class 」、主体、「:」をおくりだします。
    1を出力のモードにいれます。

出力に（*引数）を　かきます、とは。
    0を出力の改行数にいれます。
    「」で引数をつなげまして、バッファーにいれます。
    出力でバッファーをもどしまして、バッファーにいれます。
    バッファーをうちだします。

出力を（行）行だけ　あけます、とは。
    出力をフラッシュしましたら、
        おくりだします。
    出力の改行数 < 行でしたら、
        行 - 出力の改行数を行にいれます。
        「\n」 * 行をうちだします。
        出力の改行数 + 行を出力の改行数にいれます。

出力を　字さげします、とは。
    0を出力の改行数にいれます。
    出力のモード == 1でしたら、
        2を出力のモードにいれます。
        おくりだします。
        出力を字さげします。
        「def default(self):」をおくりだします。
        出力のインデント + 4を出力のインデントにいれます。
    出力をフラッシュしましたら、
        おくりだします。
    「 」 * 出力のインデントをうちだします。

出力に（*引数）を　うちだします、とは。
    出力を字さげします。
    「」で引数をつなげまして、バッファーにいれます。
    出力でバッファーをもどしまして、バッファーにいれます。
    バッファーをうちだします。

出力に（*引数）を　おくりだします、とは。
    出力に*引数をうちだします。
    おくりだします。

出力に（*引数）を　そのままおくりだします、とは。
    「 」 * 出力のインデントをうちだします。
    「」で引数をつなげまして、バッファーにいれます。
    出力でバッファーをもどしまして、バッファーにいれます。
    バッファーをおくりだします。

出力に（メソッド）の　よびだしをだします、とは。
    出力をフラッシュしましたら、
        おくりだします。
    メソッド[0]を出力のメソッドターゲットにいれます。
    メソッド[1]を出力のメソッド名にいれます。
    メソッド[2]を出力のメソッド引数にいれます。
    出力のインデントを出力のメソッドインデントにいれます。

出力に（キーワード）と（値）を　引数としてわたします、とは。
    値を出力のキーワード引数[キーワード]にいれます。

出力で（行）を　ととのえます、とは。
    「」を文字列にいれます。
    「」をカッコにいれます。
    「」を結果にいれます。
    偽をエスケープにいれます。
    行のそれぞれの字について、くりかえします。
        カッコでないなら、
            「\'"「『」から字をみつけまして、iにいれます。
            0 <= iでしたら、
                「\'"\'"」[i]を文字列にいれます。
                結果 + 「＄」 + str(出力の文字列カウント) + 「＄」を結果にいれます。
                「\'"\」』」[i]をカッコにいれます。
                出力の文字列カウント + 1を出力の文字列カウントにいれます。
            そうでなければ、
                字を全角半角表でいれかえまして、字にいれます。
                結果 + 字を結果にいれます。
        あるいは、エスケープでしたら、
            字 == '」'でしたら、または、字 == '』'でしたら、
                文字列 + 字を文字列にいれます。
            そうでなければ、
                文字列 + '\\' + 字を文字列にいれます。
            偽をエスケープにいれます。
        あるいは、字 == '\\'でしたら、
            真をエスケープにいれます。
        あるいは、字 == カッコでしたら、
            「\'"\」』」から字をみつけまして、iにいれます。
            文字列 + 「\'"\'"」[i]を文字列にいれます。
            出力の文字列集に文字列をつけくわえます。
            「」を文字列にいれます。
            「」をカッコにいれます。
        そうでなければ、
            字 == "'"でしたら、そして、カッコ == '」'でしたら、
                文字列 + '\\'を文字列にいれます。
            あるいは、字 == '"'でしたら、そして、カッコ  == '』'でしたら、
                文字列 + '\\'を文字列にいれます。
            文字列 + 字を文字列にいれます。
    結果をかえします。

出力で（値）を　もどします、とは。
    「」を文字列にいれます。
    値でしたら、くりかえします。
        値から「＄」をみつけまして、位置にいれます。
        位置 < 0でしたら、
            文字列 + 値を文字列にいれます。
            「」を値にいれます。
            うちきります。
        文字列 + 値[:位置]を文字列にいれます。
        値[位置 + 1:]を値にいれます。
        値から「＄」をみつけまして、位置にいれます。
        チェック: 0 <= 位置
        値[:位置]をカウントにいれます。
        文字列 + 出力の文字列集[int(カウント)]を文字列にいれます。
        値[位置 + 1:]を値にいれます。
    文字列をかえします。

出力が　メソッドを出力しています、とは。
    出力のメソッド名でしたら、そして、出力のメソッドインデント < 出力のインデントでしたら、
        真をかえします。
    偽をかえします。


主体: 辞書
－－－－－
辞書を　はじめにととのえます、とは。
    set()を辞書の助詞一覧にいれます。
    set()を辞書のクラス一覧にいれます。
    {}を辞書のメソッド集にいれます。
    set()を辞書の属性一覧にいれます。
    辞書の属性一覧に「ながさ」をくわえます。
    「」を辞書の主体にいれます。

辞書で（なまえ）を　主体にします、とは。
    なまえを辞書の主体にいれます。
    なまえでしたら、
        辞書のクラス一覧になまえをくわえます。

辞書に（なまえ）を（メソッド）として　定義します、とは。
    メソッドを辞書のメソッド集[なまえ]にいれます。
    メソッド[1]のそれぞれの助詞について、くりかえします。
        辞書の助詞一覧に助詞をくわえます。

辞書で（文字列）を（助詞列）ごとに　わけます、とは。
    []を結果にいれます。
    文字列でないなら、
        結果をかえします。
    助詞列でないなら、
        結果に[文字列]をつけくわえます。
        結果をかえします。
    助詞列のそれぞれの助詞について、くりかえします。
        助詞列をコピーしまして、列にいれます。
        列から助詞をとりのぞきます。
        0をiにいれます。
        真でしたら、くりかえします。
            文字列[i:]から助詞をみつけまして、位置にいれます。
            位置 < 1でしたら、
                うちきります。
            位置 + iを位置にいれます。
            文字列のながさ <= 位置 + 助詞のながさでしたら、
                うちきります。
            辞書で文字列[位置 + 助詞のながさ:]を列ごとにわけまして、のこりにいれます。
            のこりのそれぞれのわけかたについて、くりかえします。
                [文字列[:位置], 助詞]をリストにいれます。
                リストにわけかたをまぜます。
                結果にリストをつけくわえます。
            位置 + 1をiにいれます。
    結果をかえします。

辞書で（文字列）から　メソッドをみつけます、とは。
    「」をメソッドにいれます。
    0をカウントにいれます。
    []を項にいれます。
    助詞列 = sorted(辞書の助詞一覧, key=lambda p: len(p), reverse=True)
    助詞列のそれぞれの助詞について、くりかえします。
        0をiにいれます。
        真でしたら、くりかえします。
            文字列[i + 1:]から助詞をみつけまして、jにいれます。
            j == -1でしたら、
                うちきります。
            i + 1 + jをiにいれます。
            文字列[:i]をターゲットにいれます。
            文字列[i + 助詞のながさ:]をなまえにいれます。
            なまえが辞書のメソッド集にありましたら、
                辞書のメソッド集[なまえ][1]を列にいれます。
            そうでなければ、
                つぎへ。
            助詞が列にありませんでしたら、
                つぎへ。
            なまえのながさ < メソッドのながさでしたら、
                つぎへ。

            列をコピーしまして、列にいれます。
            列から助詞をとりのぞきます。
            列でないなら、
                辞書でターゲットを属性形にしまして、ターゲットにいれます。
                ターゲット == 辞書の主体でしたら、
                    「self」をターゲットにいれます。
                メソッドのながさ < なまえのながさでしたら、または、カウント == 0でしたら、
                    [ターゲット, 助詞]を項にいれます。
                    なまえをメソッドにいれます。
                つぎへ。

            辞書でターゲットを列ごとにわけまして、結果にいれます。
            結果でないなら、
                つぎへ。

            0をcにいれます。
            結果のそれぞれの候補について、くりかえします。
                []をaにいれます。
                候補のそれぞれの項について、くりかえします。
                    辞書で項を式2にしまして、ペアにいれます。
                    c + ペア[1]をcにいれます。
                    aにペア[0]をつけくわえます。
                aに助詞をつけくわえます。
                メソッドのながさ < なまえのながさでしたら、または、カウント <= cでしたら、
                    aを項にいれます。
                    なまえをメソッドにいれます。
    項でないなら、
        項をかえします。
    []を引数にいれます。
    辞書のメソッド集[メソッド][1]のそれぞれの助詞について、くりかえします。
        range(1, 項のながさ, 2)のそれぞれのiについて、くりかえします。
            項[i] == 助詞でしたら、
                引数に項[i - 1]をつけくわえます。
                うちきります。
    引数[0] == 辞書の主体でしたら、
        'self'を引数[0]にいれます。

    []を可変長引数にいれます。
    引数のそれぞれの値について、くりかえします。
        値を「、」できりわけまして、値にいれます。
        可変長引数に値をまぜます。

    可変長引数[0]、辞書のメソッド集[メソッド][0]、可変長引数[1:]をかえします。

辞書で（文字列）から　クラスをみつけます、とは。
    辞書のクラス一覧に文字列がありましたら、
        文字列をかえします。
    「は」を助詞にいれます。
    文字列のながさを位置にいれます。
    真でしたら、くりかえします。
        文字列.rfind(助詞, 0, 位置)を位置にいれます。
        位置 == -1でしたら、
            うちきります。
        文字列[:位置]をなまえにいれます。
        辞書のクラス一覧になまえがありましたら、
            なまえをかえします。
    「」をかえします。

# 「[N1]の[N2]の[N3]...」, カウント
辞書で（文字列）を　属性形2にします、とは。
    カウント = 0
    文字列のながさを位置にいれます。
    真でしたら、くりかえします。
        文字列.rfind('の', 0, 位置)を位置にいれます。
        位置 == -1でしたら、
            うちきります。
        文字列[位置 + 1:]を属性にいれます。
        「」をカッコにいれます。
        属性から「[」をみつけまして、カッコ位置にいれます。
        0 <= カッコ位置でしたら、
            辞書で属性[カッコ位置:]を式にしまして、カッコにいれます。
            属性[:カッコ位置]を属性にいれます。
        辞書の属性一覧に属性がありましたら、
            辞書で文字列[:位置]を属性形2にしまして、ペアにいれます。
            ペア[1] + 1をカウントにいれます。
            カッコでないなら、そして、属性 == 「ながさ」でしたら、
                「len(」 + ペア[0] + 「)」、カウントをかえします。
            そうでなければ、
                ペア[0] + 「.」 + 属性 + カッコ、カウントをかえします。
        あるいは、文字列[:位置] == 辞書の主体でしたら、
            辞書の属性一覧に属性をくわえます。
            「self.」 + 属性 + カッコ、カウントをかえします。
    文字列 == 辞書の主体でしたら、
        「self」を文字列にいれます。
    文字列、カウントをかえします。

辞書で（文字列）を　属性形にします、とは。
    辞書で文字列を属性形2にしまして、ペアにいれます。
    ペア[0]をかえします。

辞書で（文字列）を　式2にします、とは。
    0をカウントにいれます。
    「" ,+-*/%<>&|^~!()[:]」をくぎりにいれます。
    range(文字列のながさ)のそれぞれの位置について、くりかえします。
        文字列[位置]がくぎりにありませんでしたら、
            うちきります。
    文字列[位置]がくぎりにありましたら、
        文字列、カウントをかえします。
    文字列[:位置]をでだしにいれます。
    文字列[位置:]を文字列にいれます。
    range(文字列のながさ)のそれぞれの位置について、くりかえします。
        文字列[位置]がくぎりにありましたら、
            文字列[:位置]を項にいれます。
            辞書で項を属性形2にしまして、左にいれます。
            辞書で文字列[位置:]を式2にしまして、右にいれます。
            でだし + 左[0] + 右[0]を文字列にいれます。
            左[1] + 右[1] + カウントをカウントにいれます。
            文字列、カウントをかえします。
    辞書で文字列を属性形2にしまして、ペアにいれます。
    でだし + ペア[0]、カウント + ペア[1]をかえします。

辞書で（文字列）を　式にします、とは。
    辞書で文字列を式2にしまして、ペアにいれます。
    ペア[0]をかえします。

辞書で（文字列）を（くぎり）をさかいに　くぎります、とは。
    0をカウントにいれます。
    文字列を左がわにいれます。
    「」を右がわにいれます。
    0を位置にいれます。
    真でしたら、くりかえします。
        文字列[位置:]からくぎりをみつけまして、位置2にいれます。
        位置2 == -1でしたら、
            左がわ、右がわをかえします。
        位置 + 位置2を位置にいれます。
        1をcntにいれます。
        辞書で文字列[:位置]を式2にしまして、ペアにいれます。
        ペア[0]を左にいれます。
        cnt + ペア[1]をcntにいれます。
        辞書で文字列[位置 + くぎりのながさ:]を式2にしまして、ペアにいれます。
        ペア[0]を右にいれます。
        cnt + ペア[1]をcntにいれます。
        カウント < cntでしたら、
            cntをカウントにいれます。
            左を左がわにいれます。
            右を右がわにいれます。
        位置 + 1を位置にいれます。
    左がわ、右がわをかえします。

辞書で（行）を　定義としてよみます、とは。
    チェック: 行が「、とは。」でおわります。
    行[:-4]から余白をとりまして、行にいれます。
    チェック: 辞書の主体 == 行[:辞書の主体のながさ]
    行[辞書の主体のながさ:]を行にいれます。
    行.rfind('　')を位置にいれます。
    チェック: 0 < 位置
    行[位置 + 1:]をメソッドにいれます。
    行[:位置]から余白をとりまして、行にいれます。
    []を助詞列にいれます。
    []を引数にいれます。
    行でしたら、くりかえします。
        行から「(」をみつけまして、位置にいれます。
        位置 < 0でしたら、
            助詞列に行をつけくわえます。
            「」を行にいれます。
        そうでなければ、
            行[:位置]から余白をとりまして、助詞にいれます。
            助詞列に助詞をつけくわえます。
            行[位置 + 1:]から余白をとりまして、行にいれます。
            行から「)」をみつけまして、位置にいれます。
            チェック: 0 < 位置
            行[:位置]から余白をとりまして、項にいれます。
            引数に項をつけくわえます。
            行[位置 + 1:]から余白をとりまして、行にいれます。
    メソッド == "はじめにととのえます"でしたら、
        「__init__」をメソッドにいれます。
    メソッド、助詞列、引数をかえします。

辞書を　かきだします、とは。
    「 」で辞書のクラス一覧をつなげまして、一覧にいれます。
    「主体一覧: 」、一覧をおくりだします。
    「 」でsorted(辞書の助詞一覧, key=lambda p: len(p), reverse=True)をつなげまして、一覧にいれます。
    「助詞一覧: 」、一覧をおくりだします。
    「述語一覧:」をうちだします。
    辞書のメソッド集を項目でみまして、それぞれのなまえ、メソッドについて、くりかえします。
        なまえ、メソッドをおくりだします。


主体: トランスパイラー
－－－－－－－－－－－
トランスパイラーに（ソース名）を　とりこみます、とは。
    あたらしいファイルをつくりまして、ソースにいれます。
    あたらしいファイルをつくりまして、ライブラリにいれます。
    ソースをひらきます。
        ファイル名はソース名です。
    0を行番号にいれます。
    ソースのそれぞれの行について、くりかえします。
        行番号 + 1を行番号にいれます。
        行を全角半角表でいれかえまして、行にいれます。
        行から余白をとりまして、行にいれます。
        行が「ライブラリ:」ではじまりましたら、
            行[6:]から余白をとりまして、行にいれます。
            行を「、」できりわけまして、リストにいれます。
            リストのそれぞれのライブラリ名について、くりかえします。
                辞書で「」を主体にします。
                ライブラリをひらきます。
                    ファイル名はライブラリ名 + 「.py」です。
                ライブラリのそれぞれの行について、くりかえします。
                    行が「#!」ではじまりましたら、
                        つぎへ。
                    行が「# -*- coding:」ではじまりましたら、
                        つぎへ。
                    出力に行をうちだします。
                    行を全角半角表でいれかえまして、行にいれます。
                    行から余白をとりまして、行にいれます。
                    行が「#」ではじまりませんでしたら、
                        つぎへ。
                    行[1:]から余白をとりまして、行にいれます。
                    行が「、とは。」でおわりましたら、
                        辞書で行を定義としてよみまして、メソッドにいれます。
                        辞書にメソッド[0]をメソッドとして定義します。
                    あるいは、行が「主体:」ではじまりましたら、
                        行[3:]から余白をとりまして、行にいれます。
                        辞書で行を主体にします。
                    あるいは、行が「属性:」ではじまりましたら、
                        行[3:]から余白をとりまして、行にいれます。
                        辞書の属性一覧に行をくわえます。
                ライブラリをとじます。
                辞書で「」を主体にします。
        あるいは、行が「主体:」ではじまりましたら、
            行[3:]から余白をとりまして、行にいれます。
            辞書で行を主体にします。
        あるいは、行が「、とは。」でおわりましたら、
            辞書で行を定義としてよみまして、メソッドにいれます。
            チェック: len(メソッド[1]) == len(set(メソッド[1]))
            辞書にメソッド[0]をメソッドとして定義します。
    ソースをとじます。

トランスパイラーで（行）を　条件節に訳します、とは。
    行を「、」できりわけまして、リストにいれます。
    リストのそれぞれの条件について、くりかえします。
        []をメソッドにいれます。
        条件から余白をとりまして、条件にいれます。
        条件 == 「または」でしたら、
            出力に「 or」をかきます。
        あるいは、条件 == 「そして」でしたら、
            出力に「 and」をかきます。
        あるいは、条件が「ましたら」でおわりましたら、
            条件[:-4] + 「ます」を条件にいれます。
            辞書で条件からメソッドをみつけまして、メソッドにいれます。
        あるいは、条件が「ませんでしたら」でおわりましたら、
            条件[:-7] + 「ます」を条件にいれます。
            辞書で条件からメソッドをみつけまして、メソッドにいれます。
            出力に「 not」をかきます。
        あるいは、条件が「でしたら」でおわりましたら、
            条件[:-4]から余白をとりまして、条件にいれます。
            辞書で条件を式にしまして、条件にいれます。
            出力に「 」、条件をかきます。
        あるいは、条件が「でないなら」でおわりましたら、
            条件[:-5]から余白をとりまして、条件にいれます。
            辞書で条件を式にしまして、条件にいれます。
            出力に「 not 」、条件をかきます。
        メソッドでしたら、
            出力に「 」をかきます。
            出力にメソッドのよびだしをだします。
            出力をフラッシュします。

# 「～ます。」でおわる行を訳します。
トランスパイラーで（行）を　文に訳します、とは。
    辞書で行からメソッドをみつけまして、メソッドにいれます。
    メソッドでしたら、
        出力を字さげします。
        トランスパイラーのアサートでしたら、
            出力に「assert 」をかきます。
        出力にメソッドのよびだしをだします。
    あるいは、行 == 「うちきります」でしたら、
        出力に「break」をおくりだします。
    あるいは、行が「をかえします」でおわりましたら、
        行[:-6]から余白をとりまして、行にいれます。
        行を「、」できりわけまして、リストにいれます。
        []を引数にいれます。
        リストのそれぞれの値について、くりかえします。
            辞書で値を式にしまして、値にいれます。
            引数に値をつけくわえます。
        「, 」で引数をつなげまして、引数にいれます。
        出力に「return 」、引数をおくりだします。
    あるいは、行が「をうちだします」でおわりましたら、
        行[:-7]から余白をとりまして、行にいれます。
        行を「、」できりわけまして、リストにいれます。
        []を引数にいれます。
        リストのそれぞれの値について、くりかえします。
            辞書で値を式にしまして、値にいれます。
            引数に値をつけくわえます。
        「, 」で引数をつなげまして、引数にいれます。
        出力に「print(」、引数、『, sep='', end='')』をおくりだします。
    あるいは、行が「おくりだします」でおわりましたら、
        行[:-7]から余白をとりまして、行にいれます。
        行でないなら、
            出力に「print()」をおくりだします。
        そうでなければ、
            チェック: 行[-1] == 「を」
            行[:-1]を「、」できりわけまして、リストにいれます。
            []を引数にいれます。
            リストのそれぞれの値について、くりかえします。
                辞書で値を式にしまして、値にいれます。
                引数に値をつけくわえます。
            「, 」で引数をつなげまして、引数にいれます。
            出力に「print(」、引数、「, sep='')」をおくりだします。
    あるいは、行が「について、くりかえします」でおわりましたら、
        行[:-12]から余白をとりまして、行にいれます。
        行から「それぞれの」をみつけまして、位置にいれます。
        チェック:　0 <= 位置
        行[位置 + 5:]から余白をとりまして、ターゲットにいれます。
        ターゲットを「、」できりわけまして、ターゲットにいれます。
        「, 」でターゲットをつなげまして、ターゲットにいれます。
        行[:位置]から余白をとりまして、行にいれます。
        行[-1] == 「の」でしたら、
            行[:-1]から余白をとりまして、行にいれます。
            辞書で行を式にしまして、リストにいれます。
            出力に「for 」、ターゲット、「 in 」、リスト、":"をおくりだします。
        そうでなければ、
            チェック:　行が「まして、」でおわります。
            行[:-4] + 「ます」を行にいれます。
            辞書で行からメソッドをみつけまして、メソッドにいれます。
            チェック:　メソッド
            出力に「for 」、ターゲット、「 in 」をうちだします。
            出力にメソッドのよびだしをだします。
            出力をフラッシュします。
            出力に「:\n」をかきます。
    あるいは、行が「ら、くりかえします」でおわりましたら、
        出力に「while」をうちだします。
        行[:-8]から余白をとりまして、行にいれます。
        トランスパイラーで行を条件節に訳します。
        出力に「:\n」をかきます。
    あるいは、行が「にいれます」でおわりましたら、
        行[:-5]から余白をとりまして、行にいれます。
        行から「まして、」をうしろからみつけまして、位置にいれます。
        0 <= 位置でしたら、
            行[位置 + 4:]から余白をとりまして、ターゲットにいれます。
            辞書でターゲットを属性形にしまして、ターゲットにいれます。
            行[:位置] + 「ます」を行にいれます。
            「」を主体にいれます。
            行が「あたらしい」ではじまりましたら、そして、行が「をつくります」でおわりましたら、
                行[5:-6]を主体にいれます。
            主体が辞書のクラス一覧にありましたら、
                トランスパイラーのアクター主体一覧に主体がありましたら、
                    トランスパイラーのアクター一覧にターゲットをつけくわえます。
                出力にターゲット、「 = 」、主体、「()」をおくりだします。
            そうでなければ、
                辞書で行からメソッドをみつけまして、メソッドにいれます。
                チェック:　メソッド
                出力にターゲット、「 = 」をうちだします。
                出力にメソッドのよびだしをだします。
                出力をフラッシュしましたら、
                    おくりだします。
        そうでなければ、
            辞書で行を「を」をさかいにくぎりまして、ペアにいれます。
            辞書でペア[0]を式にしまして、式にいれます。
            出力にペア[1]、「 = 」、式をおくりだします。

トランスパイラーで（ソース名）を　訳します、とは。
    あたらしいファイルをつくりまして、ソースにいれます。
    set()をトランスパイラーのアクター主体一覧にいれます。
    []をトランスパイラーのアクター一覧にいれます。

    ソースをひらきます。
        ファイル名はソース名です。
    0を行番号にいれます。
    ソースのそれぞれの行について、くりかえします。
        行番号 + 1を行番号にいれます。
        行が「－－」ではじまりましたら、
            つぎへ。
        出力で行をととのえまして、行にいれます。
        行が「ライブラリ:」ではじまりましたら、
            つぎへ。
        出力を行にあわせます。
        行から余白をとりまして、行にいれます。

        出力のモード == 2でしたら、
            トランスパイラーのアクター主体一覧に辞書の主体をくわえます。

        行が「チェック:」ではじまりましたら、
            行[5:]から余白をとりまして、行にいれます。
            真をトランスパイラーのアサートにいれます。
        そうでなければ、
            偽をトランスパイラーのアサートにいれます。

        行が「主体:」ではじまりましたら、
            行[3:]から余白をとりまして、行にいれます。
            辞書で行を主体にします。
            出力に辞書の主体をクラスとしてかきだします。
        あるいは、行が「はじめに:」ではじまりましたら、
            辞書で「」を主体にします。
            出力をリセットします。
            出力を2行だけあけます。
        あるいは、行が「ら、」でおわりましたら、
            出力を字さげします。
            行が「あるいは、」ではじまりましたら、
                出力に「elif」をかきます。
                行[5:]から余白をとりまして、行にいれます。
            そうでなければ、
                出力に「if」をかきます。
            行[:-1]から余白をとりまして、行にいれます。
            トランスパイラーで行を条件節に訳します。
            出力に「:\n」をかきます。
        あるいは、行 == 「そうでなければ、」でしたら、
            出力に「else:」をおくりだします。
        あるいは、行 == 「つぎへ。」でしたら、
            出力に「continue」をおくりだします。
        あるいは、行が「、とは。」でおわりましたら、
            辞書で行を定義としてよみまして、メソッドにいれます。
            出力を1行だけあけます。
            出力のモードをリセットします。
            出力に「def 」、メソッド[0]、「(self」をうちだします。
            メソッド[2]でしたら、
                「, 」でメソッド[2]をつなげまして、引数にいれます。
                出力に「, 」、引数をかきます。
            出力に「):\n」をかきます。
        あるいは、行が「ます。」でおわりましたら、
            行[:-1]から余白をとりまして、行にいれます。
            トランスパイラーで行を文に訳します。
        あるいは、行が「です。」でおわりましたら、
            行[:-1]から余白をとりまして、行にいれます。
            出力がメソッドを出力していましたら、
                行[:-2]から余白をとりまして、行にいれます。
                辞書で行を「は」をさかいにくぎりまして、ペアにいれます。
                出力にペア[0]とペア[1]を引数としてわたします。
            そうでなければ、
                辞書で行からメソッドをみつけまして、メソッドにいれます。
                チェック:　メソッド
                出力に「return 」、メソッド[0]、「.」、メソッド[1]、「()」をうちだします。
        あるいは、行でしたら、
            辞書で行を式にしまして、行にいれます。
            トランスパイラーのアサートでしたら、
                出力に「assert 」、行をおくりだします。
            そうでなければ、
                出力に行をそのままおくりだします。
        そうでなければ、
            出力を1行だけあけます。
    ソースをとじます。

    出力をフラッシュしましたら、
        おくりだします。
    出力をリセットします。

    トランスパイラーのアクター一覧でしたら、
        出力を1行だけあけます。
        出力に「while True:」をおくりだします。
        出力を4桁だけずらします。
        トランスパイラーのアクター一覧のそれぞれのアクターについて、くりかえします。
            出力にアクター、「.default()」をおくりだします。


はじめに:
－－－－－
プログラムの引数のながさ < 2でしたら、
    プログラムをおえます。

あたらしい出力をつくりまして、出力にいれます。
あたらしい辞書をつくりまして、辞書にいれます。

出力に「#!/usr/bin/python3\n」をかきます。
出力に「# -*- coding: utf-8 -*-\n」をかきます。
出力に「\n」をかきます。
出力に「真 = True\n」をかきます。
出力に「偽 = False\n」をかきます。

python_methods = {
    "あります": ["__contains__", ['に', 'が'], ['item']],
    "くわえます": ["add", ['に', 'を'], ['elem']],
    "つけくわえます": ["append", ['に', 'を'], ['x']],
    "コピーします": ["copy", ['を'], []],
    "おわります": ["endswith", ['が', 'で'], ['suffix']],
    "まぜます": ["extend", ['に', 'を'], ['iterable']],
    "みつけます": ["find", ['から', 'を'], ['sub']],
    "項目でみます": ["items", ['を'], []],
    "つなげます": ["join", ['で', 'を'], ['x']],
    "とりのぞきます": ["remove", ['から', 'を'], ['item']],
    "うしろからみつけます": ["rfind", ['から', 'を'], ['sub']],
    "きりわけます": ["split", ['を', 'で'], ['sep']],
    "はじまります": ["startswith", ['が', 'で'], ['prefix']],
    "余白をとります": ["strip", ['から'], []],
    "いれかえます": ["translate", ['を', 'で'], ['table']],
    "値でみます": ["values", ['を'], []],
}

python_methodsを項目でみまして、それぞれのなまえ、メソッドについて、くりかえします。
    辞書になまえをメソッドとして定義します。

あたらしいトランスパイラーをつくりまして、トランスパイラーにいれます。
トランスパイラーにプログラムの引数[1]をとりこみます。
トランスパイラーでプログラムの引数[1]を訳します。