nadesiko3 3.7.20 → 3.7.22

package/core/src/nako_parser_message.mts

@@ -0,0 +1,105 @@
+/**
+ * 構文解析器のエラーメッセージを組み立てるモジュール
+ *
+ * NakoParser / NakoParserBase から分離した (#2364)。
+ * 構文木やトークンを日本語の説明文に変換するだけで、
+ * トークンのカーソルにも計算用スタックにも一切触れない。
+ * (実体は nako_parser_base.mts の nodeToStr と
+ *  nako_parser3.mts の makeStackBalanceReport だった)
+ */
+import { Ast, AstBlocks, AstOperator, AstConst, AstStrValue } from './nako_ast.mjs'
+import { Token } from './nako_token.mjs'
+import { FuncArgs, FuncListItem } from './nako_types.mjs'
+
+/**
+ * 構文木やトークンを日本語の説明文にする
+ * @param node 説明したいノード
+ * @param opts depth: 展開する深さ / typeName: 先頭の型名を上書きする場合に指定
+ * @param debugMode true ならノードの JSON も埋め込む
+ */
+export function nodeToStr (node: Ast|Token|null, opts: {depth: number, typeName?: string}, debugMode: boolean): string {
+  const depth = opts.depth - 1
+  const typeName = (name: string) => (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) {
+      const subNode: Ast = (node as AstBlocks).blocks[0]
+      return `${typeName('')}『${nodeToStr(subNode, { depth }, debugMode)}に演算子『not』を適用した式${debug}』`
+    } else {
+      return `${typeName('演算子')}『not』`
+    }
+  case 'op': {
+    const node2: AstOperator = node as AstOperator
+    let operator: string = node2.operator || ''
+    const table:{[key: string]: string} = { eq: '＝', not: '!', gt: '>', lt: '<', and: 'かつ', or: 'または' }
+    if (operator in table) {
+      operator = table[operator]
+    }
+    if (depth >= 0) {
+      const left: string = nodeToStr(node2.blocks[0], { depth }, debugMode)
+      const right: string = nodeToStr(node2.blocks[1], { depth }, debugMode)
+      if (node2.operator === 'eq') {
+        return `${typeName('')}『${left}と${right}が等しいかどうかの比較${debug}』`
+      }
+      return `${typeName('')}『${left}と${right}に演算子『${operator}』を適用した式${debug}』`
+    } else {
+      return `${typeName('演算子')}『${operator}${debug}』`
+    }
+  }
+  case 'number':
+    return `${typeName('数値')}${(node as AstConst).value}`
+  case 'bigint':
+    return `${typeName('巨大整数')}${(node as AstConst).value}`
+  case 'string':
+    return `${typeName('文字列')}『${(node as AstConst).value}${debug}』`
+  case 'word':
+    return `${typeName('単語')}『${(node as AstStrValue).value}${debug}』`
+  case 'func':
+    return `${typeName('関数')}『${node.name || (node as AstStrValue).value}${debug}』`
+  case 'eol':
+    return '行の末尾'
+  case 'eof':
+    return 'ファイルの末尾'
+  default: {
+    let name: any = (node as any).name
+    if (name && typeof name !== 'string') { name = (node as any).value }
+    if (typeof name !== 'string') { name = node.type }
+    return `${typeName('')}『${name}${debug}』`
+  }
+  }
+}
+
+/**
+ * 計算用スタックに余りが出たときのレポートを作る
+ * @param stack 余ってしまった計算用スタックの中身
+ * @param recentlyCalledFunc 最近呼び出した関数(使い方の候補を示すのに使う #1093)
+ */
+export function makeStackBalanceReport (stack: Ast[], recentlyCalledFunc: FuncListItem[]): string {
+  const words: string[] = []
+  stack.forEach((t) => {
+    let w = nodeToStr(t, { depth: 1 }, false)
+    if (t.josi) { w += t.josi }
+    words.push(w)
+  })
+  const desc = words.join(',')
+  // 最近使った関数の使い方レポートを作る #1093
+  let descFunc = ''
+  const chA = 'A'.charCodeAt(0)
+  for (const f of recentlyCalledFunc) {
+    descFunc += ' - '
+    let no = 0
+    const josiA: FuncArgs | undefined = (f).josi
+    if (josiA) {
+      for (const arg of josiA) {
+        const ch = String.fromCharCode(chA + no)
+        descFunc += ch
+        if (arg.length === 1) { descFunc += arg[0] } else { descFunc += `(${arg.join('|')})` }
+        no++
+      }
+    }
+    descFunc += String(f.name) + '\n'
+  }
+  return `未解決の単語があります: [${desc}]\n次の命令の可能性があります:\n${descFunc}`
+}

package/core/src/nako_parser_operator.mts

@@ -0,0 +1,93 @@
+/**
+ * なでしこの計算式を演算子の優先順位に従って構文木へ変換するモジュール
+ *
+ * NakoParser から分離した (#2364)。
+ * 中置記法のリスト(値と演算子が交互に並んだもの)を、逆ポーランド記法を経由して
+ * `op` ノードの木に組み立てる。
+ *
+ * このモジュールはトークンのカーソルにも計算用スタックにも一切触れないため、
+ * 構文解析器の相互再帰から完全に独立している。
+ * (実体は nako_parser3.mts の NakoParser.infixToPolish / infixToAST だった)
+ */
+import { opPriority } from './nako_parser_const.mjs'
+import { NakoSyntaxError } from './nako_errors.mjs'
+import { NakoLogger } from './nako_logger.mjs'
+import { Ast, AstOperator } from './nako_ast.mjs'
+
+/**
+ * 中置記法のリストを逆ポーランド記法に変換する
+ * @param list 値と演算子が交互に並んだリスト(破壊的に消費される)
+ * @param logger エラー報告用
+ */
+export function infixToPolish (list: Ast[], logger: NakoLogger): Ast[] {
+  // 中間記法から逆ポーランドに変換
+  const priority = (t: Ast) => {
+    if (opPriority[t.type]) { return opPriority[t.type] }
+    return 10
+  }
+  const stack: Ast[] = []
+  const polish: Ast[] = []
+  while (list.length > 0) {
+    const t = list.shift()
+    if (!t) { break }
+    while (stack.length > 0) { // 優先順位を見て移動する
+      const sTop = stack[stack.length - 1]
+      if (priority(t) > priority(sTop)) { break }
+      const tpop = stack.pop()
+      if (!tpop) {
+        logger.error('計算式に間違いがあります。', t)
+        break
+      }
+      polish.push(tpop)
+    }
+    stack.push(t)
+  }
+  // 残った要素を積み替える
+  while (stack.length > 0) {
+    const t = stack.pop()
+    if (t) { polish.push(t) }
+  }
+  return polish
+}
+
+/**
+ * 中置記法のリストを構文木(op ノードの入れ子)に変換する
+ * @param list 値と演算子が交互に並んだリスト
+ * @param logger エラー報告用
+ */
+export function infixToAST (list: Ast[], logger: NakoLogger): Ast | null {
+  if (list.length === 0) { return null }
+  // 逆ポーランドを構文木に
+  const josi = list[list.length - 1].josi
+  const node = list[list.length - 1]
+  const polish = infixToPolish(list, logger)
+  const stack: Ast[] = []
+  for (const t of polish) {
+    if (!opPriority[t.type]) { // 演算子ではない
+      stack.push(t)
+      continue
+    }
+    const b:Ast|undefined = stack.pop()
+    const a:Ast|undefined = stack.pop()
+    if (a === undefined || b === undefined) {
+      logger.debug('--- 計算式(逆ポーランド) ---\n' + JSON.stringify(polish))
+      throw NakoSyntaxError.fromNode('計算式でエラー', node)
+    }
+    /** @type {AstOperator} */
+    const op: AstOperator = {
+      type: 'op',
+      operator: t.type,
+      blocks: [a, b],
+      josi,
+      startOffset: a.startOffset,
+      endOffset: a.endOffset,
+      line: a.line,
+      column: a.column,
+      file: a.file
+    }
+    stack.push(op)
+  }
+  const ans = stack.pop()
+  if (!ans) { return null }
+  return ans
+}

package/core/src/nako_plugin_manager.mts

@@ -0,0 +1,260 @@
+// deno-lint-ignore-file no-explicit-any
+/**
+ * なでしこ3 のプラグイン管理
+ *
+ * NakoCompiler からプラグイン登録処理を分離したモジュール (#2360)
+ * 循環参照を避けるため、このモジュールは nako3.mts を参照せず、
+ * 必要な機能は NakoPluginHost インターフェイス経由で受け取る。
+ */
+import { FuncArgs, FuncList, FuncListItem, NakoVars } from './nako_types.mjs'
+import { NakoLogger } from './nako_logger.mjs'
+
+const cloneAsJSON = (x: any): any => JSON.parse(JSON.stringify(x))
+
+/** プラグインが要求するランタイムの最低バージョン (= minor * 100 + patch) */
+export const PLUGIN_MIN_VERSION_INT = 600
+
+/** プラグインのメタ情報 */
+export interface NakoPluginMeta {
+  pluginName: string;
+  nakoVersionResult?: boolean;
+  nakoVersion: string;
+  path?: string;
+}
+
+/**
+ * NakoPluginManager がホスト(NakoCompiler)に要求する最小限の機能
+ */
+export interface NakoPluginHost {
+  /** プラグインで定義された関数 + ユーザーが定義した関数。reset() で差し替わるため都度取得する */
+  getFuncList (): FuncList;
+  /** システム領域の変数 (= __varslist[0]) */
+  getSysVars (): NakoVars;
+  getLogger (): NakoLogger;
+}
+
+/**
+ * プラグインの登録と、プラグインが定義した関数・変数・定数の管理を行うクラス
+ */
+export class NakoPluginManager {
+  /** プラグインで定義された関数 (reset() でユーザー定義関数を消すときに使う) */
+  readonly pluginFunclist: Record<string, FuncListItem>
+  /** 取り込んだファイル一覧 */
+  readonly pluginfiles: Record<string, any>
+  /** プラグインで定義された定数・変数・関数の名前 */
+  readonly commandlist: Set<string>
+  /** requireなどで取り込んだモジュールの一覧 (NakoCompiler.__module と同一オブジェクト) */
+  readonly modules: Record<string, Record<string, FuncListItem>>
+  private host: NakoPluginHost
+
+  constructor (host: NakoPluginHost) {
+    this.host = host
+    this.pluginFunclist = {}
+    this.pluginfiles = {}
+    this.commandlist = new Set()
+    this.modules = {}
+  }
+
+  /**
+   * プラグイン・オブジェクトを追加
+   * @param po プラグイン・オブジェクト
+   * @param persistent falseのとき、次以降の実行では使えない
+   * @param fpath ファイルパス
+   */
+  addPlugin (po: {[key: string]: any}, persistent = true, fpath = ''): void {
+    // __v0を取得
+    const __v0 = this.host.getSysVars()
+    // プラグインのメタ情報をチェック (#1034) (#1647)
+    let __pluginInfo = __v0.get('__pluginInfo')
+    if (!__pluginInfo) {
+      __pluginInfo = {}
+      __v0.set('__pluginInfo', __pluginInfo)
+    }
+    // メタ情報を読み取る
+    const meta = this.readPluginMeta(po, fpath)
+    let pluginName = meta.pluginName
+    const metaValue = meta.metaValue
+    // プラグイン名の重複を確認
+    if (__pluginInfo[pluginName] !== undefined) {
+      // プラグイン名が重複した場合はプラグインとして登録しない
+      return
+    }
+    pluginName = NakoPluginManager.removeInvalidFilenameChars(pluginName)
+    // プラグイン情報を記録
+    __pluginInfo[pluginName] = metaValue
+    // バージョンチェック
+    pluginName = this.checkPluginVersion(pluginName, meta.intVersion, po, metaValue)
+    // 初期化とクリアを変換する
+    this.modules[pluginName] = po
+    this.pluginfiles[pluginName] = '*'
+    // `初期化`と`クリア`をチェック
+    if (typeof (po['初期化']) === 'object') {
+      const def = po['初期化']
+      delete po['初期化']
+      const initKey = `!${pluginName}:初期化`
+      po[initKey] = def
+    }
+    // プラグインの値を、なでしこシステム変数(Map)にコピー
+    this.registerPluginEntries(po, persistent, __v0)
+  }
+
+  /**
+   * プラグインのメタ情報を読み取る
+   * @param po プラグイン・オブジェクト
+   * @param fpath ファイルパス
+   */
+  private readPluginMeta (po: {[key: string]: any}, fpath: string): { pluginName: string, intVersion: number, metaValue: NakoPluginMeta } {
+    let intVersion = 0
+    let pluginName = 'unknown'
+    let metaValue: NakoPluginMeta = { pluginName: 'unknown', nakoVersionResult: true, nakoVersion: '0.0.0', path: '' }
+    if (po.meta) {
+      if (po.meta.value && typeof (po.meta) === 'object') {
+        const meta = po.meta
+        metaValue = meta.value || { pluginName: 'unknown', nakoVersion: '0.0.0' }
+        pluginName = metaValue.pluginName || 'unknown'
+        // version check
+        const nakoVersion = (metaValue.nakoVersion || '0.0.0') + '.0.0'
+        const versions = nakoVersion.split('.').map((v) => parseInt(v))
+        intVersion = versions[1] * 100 + versions[2]
+        // fpath
+        metaValue.path = fpath
+      }
+    }
+    // unknown の場合は、関数名からプラグイン名を自動生成する
+    if (pluginName === 'unknown') {
+      pluginName = Object.keys(po).join('-')
+    }
+    return { pluginName, intVersion, metaValue }
+  }
+
+  /**
+   * プラグインが要求するランタイムのバージョンを確認する
+   * @returns プラグイン名 (古い形式で名前が不明な場合は関数名から生成した名前)
+   */
+  private checkPluginVersion (pluginName: string, intVersion: number, po: {[key: string]: any}, metaValue: NakoPluginMeta): string {
+    if (PLUGIN_MIN_VERSION_INT <= intVersion) { return pluginName }
+    const keyStr: string = Object.keys(po).join(',')
+    if (pluginName === 'unknown') {
+      pluginName = keyStr.substring(0, 30) + '...'
+    }
+    if (pluginName !== '') {
+      const errMsg = `なでしこプラグイン『${pluginName}』は古い形式なので正しく動作しない可能性があります。` +
+        `(ランタイムの要求: ${PLUGIN_MIN_VERSION_INT}/プラグイン: ${intVersion})`
+      console.warn(errMsg, 'see', 'https://github.com/kujirahand/nadesiko3/issues/1647')
+      this.host.getLogger().warn(errMsg)
+      metaValue.nakoVersionResult = false
+    }
+    return pluginName
+  }
+
+  /**
+   * プラグインの値を、なでしこシステム変数(Map)にコピーする
+   * @param po プラグイン・オブジェクト
+   * @param persistent falseのとき、次以降の実行では使えない
+   * @param __v0 システム領域の変数
+   */
+  private registerPluginEntries (po: {[key: string]: any}, persistent: boolean, __v0: NakoVars): void {
+    const funclist = this.host.getFuncList()
+    for (const key in po) {
+      const v = po[key]
+      funclist.set(key, v)
+      if (persistent) {
+        this.pluginFunclist[key] = cloneAsJSON(v)
+      }
+      if (v.type === 'func') {
+        __v0.set(key, v.fn)
+        if (v.asyncFn) { // asyncFn を正しく実行するために pure に変更する (core#142)
+          v.pure = true
+        }
+      } else if (v.type === 'const' || v.type === 'var') {
+        // メタ情報としての const | var は現在利用していない
+        // meta[key] = { readonly: v.type === 'const' }
+        __v0.set(key, v.value)
+      } else {
+        console.error('[プラグイン追加エラー]', v)
+        throw new Error('プラグインの追加でエラー。')
+      }
+      // コマンドを登録するか?
+      if (key === '初期化' || key.substring(0, 1) === '!') { // 登録しない関数名
+        continue
+      }
+      this.commandlist.add(key)
+    }
+  }
+
+  /**
+   * Windowsのパスやファイル名に使えない文字列があると、JSファイル書き出しでエラーになるので置換する
+   */
+  static removeInvalidFilenameChars (str: string): string {
+    return str.replace(/[^A-Za-z0-9\-_\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\u3400-\u4DBF\uF900-\uFAFF]/g, '_')
+  }
+
+  /**
+   * プラグイン・オブジェクトを追加(ブラウザ向け)
+   * @param objName オブジェクト名 (今後プラグイン名は、meta.value.pluginNameに指定する)
+   * @param po 関数リスト
+   * @param persistent falseのとき、次以降の実行では使えない
+   */
+  addPluginObject (objName: string, po: {[key: string]: any}, persistent = true): void {
+    // metaプロパティがなければ互換性のため適当に追加
+    if (po.meta === undefined) {
+      po.meta = { type: 'const', value: { pluginName: objName, nakoVersion: '0.0.0' } }
+    }
+    this.addPlugin(po, persistent)
+  }
+
+  /**
+   * プラグイン・ファイルを追加(Node.js向け)
+   * @param fpath ファイルパス
+   * @param po 登録するオブジェクト
+   * @param persistent falseのとき、次以降の実行では使えない
+   */
+  addPluginFromFile (fpath: string, po: { [key: string]: any }, persistent = true): void {
+    this.addPlugin(po, persistent, fpath)
+  }
+
+  /**
+   * 関数を追加する
+   * @param key 関数名
+   * @param josi 助詞
+   * @param fn 関数
+   * @param returnNone 値を返す関数の場合はfalseを指定
+   * @param asyncFn Promiseを返す関数かを指定
+   */
+  addFunc (key: string, josi: FuncArgs, fn: any, returnNone = true, asyncFn = false): void {
+    const funcObj: FuncListItem = { josi, fn, type: 'func', return_none: returnNone, asyncFn, pure: true }
+    this.host.getFuncList().set(key, funcObj)
+    this.pluginFunclist[key] = cloneAsJSON(funcObj)
+    this.host.getSysVars().set(key, fn)
+  }
+
+  /**
+   * プラグイン関数を参照する
+   * @param key プラグイン関数の関数名
+   * @returns プラグイン・オブジェクト
+   */
+  getFunc (key: string): FuncListItem|undefined {
+    return this.host.getFuncList().get(key)
+  }
+
+  /** プラグインで定義された定数・変数・関数の名前かどうかを返す */
+  hasCommand (name: string): boolean {
+    return this.commandlist.has(name)
+  }
+
+  /**
+   * プラグイン由来の命令だけを含む関数一覧を新規に作る (reset() 用)
+   * @param sysVars システム領域の変数 (= __varslist[0])
+   */
+  createFuncListFromPlugins (sysVars: NakoVars): FuncList {
+    const funclist: FuncList = new Map()
+    for (const name of sysVars.keys()) {
+      const original = this.pluginFunclist[name] // record
+      if (!original) {
+        continue
+      }
+      funclist.set(name, cloneAsJSON(original))
+    }
+    return funclist
+  }
+}