nadesiko3 3.7.21 → 3.7.23

package/core/src/plugin_system_timer.mts

@@ -0,0 +1,152 @@
+/**
+ * @fileOverview なでしこ3 plugin_system の分割ファイル
+ *
+ * タイマー処理の命令を定義する。
+ * このファイルは単独のプラグインではなく、plugin_system.mts へマージされる。(#2351)
+ */
+import { NakoRuntimeError } from './nako_errors.mjs'
+import { NakoSystem } from './plugin_api.mjs'
+
+export default {
+  // @タイマー
+  '秒待': { // @ N秒の間待機する // @びょうまつ
+    type: 'func',
+    josi: [['']],
+    pure: true,
+    asyncFn: true,
+    fn: function(n: any, sys:any): Promise<void> {
+      return new Promise((resolve, reject) => {
+        try {
+          // タイマーを仕掛ける
+          const timerId = setTimeout(() => {
+            // タイマー使用中リストに追加したIDを削除
+            const i = sys.__timeout.indexOf(timerId)
+            if (i >= 0) { sys.__timeout.splice(i, 1) }
+            // Promiseを終了
+            resolve()
+          }, parseFloat(n) * 1000)
+          // タイマー使用中リストに追加
+          sys.__timeout.push(timerId)
+        } catch (err: any) {
+          reject(err)
+        }
+      })
+    },
+    return_none: true
+  },
+  '秒待機': { // @ N秒の間待機する(『秒待』と同じ) // @びょうたいき
+    type: 'func',
+    josi: [['']],
+    pure: true,
+    asyncFn: true,
+    fn: async function(n: any, sys: any) {
+      const p = sys.__exec('秒待', [n, sys])
+      return await p
+    },
+    return_none: true
+  },
+  '秒逐次待機': { // @ (非推奨) 逐次実行構文にて、N秒の間待機する (廃止予定) // @びょうちくじたいき
+    type: 'func',
+    josi: [['']],
+    pure: true,
+    asyncFn: true,
+    fn: async function(n: any, sys: any) {
+      const p = sys.__exec('秒待', [n, sys])
+      return await p
+    },
+    return_none: true
+  },
+  '秒後': { // @無名関数（あるいは、文字列で関数名を指定）FをN秒後に実行する。変数『対象』にタイマーIDを代入する。 // @びょうご
+    type: 'func',
+    josi: [['を'], ['']],
+    pure: true,
+    fn: function(f: any, n: any, sys: any) {
+      // 文字列で指定された関数をオブジェクトに変換
+      if (typeof f === 'string') { f = sys.__findFunc(f, '秒後') }
+      // 1回限りのタイマーをセット
+      const timerId = setTimeout(() => {
+        // 使用中リストに追加したIDを削除
+        const i = sys.__timeout.indexOf(timerId)
+        if (i >= 0) { sys.__timeout.splice(i, 1) }
+        try {
+          f(timerId, sys)
+        } catch (e: any) {
+          let err = e
+          if (!(e instanceof NakoRuntimeError)) {
+            err = new NakoRuntimeError(e, sys.__getSysVar('__line'))
+          }
+          sys.logger.error(err)
+        }
+      }, parseFloat(n) * 1000)
+      sys.__timeout.unshift(timerId)
+      sys.__setSysVar('対象', timerId)
+      return timerId
+    }
+  },
+  '秒毎': { // @無名関数（あるいは、文字列で関数名を指定）FをN秒ごとに実行する(『タイマー停止』で停止できる)。変数『対象』にタイマーIDを代入する。 // @びょうごと
+    type: 'func',
+    josi: [['を'], ['']],
+    pure: false,
+    fn: function(f: any, n: any, sys: any) {
+      // 文字列で指定された関数をオブジェクトに変換
+      if (typeof f === 'string') { f = sys.__findFunc(f, '秒毎') }
+      // タイマーをセット
+      const timerId = setInterval(() => {
+        f(timerId, sys)
+      }, parseFloat(n) * 1000)
+      // タイマーIDを追加
+      sys.__interval.unshift(timerId)
+      sys.__setSysVar('対象', timerId)
+      return timerId
+    }
+  },
+  '秒タイマー開始時': { // @無名関数（あるいは、文字列で関数名を指定）FをN秒ごとに実行する(『秒毎』と同じ) // @びょうたいまーかいししたとき
+    type: 'func',
+    josi: [['を'], ['']],
+    pure: false,
+    fn: function(f: any, n: any, sys: any) {
+      return sys.__exec('秒毎', [f, n, sys])
+    }
+  },
+  'タイマー停止': { // @『秒毎』『秒後』や『秒タイマー開始』で開始したタイマーを停止する // @たいまーていし
+    type: 'func',
+    josi: [['の', 'で']],
+    pure: true,
+    fn: function(timerId: any, sys: any) {
+      const i = sys.__interval.indexOf(timerId)
+      if (i >= 0) {
+        sys.__interval.splice(i, 1)
+        clearInterval(timerId)
+        return true
+      }
+      const j = sys.__timeout.indexOf(timerId)
+      if (j >= 0) {
+        sys.__timeout.splice(j, 1)
+        clearTimeout(timerId)
+        return true
+      }
+      return false
+    },
+    return_none: false
+  },
+  '全タイマー停止': { // @『秒毎』『秒後』や『秒タイマー開始』で開始したタイマーを全部停止する // @ぜんたいまーていし
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function(sys: NakoSystem) {
+      // clearInterval
+      for (let i = 0; i < sys.__interval.length; i++) {
+        const timerId = sys.__interval[i]
+        clearInterval(timerId)
+      }
+      sys.__interval = []
+      // clearTimeout
+      for (let i = 0; i < sys.__timeout.length; i++) {
+        const timerId = sys.__timeout[i]
+        clearTimeout(timerId)
+      }
+      sys.__timeout = []
+    },
+    return_none: true
+  },
+}

package/core/src/plugin_system_types.mts

@@ -0,0 +1,151 @@
+/**
+ * @fileOverview なでしこ3 plugin_system の分割ファイル
+ *
+ * 型変換の命令を定義する。
+ * このファイルは単独のプラグインではなく、plugin_system.mts へマージされる。(#2351)
+ */
+export default {
+  // @型変換
+  '変数型確認': { // @変数Vの型を返す // @へんすうかたかくにん
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(v: any) {
+      return (typeof v)
+    }
+  },
+  'TYPEOF': { // @変数Vの型を返す // @TYPEOF
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(v: any) {
+      return (typeof v)
+    }
+  },
+  '文字列変換': { // @値Vを文字列に変換 // @もじれつへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): string {
+      return String(v)
+    }
+  },
+  'TOSTR': { // @値Vを文字列に変換 // @TOSTR
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): string {
+      return String(v)
+    }
+  },
+  '整数変換': { // @値Vを整数に変換 // @せいすうへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseInt(v)
+    }
+  },
+  'TOINT': { // @値Vを整数に変換 // @TOINT
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseInt(v)
+    }
+  },
+  '実数変換': { // @値Vを実数に変換 // @じっすうへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseFloat(v)
+    }
+  },
+  'TOFLOAT': { // @値Vを実数に変換 // @TOFLOAT
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseFloat(v)
+    }
+  },
+  'INT': { // @値Vを整数に変換 // @INT
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseInt(v)
+    }
+  },
+  'FLOAT': { // @値Vを実数に変換 // @FLOAT
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(v: any): number {
+      return parseFloat(v)
+    }
+  },
+  'NAN判定': { // @値VがNaNかどうかを判定(命令『非数判定』を使う事を推奨) // @NANはんてい
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): boolean {
+      return isNaN(v)
+    }
+  },
+  '非数判定': { // @値Vが非数かどうかを判定(NAN判定より堅牢) // @ひすうはんてい
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(v: any): boolean {
+      // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+      return Number.isNaN(v)
+    }
+  },
+  'HEX': { // @値Vを16進数に変換 // @HEX
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any): string {
+      return parseInt(a).toString(16)
+    }
+  },
+  '進数変換': { // @値VをN進数に変換 // @しんすうへんかん
+    type: 'func',
+    josi: [['を', 'の'], ['']],
+    pure: true,
+    fn: function(v: any, n: number): string {
+      return parseInt(v).toString(n)
+    }
+  },
+  '二進': { // @値Vを2進数に変換 // @にしん
+    type: 'func',
+    josi: [['を', 'の', 'から']],
+    pure: true,
+    fn: function(v: any): string {
+      return parseInt(v).toString(2)
+    }
+  },
+  '二進表示': { // @値Vを2進数に変換して表示 // @にしんひょうじ
+    type: 'func',
+    josi: [['を', 'の', 'から']],
+    pure: true,
+    fn: function(v: any, sys: any) {
+      const s = parseInt(v).toString(2)
+      sys.__exec('表示', [s, sys])
+    }
+  },
+  'RGB': { // @HTML用のカラーコードを返すRGB(R,G,B)で各値は0-255 // @RGB
+    type: 'func',
+    josi: [['と'], ['の'], ['で']],
+    pure: true,
+    fn: function(r: any, g: any, b: any): string {
+      const z2 = (v: any): string => {
+        const v2: string = '00' + (parseInt(String(v)).toString(16))
+        return v2.substring(v2.length - 2, v2.length)
+      }
+      return '#' + z2(r) + z2(g) + z2(b)
+    }
+  },
+}

package/core/src/plugin_system_url.mts

@@ -0,0 +1,193 @@
+/**
+ * @fileOverview なでしこ3 plugin_system の分割ファイル
+ *
+ * URLエンコード・パラメータ処理・BASE64・パス操作の命令を定義する。
+ * このファイルは単独のプラグインではなく、plugin_system.mts へマージされる。(#2351)
+ */
+import { NakoSystem } from './plugin_api.mjs'
+
+export default {
+  // @URLエンコードとパラメータ
+  'URLエンコード': { // @URLエンコードして返す // @URLえんこーど
+    type: 'func',
+    josi: [['を', 'から']],
+    pure: true,
+    fn: function(text: any) {
+      return encodeURIComponent(text)
+    }
+  },
+  'URLデコード': { // @URLデコードして返す // @URLでこーど
+    type: 'func',
+    josi: [['を', 'へ', 'に']],
+    pure: true,
+    fn: function(text: any) {
+      return decodeURIComponent(text)
+    }
+  },
+  'URLパラメータ解析': { // @URLパラメータを解析してハッシュで返す // @URLぱらめーたかいせき
+    type: 'func',
+    josi: [['を', 'の', 'から']],
+    pure: true,
+    fn: function(url: string, sys: any) {
+      const res: any = {}
+      if (typeof url !== 'string') {
+        return res
+      }
+      const p = url.split('?')
+      if (p.length <= 1) {
+        return res
+      }
+      const params = p[1].split('&')
+      for (const line of params) {
+        if (line === '') { continue }
+        const eqIdx = line.indexOf('=')
+        let k: string
+        let v: string
+        if (eqIdx < 0) {
+          k = line
+          v = ''
+        } else {
+          k = line.substring(0, eqIdx)
+          v = line.substring(eqIdx + 1)
+        }
+        const decodedKey = sys.__exec('URLデコード', [k])
+        const decodedVal = sys.__exec('URLデコード', [v])
+        res[decodedKey] = decodedVal
+      }
+      return res
+    }
+  },
+
+  // @BASE64
+  'BASE64エンコード': { // @BASE64エンコードして返す // @BASE64えんこーど
+    type: 'func',
+    josi: [['を', 'から']],
+    pure: true,
+    fn: function(text: any) {
+      // browser?
+      if (typeof (window) !== 'undefined' && (window as any).btoa) {
+        const u8a: any = new TextEncoder().encode(text)
+        const utf8str = String.fromCharCode.apply(null, u8a)
+        return btoa(utf8str)
+      }
+      // Node?
+      if (typeof (Buffer) !== 'undefined') {
+        return Buffer.from(text).toString('base64')
+      }
+      throw new Error('『BASE64エンコード』は利用できません。')
+    }
+  },
+  'BASE64デコード': { // @BASE64デコードして返す // @BASE64でこーど
+    type: 'func',
+    josi: [['を', 'へ', 'に']],
+    pure: true,
+    fn: function(text: any) {
+      if (typeof (window) !== 'undefined' && (window as any).atob) {
+        const decodedUtf8str = atob(text)
+        const dec: any = Array.prototype.map.call(decodedUtf8str, c => c.charCodeAt())
+        const decodedArray = new Uint8Array(dec)
+        return new TextDecoder('UTF-8').decode(decodedArray)
+      }
+      // Node?
+      if (typeof (Buffer) !== 'undefined') {
+        return Buffer.from(text, 'base64').toString()
+      }
+      throw new Error('『BASE64デコード』は利用できません。')
+    }
+  },
+
+  // @パス操作
+  '拡張子抽出': { // @ファイル名Sから拡張子を抽出する // @かくちょうしちゅうしゅつ
+    type: 'func',
+    josi: [['から', 'の']],
+    pure: true,
+    fn: function(fname: string, sys: NakoSystem) {
+      if (fname === null || fname === undefined) { return '' }
+      const sep = sys.pathSeparator || '/'
+      if (fname.indexOf(sep) >= 0) { // パス記号があればファイル名を抽出
+        const parts = fname.split(sep)
+        fname = parts[parts.length - 1]
+      }
+      const m = fname.match(/(\.[a-zA-Z0-9_\-+]+)$/)
+      if (m) { return m[1] }
+      return ''
+    }
+  },
+  '拡張子変更': { // @ファイル名Aの拡張子をBに変更して返す // @かくちょうしへんこう
+    type: 'func',
+    josi: [['の', 'を', 'から'], ['に', 'へ']],
+    pure: true,
+    fn: function(fname: string, ext: string, sys: NakoSystem) {
+      if (fname === null || fname === undefined) { return ext }
+      const sep = sys.pathSeparator || '/'
+      const pathList = fname.split(sep)
+      const filename = pathList[pathList.length - 1]
+      const pathStr = pathList.slice(0, -1).join(sep)
+      const rawExt = (ext ?? '').trim()
+      let extWithDot = rawExt
+      if (rawExt !== '' ) {
+        extWithDot = rawExt.startsWith('.') ? rawExt : '.' + rawExt
+      }
+      const newFilename = filename.replace(/(\.[a-zA-Z0-9_\-+]+)?$/, extWithDot)
+      return sys.__exec('終端パス追加', [pathStr, sys]) + newFilename
+    }
+  },
+  '終端パス追加': { // @パスSの終端にパス区切り文字を追加して返す // @しゅうたんぱすついか
+    type: 'func',
+    josi: [['に', 'へ']],
+    pure: true,
+    fn: function(path: string, sys: NakoSystem) {
+      const sep = sys.pathSeparator || '/'
+      if (path === undefined || path === null || path === '') {
+        return ''
+      }
+      if (path.endsWith(sep)) {
+        return path
+      }
+      return path + sep
+    }
+  },
+  '終端パス除去': { // @フォルダ名DIRの末尾にあるパス記号を削除する // @しゅうたんぱすじょきょ
+    type: 'func',
+    josi: [['の', 'から']],
+    pure: true,
+    fn: function(dir: string, sys: NakoSystem) {
+      const sep = sys.pathSeparator || '/'
+      if (!dir) { return '' }
+      if (dir.endsWith(sep)) {
+        return dir.substring(0, dir.length - 1)
+      } else {
+        return dir
+      }
+    }
+  },
+  '終端パス削除': { // @フォルダ名DIRの末尾にあるパス記号を削除する // @しゅうたんぱすさくじょ
+    type: 'func',
+    josi: [['の', 'から']],
+    pure: true,
+    fn: function(dir: string, sys: NakoSystem) {
+      return sys.__exec('終端パス除去', [dir, sys])
+    }
+  },
+  'ファイル名抽出': { // @パスPATHからファイル名を抽出して返す // @ふぁいるめいちゅうしゅつ
+    type: 'func',
+    josi: [['の', 'から']],
+    pure: true,
+    fn: function(dir: string, sys: NakoSystem) {
+      const sep = sys.pathSeparator || '/'
+      const parts = dir.split(sep)
+      return parts[parts.length - 1]
+    }
+  },
+  'パス抽出': { // @パスPATHからディレクトリ部分を抽出して返す // @ぱすちゅうしゅつ
+    type: 'func',
+    josi: [['の', 'から']],
+    pure: true,
+    fn: function(dir: string, sys: NakoSystem) {
+      const sep = sys.pathSeparator || '/'
+      const parts = dir.split(sep)
+      parts.pop()
+      return parts.join(sep)
+    }
+  }
+}

package/core/src/plugin_toml.mts

@@ -16,7 +16,7 @@ const PluginTOML = {
     type: 'func',
     josi: [],
     pure: true,
-    fn: function(sys: any) {
+    fn: function(_sys: any) {
     }
   },
   // @TOML
@@ -24,7 +24,7 @@ const PluginTOML = {
     type: 'func',
     josi: [['を', 'の', 'から']],
     pure: true,
-    fn: function(s: string, sys: any) {
+    fn: function(s: string, _sys: any) {
       return TOML.parse(s)
     }
   },
@@ -32,7 +32,7 @@ const PluginTOML = {
     type: 'func',
     josi: [['を', 'から', 'の']],
     pure: true,
-    fn: function(s: any, sys: any) {
+    fn: function(s: any, _sys: any) {
       return TOML.stringify(s)
     }
   }

package/core/test/algorithm_samples_test.mjs

@@ -0,0 +1,58 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { runAlgorithmTest } from './algorithms/helper.mjs'
+
+const testRoot = path.dirname(fileURLToPath(import.meta.url))
+const casesRoot = path.join(testRoot, 'algorithms')
+const sampleRoot = path.resolve(testRoot, '../sample/algorithms')
+
+async function findFiles (dir, suffix) {
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+  const files = []
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...await findFiles(entryPath, suffix))
+    } else if (entry.name.endsWith(suffix)) {
+      files.push(entryPath)
+    }
+  }
+  return files.sort()
+}
+
+function relativePath (base, target) {
+  return path.relative(base, target).split(path.sep).join('/')
+}
+
+const testFiles = await findFiles(casesRoot, '_test.nako3')
+const tests = testFiles.map(testPath => {
+  const relativeTest = relativePath(casesRoot, testPath)
+  return {
+    id: relativeTest.replace(/_test\.nako3$/, ''),
+    source: relativeTest.replace(/_test\.nako3$/, '.nako3'),
+    testPath
+  }
+})
+
+describe('アルゴリズムサンプル', () => {
+  it('全ての実装とテスト定義が1対1で対応している', async () => {
+    const sampleFiles = await findFiles(sampleRoot, '.nako3')
+    const sampleSources = sampleFiles.map(file => relativePath(sampleRoot, file))
+    const registeredSources = tests.map(test => test.source).sort()
+    const ids = tests.map(test => test.id)
+
+    assert.strictEqual(new Set(ids).size, ids.length, 'アルゴリズムIDが重複しています')
+    assert.strictEqual(new Set(registeredSources).size, registeredSources.length, '実装ファイルが重複登録されています')
+    assert.deepStrictEqual(registeredSources, sampleSources)
+  })
+
+  for (const test of tests) {
+    it(test.id, async () => {
+      const log = await runAlgorithmTest(sampleRoot, test.source, test.testPath)
+      assert.strictEqual(log, '')
+    })
+  }
+})

package/core/test/algorithms/graph/dijkstra_test.nako3

@@ -0,0 +1,21 @@
+# ダイクストラ法のテスト
+
+G=[
+    [{"先":1,"重み":4},{"先":2,"重み":1}],
+    [{"先":3,"重み":1}],
+    [{"先":1,"重み":2},{"先":3,"重み":5}],
+    []
+]
+実際はGを0からダイクストラ法処理してJSONエンコード
+実際と『[0,3,1,4]』がASSERT等
+
+G=[
+    [{"先":1,"重み":2}],
+    [],
+    []
+]
+実際はGを0からダイクストラ法処理してJSONエンコード
+実際と『[0,2,-1]』がASSERT等
+
+実際はGを4からダイクストラ法処理してJSONエンコード
+実際と『[]』がASSERT等

package/core/test/algorithms/graph/kruskal_test.nako3

@@ -0,0 +1,21 @@
+# クラスカル法のテスト
+
+E=[
+    {"始":0,"終":1,"重み":10},
+    {"始":0,"終":2,"重み":6},
+    {"始":0,"終":3,"重み":5},
+    {"始":1,"終":3,"重み":15},
+    {"始":2,"終":3,"重み":4}
+]
+実際は4とEでクラスカル法処理してJSONエンコード
+実際と『[{"始":2,"終":3,"重み":4},{"始":0,"終":3,"重み":5},{"始":0,"終":1,"重み":10}]』がASSERT等
+
+E=[
+    {"始":0,"終":1,"重み":1},
+    {"始":2,"終":3,"重み":2}
+]
+実際は4とEでクラスカル法処理してJSONエンコード
+実際と『[{"始":0,"終":1,"重み":1},{"始":2,"終":3,"重み":2}]』がASSERT等
+
+実際は0と[]でクラスカル法処理してJSONエンコード
+実際と『[]』がASSERT等

package/core/test/algorithms/helper.mjs

@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { NakoCompiler } from '../../src/nako3.mjs'
+
+export async function runAlgorithmTest (sampleRoot, source, testPath) {
+  const sourcePath = path.resolve(sampleRoot, source)
+  const sourceCode = await fs.readFile(sourcePath, 'utf8')
+  const test = await fs.readFile(testPath, 'utf8')
+  const code = `${sourceCode}\n${test}\n`
+  const compiler = new NakoCompiler()
+  const result = await compiler.runAsync(code, testPath)
+  return result.log
+}

package/core/test/algorithms/math/euclidean_gcd_test.nako3

@@ -0,0 +1,13 @@
+# ユークリッドの互除法のテスト
+
+実際は1071と462の最大公約数計算処理
+実際と21がASSERT等
+
+実際は24と0の最大公約数計算処理
+実際と24がASSERT等
+
+実際は0と0の最大公約数計算処理
+実際と0がASSERT等
+
+実際は-54と24の最大公約数計算処理
+実際と6がASSERT等

package/core/test/algorithms/math/sieve_of_eratosthenes_test.nako3

@@ -0,0 +1,10 @@
+# エラトステネスの篩のテスト
+
+実際は30までの素数列挙処理してJSONエンコード
+実際と『[2,3,5,7,11,13,17,19,23,29]』がASSERT等
+
+実際は2までの素数列挙処理してJSONエンコード
+実際と『[2]』がASSERT等
+
+実際は1までの素数列挙処理してJSONエンコード
+実際と『[]』がASSERT等

package/core/test/algorithms/search/binary_search_test.nako3

@@ -0,0 +1,15 @@
+# 二分探索処理のテスト
+
+A=[1,3,5,7,9]
+実際はAから5を二分探索処理
+実際と2がASSERT等
+
+実際はAから9を二分探索処理
+実際と4がASSERT等
+
+実際はAから4を二分探索処理
+実際と-1がASSERT等
+
+A=[]
+実際はAから1を二分探索処理
+実際と-1がASSERT等