nadesiko3 3.2.27

package/src/nako_parser_base.js

@@ -0,0 +1,265 @@
+/**
+ * なでしこの構文解析のためのユーティリティクラス
+ */
+
+const { NakoSyntaxError } = require('./nako_errors')
+
+class NakoParserBase {
+  /**
+   * @param {import("./nako_logger")} logger
+   */
+  constructor (logger) {
+    this.logger = logger
+    this.stackList = [] // 関数定義の際にスタックが混乱しないように整理する
+    this.init()
+    /** @type {import('./nako3').TokenWithSourceMap[]} */
+    this.tokens = []
+    /** @type {import('./nako3').Ast[]} */
+    this.stack = []
+    this.index = 0
+    /** @type {import('./nako3').Ast[]} */
+    this.y = []
+    this.genMode = 'sync' // #637
+  }
+
+  init () {
+    this.funclist = {} // 関数の一覧
+    this.reset()
+  }
+
+  reset () {
+    /** @type {import('./nako3').TokenWithSourceMap[]} */
+    this.tokens = [] // 字句解析済みのトークンの一覧を保存
+    this.index = 0 // tokens[] のどこまで読んだかを管理する
+    this.stack = [] // 計算用のスタック ... 直接は操作せず、pushStack() popStack() を介して使う
+    this.y = [] // accept()で解析済みのトークンを配列で得るときに使う
+    this.genMode = 'sync' // #637, #1056
+  }
+
+  setFuncList (funclist) {
+    this.funclist = funclist
+  }
+
+  /**
+   * 特定の助詞を持つ要素をスタックから一つ下ろす、指定がなければ末尾を下ろす
+   * @param {string[]} josiList 下ろしたい助詞の配列
+   * @returns {import('./nako3').Ast | null | undefined}
+   */
+  popStack (josiList) {
+    if (!josiList) { return this.stack.pop() }
+
+    // josiList にマッチする助詞を探す
+    for (let i = 0; i < this.stack.length; i++) {
+      const t = this.stack[i]
+      if (josiList.length === 0 || josiList.indexOf(t.josi) >= 0) {
+        this.stack.splice(i, 1) // remove stack
+        this.logger.trace('POP :' + JSON.stringify(t))
+        return t
+      }
+    }
+    // 該当する助詞が見つからなかった場合
+    return null
+  }
+
+  /**
+   * saveStack と loadStack は対で使う。
+   * 関数定義などでスタックが混乱しないように配慮するためのもの
+   */
+  saveStack () {
+    this.stackList.push(this.stack)
+    this.stack = []
+  }
+
+  loadStack () {
+    this.stack = this.stackList.pop()
+  }
+
+  /**
+   * 計算用に要素をスタックに積む
+   */
+  pushStack (item) {
+    this.logger.debug('PUSH:' + JSON.stringify(item))
+    this.stack.push(item)
+  }
+
+  /**
+   * トークンの末尾に達したか
+   */
+  isEOF () {
+    return (this.index >= this.tokens.length)
+  }
+
+  /**
+   * カーソル位置にある単語の型を確かめる
+   */
+  check (ttype) {
+    return (this.tokens[this.index].type === ttype)
+  }
+
+  /**
+   * カーソル位置以降にある単語の型を確かめる 2単語以上に対応
+   * @param a [単語1の型, 単語2の型, ... ]
+   */
+  check2 (a) {
+    for (let i = 0; i < a.length; i++) {
+      const idx = i + this.index
+      if (this.tokens.length <= idx) { return false }
+      if (a[i] === '*') { continue } // ワイルドカード(どんなタイプも許容)
+      const t = this.tokens[idx]
+      if (a[i] instanceof Array) {
+        if (a[i].indexOf(t.type) < 0) { return false }
+        continue
+      }
+      if (t.type !== a[i]) { return false }
+    }
+    return true
+  }
+
+  /**
+   * カーソル位置の型を確認するが、複数の種類を確かめられる
+   */
+  checkTypes (a) {
+    const type = this.tokens[this.index].type
+    return (a.indexOf(type) >= 0)
+  }
+
+  /**
+   * check2の高度なやつ、型名の他にコールバック関数を指定できる
+   * 型にマッチしなければ null を返し、カーソルを巻き戻す
+   */
+  accept (types) {
+    const y = []
+    const tmpIndex = this.index
+    const rollback = () => {
+      this.index = tmpIndex
+      return false
+    }
+    for (let i = 0; i < types.length; i++) {
+      if (this.isEOF()) { return rollback() }
+      const type = types[i]
+      if (typeof type === 'string') {
+        const token = this.get()
+        if (token.type !== type) { return rollback() }
+        y[i] = token
+        continue
+      }
+      if (typeof type === 'function') {
+        const f = type.bind(this)
+        const r = f(y)
+        if (r === null) { return rollback() }
+        y[i] = r
+        continue
+      }
+      if (type instanceof Array) {
+        if (!this.checkTypes(type)) { return rollback() }
+        y[i] = this.get()
+        continue
+      }
+      throw new Error('System Error : accept broken : ' + typeof type)
+    }
+    this.y = y
+    return true
+  }
+
+  /**
+   * カーソル語句を取得して、カーソルを後ろに移動する
+   * @returns {import('./nako3').TokenWithSourceMap | null}
+   */
+  get () {
+    if (this.isEOF()) { return null }
+    return this.tokens[this.index++]
+  }
+
+  unget () {
+    if (this.index > 0) { this.index-- }
+  }
+
+  /**
+   * @returns {import('./nako3').TokenWithSourceMap | null}
+   */
+  peek (i = 0) {
+    if (this.isEOF()) { return null }
+    return this.tokens[this.index + i]
+  }
+
+  /**
+   * 現在のカーソル語句のソースコード上の位置を取得する。
+   * @returns {{
+   *     startOffset: number | null
+   *     endOffset: number | null
+   *     file: string | undefined
+   *     line: number
+   *     column: number
+   * }}
+   */
+  peekSourceMap () {
+    const token = this.peek()
+    if (token === null) {
+      return { startOffset: null, endOffset: null, file: undefined, line: 0, column: 0 }
+    }
+    return { startOffset: token.startOffset, endOffset: token.endOffset, file: token.file, line: token.line, column: token.column }
+  }
+
+  /**
+   * depth: 表示する深さ
+   * typeName: 先頭のtypeの表示を上書きする場合に設定する
+   * @param {{ depth: number, typeName?: string }} opts
+   * @param {boolean} debugMode
+   */
+  nodeToStr (node, opts, debugMode) {
+    const depth = opts.depth - 1
+    const typeName = (name) => opts.typeName !== undefined ? opts.typeName : name
+    const debug = debugMode ? (' debug: ' + JSON.stringify(node, null, 2)) : ''
+    if (!node) {
+      return '(NULL)'
+    }
+    switch (node.type) {
+      case 'not':
+        if (depth >= 0) {
+          return `${typeName('')}『${this.nodeToStr(node.value, { depth }, debugMode)}に演算子『not』を適用した式${debug}』`
+        } else {
+          return `${typeName('演算子')}『not』`
+        }
+      case 'op': {
+        let operator = node.operator
+        const table = { eq: '＝', not: '!', gt: '>', lt: '<', and: 'かつ', or: 'または' }
+        if (operator in table) {
+          operator = table[operator]
+        }
+        if (depth >= 0) {
+          const left = this.nodeToStr(node.left, { depth }, debugMode)
+          const right = this.nodeToStr(node.right, { depth }, debugMode)
+          if (node.operator === 'eq') {
+            return `${typeName('')}『${left}と${right}が等しいかどうかの比較${debug}』`
+          }
+          return `${typeName('')}『${left}と${right}に演算子『${operator}』を適用した式${debug}』`
+        } else {
+          return `${typeName('演算子')}『${operator}${debug}』`
+        }
+      }
+      case 'number':
+        return `${typeName('数値')}${node.value}`
+      case 'string':
+        return `${typeName('文字列')}『${node.value}${debug}』`
+      case 'word':
+        return `${typeName('単語')}『${node.value}${debug}』`
+      case 'func':
+        return `${typeName('関数')}『${node.name || node.value}${debug}』`
+      case 'eol':
+        return '行の末尾'
+      case 'eof':
+        return 'ファイルの末尾'
+      default: {
+        let name = node.name
+        if (!name) { name = node.value }
+        if (typeof name !== 'string') { name = node.type }
+        return `${typeName('')}『${name}${debug}』`
+      }
+    }
+  }
+}
+
+module.exports = {
+  NakoParserBase,
+  NakoSyntaxError
+}

package/src/nako_parser_const.js

@@ -0,0 +1,37 @@
+/* eslint-disable quote-props */
+const opPriority = {
+  // and or
+  'and': 1,
+  'or': 1,
+  // compare
+  'eq': 2,
+  'noteq': 2,
+  '===': 2,
+  '!==': 2,
+  'gt': 2,
+  'gteq': 2,
+  'lt': 2,
+  'lteq': 2,
+  '&': 3,
+  // + - << >> >>>
+  '+': 4,
+  '-': 4,
+  'shift_l': 4,
+  'shift_r': 4,
+  'shift_r0': 4,
+  // * /
+  '*': 5,
+  '/': 5,
+  '%': 5,
+  // ^
+  '^': 6
+}
+
+const keizokuJosi = [
+  'いて', 'えて', 'きて', 'けて', 'して', 'って', 'にて', 'みて', 'めて', 'ねて', 'には', 'んで'
+]
+
+module.exports = {
+  opPriority,
+  keizokuJosi
+}

package/src/nako_prepare.js

@@ -0,0 +1,293 @@
+/**
+ * nako_prepare.js
+ * 字句解析の前の前処理。全角文字を半角文字に変換するのが主な処理。
+ * ただし、コメントや文字列の中は変換しないように考慮して変換する。
+ */
+
+/**
+ * 置換後の位置から置換前の位置へマッピングできる文字列
+ */
+class Replace {
+  /**
+   * @param {string} code
+   */
+  constructor (code) {
+    /** @private @type {{ from: number, to: number, index: number }[]} */
+    this.history = []
+
+    /** @private */
+    this.code = code
+  }
+
+  /**
+   * @returns {string}
+   */
+  getText () {
+    return this.code
+  }
+
+  /**
+   * @param {string} from
+   * @param {string} to
+   */
+  replaceAll (from, to) {
+    while (true) {
+      const index = this.getText().indexOf(from)
+      if (index === -1) {
+        break
+      }
+      if (from.length !== to.length) {
+        this.history.unshift({ index, from: from.length, to: to.length })
+      }
+      this.code = this.code.replace(from, to)
+    }
+  }
+
+  /**
+   * @param {number} i
+   * @returns {number}
+   */
+  getSourcePosition (i) {
+    // 少し遅い。パース時間1.4秒に対して0.15秒かかる。iが単調増加することを利用して高速化できるはず。
+    for (const item of this.history) {
+      if (i >= item.index + item.to) { // 置換範囲より後ろ
+        i += item.from - item.to
+      } else if (item.index <= i && i < item.index + item.to) { // 置換範囲
+        // 置換文字列が2文字以上のとき、最後の文字は最後の文字へマップする。それ以外は最初の文字へマップする。
+        if (item.to >= 2 && i === item.index + item.to - 1) {
+          i = item.index + item.from - 1
+        } else {
+          i = item.index
+        }
+      }
+    }
+    return i
+  }
+}
+
+// 字句解析を行う前に全角文字を半角に揃える
+// ただし、文字列部分だけは、そのまま全角で出力するようにする
+// for https://github.com/kujirahand/nadesiko3/issues/94
+class NakoPrepare {
+  /**
+   * @param {import("./nako_logger")} logger
+   */
+  constructor (logger) {
+    this.logger = logger
+
+    // 参考) https://hydrocul.github.io/wiki/blog/2014/1101-hyphen-minus-wave-tilde.html
+    this.HYPHENS = { // ハイフン問題
+      0x2d: true, // ASCIIのハイフン
+      0x2010: true, // 別のハイフン
+      0x2011: true, // 改行しないハイフン
+      0x2013: true, // ENダッシュ
+      0x2014: true, // EMダッシュ
+      0x2015: true, // 全角のダッシュ
+      0x2212: true // 全角のマイナス
+    }
+    this.TILDES = { // チルダ問題
+      0x7e: true,
+      0x02dc: true, // 小さなチルダ
+      0x02F7: true, // Modifier Letter Low Tilde
+      0x2053: true, // Swung Dash - 辞書のみだし
+      0x223c: true, // Tilde Operator: 数学で Similar to
+      0x301c: true, // Wave Dash(一般的な波ダッシュ)
+      0xFF5E: true // 全角チルダ
+    }
+    // スペース問題
+    // 参考) http://anti.rosx.net/etc/memo/002_space.html
+    this.SPACES = {
+      0x20: true,
+      0x2000: true, // EN QUAD
+      0x2002: true, // EN SPACE
+      0x2003: true, // EM SPACE
+      0x2004: true, // THREE-PER-EM SPACE
+      0x2005: true, // FOUR-PER-EM SPACE
+      0x2006: true, // SIX-PER-EM SPACE
+      0x2007: true, // FIGURE SPACE
+      0x2009: true, // THIN SPACE
+      0x200A: true, // HAIR SPACE
+      0x200B: true, // ZERO WIDTH SPACE
+      0x202F: true, // NARROW NO-BREAK SPACE
+      0x205F: true, // MEDIUM MATHEMATICAL SPACE
+      0x3000: true, // 全角スペース
+      0x3164: true // HANGUL FILLER
+    }
+    // その他の変換
+    this.convertTable = {
+      0x09: ' ', // TAB --> SPC
+      0x203B: '#', // '※' --- コメント
+      0x3002: ';', // 句点
+      0x3010: '[', // '【'
+      0x3011: ']', // '】'
+      // 読点は「,」に変換する (#877)
+      0x3001: ',', // 読点 --- JSON記法で「,」と「、」を区別したいので読点は変換しないことに。(#276)
+      0xFF0C: ',' // 読点 '，' 論文などで利用、ただし句点はドットと被るので変換しない (#735)
+    }
+  }
+
+  // 一文字だけ変換
+  /**
+   * @param {string} ch
+   */
+  convert1ch (ch) {
+    if (!ch) { return '' }
+    const c = ch.codePointAt(0)
+    // テーブルによる変換
+    if (this.convertTable[c]) { return this.convertTable[c] }
+    // ASCIIエリア
+    if (c < 0x7F) { return ch }
+    // 全角半角単純変換可能 --- '！' - '～'
+    if (c >= 0xFF01 && c <= 0xFF5E) {
+      const c2 = c - 0xFEE0
+      return String.fromCodePoint(c2)
+    }
+    // 問題のエリア
+    if (this.HYPHENS[c]) { return '-' }
+    if (this.TILDES[c]) { return '~' }
+    if (this.SPACES[c]) { return ' ' }
+    return ch
+  }
+
+  /**
+   * @param {string} code
+   * @returns {{ text: string, sourcePosition: number }[]}
+   */
+  convert (code) {
+    if (!code) { return [] }
+    const src = new Replace(code)
+
+    // 改行コードを統一
+    src.replaceAll('\r\n', '\n')
+    src.replaceAll('\r', '\n')
+
+    let flagStr = false // 文字列リテラル内かどうか
+    let flagStr2 = false // 絵文字による文字列リテラル内かどうか
+    let endOfStr = '' // 文字列リテラルを終了させる記号
+    /** @type {{ text: string, sourcePosition: number }[]} */
+    const res = []
+    let left = 0 // 現在処理中の部分文字列の左端の位置
+    let str = '' // 文字列リテラルの値
+
+    // 一文字ずつ全角を半角に置換する
+    let i = 0
+    while (i < src.getText().length) {
+      const c = src.getText().charAt(i)
+      const ch2 = src.getText().substr(i, 2)
+      // 文字列のとき
+      if (flagStr) {
+        if (c === endOfStr) {
+          flagStr = false
+          res.push({ text: str + endOfStr, sourcePosition: src.getSourcePosition(left) })
+          i++
+          left = i
+          continue
+        }
+        str += c
+        i++
+        continue
+      }
+      // 絵文字制御による文字列のとき
+      if (flagStr2) {
+        if (ch2 === endOfStr) {
+          flagStr2 = false
+          res.push({ text: str + endOfStr, sourcePosition: src.getSourcePosition(left) })
+          i += 2
+          left = i
+          continue
+        }
+        str += c
+        i++
+        continue
+      }
+      // 文字列判定
+      if (c === '「') {
+        res.push({ text: c, sourcePosition: src.getSourcePosition(left) })
+        i++
+        left = i
+        flagStr = true
+        endOfStr = '」'
+        str = ''
+        continue
+      }
+      if (c === '『') {
+        res.push({ text: c, sourcePosition: src.getSourcePosition(left) })
+        i++
+        left = i
+        flagStr = true
+        endOfStr = '』'
+        str = ''
+        continue
+      }
+      if (c === '“') {
+        res.push({ text: c, sourcePosition: src.getSourcePosition(left) })
+        i++
+        left = i
+        flagStr = true
+        endOfStr = '”'
+        str = ''
+        continue
+      }
+      // JavaScriptの内部的には文字列はUTF-16で扱われてるので charAt を使う場合 絵文字が2文字扱いになる --- #726
+      if (ch2 === '🌴' || ch2 === '🌿') {
+        res.push({ text: ch2, sourcePosition: src.getSourcePosition(left) })
+        i += 2
+        left = i
+        flagStr2 = true
+        endOfStr = ch2
+        str = ''
+        continue
+      }
+      const c1 = this.convert1ch(c)
+      if (c1 === '"' || c1 === '\'') {
+        res.push({ text: c1, sourcePosition: src.getSourcePosition(left) })
+        i++
+        left = i
+        flagStr = true
+        endOfStr = c
+        str = ''
+        continue
+      }
+      // ラインコメントを飛ばす (#725)
+      if (c1 === '#') {
+        res.push({ text: c1, sourcePosition: src.getSourcePosition(left) })
+        i++
+        left = i
+        flagStr = true // 本当はコメントだけど便宜上
+        endOfStr = '\n'
+        str = ''
+        continue
+      }
+      // ラインコメントを飛ばす
+      if (ch2 === '//' || ch2 === '／／') {
+        res.push({ text: '//', sourcePosition: src.getSourcePosition(left) }) // 強制的に'//'とする
+        i += 2
+        left = i
+        flagStr = true
+        endOfStr = '\n'
+        str = ''
+        continue
+      }
+      // 複数行コメント内を飛ばす (#731)
+      if (ch2 === '/*') {
+        res.push({ text: ch2, sourcePosition: src.getSourcePosition(left) })
+        i += 2
+        left = i
+        flagStr2 = true
+        endOfStr = '*/'
+        str = ''
+        continue
+      }
+      // 変換したものを追加
+      res.push({ text: c1, sourcePosition: src.getSourcePosition(left) })
+      i++
+      left = i
+    }
+    if (flagStr || flagStr2) {
+      res.push({ text: str + endOfStr, sourcePosition: src.getSourcePosition(left) })
+    }
+    return res
+  }
+}
+
+module.exports = NakoPrepare

package/src/nako_reserved_words.js

@@ -0,0 +1,35 @@
+/* eslint-disable quote-props */
+/**
+ * 予約語
+ */
+
+module.exports = {
+  '回': '回',
+  '回繰返': '回', // (#924)
+  '間': '間',
+  '間繰返': '間', // (#927)
+  '繰返': '繰り返す',
+  '反復': '反復',
+  '抜': '抜ける',
+  '続': '続ける',
+  '戻': '戻る',
+  '先': '先に',
+  '次': '次に',
+  '代入': '代入',
+  '実行速度優先': '実行速度優先',
+  'パフォーマンスモニタ適用': 'パフォーマンスモニタ適用', // (#986)
+  '定': '定める',
+  '逐次実行': '逐次実行',
+  '条件分岐': '条件分岐',
+  '変数': '変数',
+  '定数': '定数',
+  'エラー監視': 'エラー監視', // 例外処理:エラーならばと対
+  'エラー': 'エラー',
+  'それ': 'word',
+  'そう': 'word', // 「それ」のエイリアス
+  '関数': 'def_func', // 無名関数の定義用
+  'インデント構文': 'インデント構文', // https://nadesi.com/v3/doc/go.php?949
+  '非同期モード': '非同期モード', // (#637)
+  'モード設定': 'モード設定', // (#1020)
+  '取込': '取込'
+}