変奏現実

パソコンやMMORPGのことなどを思いつくまま・・・記載されている会社名・製品名・システム名などは、各社の商標、または登録商標です。

この画面は、簡易表示です

javascript

[javascript]spreadSheet5 ネームスペース

自前コードなので、関数やクラスをネームスペースにバラ巻いていた。

ただ、このままでは、再利用する度に、困りそうなので、カスタムタグのソースのクラスなどをMYAPPに纏めてみた。

まず、ネームスペースをまとめる関数を追加。※ネットで見つけたコードを少し改良したもの

/**
 *  MYAPP   グローバルオブジェクトのアプリ名
 */
const MYAPP = {};   //  初期設定

/**
 *  指定ネームスペースを作成する
 * @param {string} pNameSpace       作成するネームスペース・パス
 * @param {undefined | JSON} pJson  追記する内容 undefined または JSON
 * @param {boolean} pFreeze         変更不可指定
 */
MYAPP.namespace = (pNameSpace, pJson = undefined, pFreeze = false) => {
    /**
     * 再帰的にオブジェクトを凍結する
     * @param {object} obj  凍結するオブジェクト
     */
    const freezeR = (obj) => {
        if (typeof obj === 'object') {
            // オブジェクトの配下を再帰的に凍結
            for (const key of Object.keys(obj)) {
                freezeR(obj[key]);
            }
            // オブジェクト自体を凍結
            Object.freeze(obj);
        }
    };
    // ネームスペースのテキストを .で区切った配列を作成する。※先頭がMYAPPなら削除する
    const aNameSpace = pNameSpace.split('.').filter((element, index) => index !== 0 || element !== 'MYAPP');
    //  現在のパスをMYAPPへ移動する
    let curPath = MYAPP;
    //  パス最後の要素の有無で処理が分岐する為、配列から最後の要素を分離する。※constでもpopはオブジェクトを差替(代入)えないのでOK(らしい
    const lastElement = aNameSpace.pop();
    //  配列の順にネームスペースの有無をチェックする
    for (const part of aNameSpace) {
        // パスが存在しなければ作成し、パス位置を現在位置へ移動する
        curPath = curPath[part] = curPath[part] ?? {};
    }
    // パス最後の要素が未設定なら空リストを代入
    if (curPath[lastElement]) {
        // pJsonをマージする
        Object.assign(curPath[lastElement], pJson ?? {});
    } else {
        // pJsonに差替える
        curPath[lastElement] = pJson ?? {};
    }
    //  編集不可指定ありの場合
    if (pFreeze) {
        //  作成したネームスペースを再帰的に凍結します
        if (!pJson) {
            freezeR(curPath[lastElement]);
        } else {
            //  JSON配下のオブジェクトを再帰的に凍結します
            for (const key of Object.keys(pJson)) {
                freezeR(curPath[lastElement][key]);
            }
        }
    }
};

aNameSpaceからそのままfor (const part of aNameSpace)を回すと、curPathが最後まで移動し、pJsonをネームスペースに追加しようとすると、

 curPath = pJson ?? {} ;                            // MYAPPの方は書き換わらない

となってしまい、MYAPPの方は書き換わらないので、最終の一歩手前でcurPathを止めて、

curPath[lastElement] = pJson ?? {};                 // curPath[lastElement]はMYAPPの一部なのでOK

としたかったので、aNameSpaceから最後の要素を切り取った。

また、Object.assignの第一パラメータの中身がundefinedの場合は、エラってしまうので、

try {
  let obj = undefined;
  Object.assign(obj, pJson ?? {}); 
} catch(ex) {
  debug.print('Fail. '+ex);
}

⇒ Fail. Uncaught TypeError TypeError: Cannot convert undefined or null to object

undefined判定で空リストに変えてマージ。

    if (!curPath[lastElement]) {
        curPath[lastElement] = {};                      // 空リストにする
    }
    Object.assign(curPath[lastElement], pJson ?? {});   // マージする

さすがに

Object.assign(curPath[lastElement]??{}, pJson);   // マージする

は無理。

また、参照先が同じJSONにある場合は未確定な状態になりやすいので、MYAPP.namespaceの呼び出しを参照元と参照先で分けるのも面倒なので、第一パラメータで非参照先のネームパスを作成した方が楽。

これで完了と思ったら( ^ω^)・・・

MYAPP.namespace('aaa.bbb.ccc',
   (p1, p2, p3) => {
     ...
   }
);

aaa.bbb.ccc(1,2,3);

Uncaught TypeError TypeError: aaa.bbb.ccc is not a function

Object.assignは関数をプロパティっぽく書き込み、参照時に未定義な関数のエラーになるので、

    // パス最後の要素が未設定なら空リストを代入
    if (curPath[lastElement]) {
        // pJsonをマージする
        Object.assign(curPath[lastElement], pJson ?? {});
    } else {
        // pJsonに差替える
        curPath[lastElement] = pJson ?? {};
    }

で落ち着いた。

※まずpJsonがJSONかどうか判定した後の処理にした方が意図が読み取りやすいけど、深く意味を読み取ると無駄だと判るコードになる。

元ネタでは、

/**
 * スプレッドシートクラス
 * @class MYAPP.spreadSheet.SpreadSheetCustomElement
 */
MYAPP.namespace('spreadSheet.SpreadSheetCustomElement'),
MYAPP.spreadSheet.SpreadSheetCustomElement = class extends HTMLElement {
    ...
};

と、ネームスペースを作成し、作成したネームスペースにクラス等を設定する感じになっていた。

これを実際に動かしてみると、クラスの#変数がエラるw(パラメータがクラス宣言部なせいだろう)し、ネームスペースの文字も2度書いてるw(被ってるのは嫌い)なので、ネームスペースはファイルのパスまでとし、クラス名等はJSON形式でキー指定した方に変更して、クラスの定義は、こんな感じになった。

/**
 * スプレッドシートクラス
 * @class MYAPP.spreadSheet.SpreadSheetCustomElement
 */
MYAPP.namespace('spreadSheet', {
  'SpreadSheetCustomElement': class extends HTMLElement {
    ...
  }
});

ゴチャ付いてないから見やすくなった。(と思う

クラスを使用する場合はグローバルにクラスを宣言してないので、フルパス名で指定する。

_spreadSheet._command = new MYAPP.spreadSheet.SpreadSheetCommand(this);

関数も同様で、無名関数「function(…) { } 」でもいい。

MYAPP.namespace('lib', {
  'createHtmlElement': (elementName, options) => {
    ...
    },
});

使う時はフルパス名で指定する。

_layout.divTableN = MYAPP.lib.createHtmlElement('div', ... );

オブジェクトのプロパティはObject.freeze(object)で変更不可にできる。

メソッド名プロパティの追加プロパティの削除プロパティの値の変更
Object.preventExtensions()
Object.seal()
Object.freeze()

Object.freeze(object)以外は値の変更ができるので今回は対象外。

MYAPP.namespace('lib', {
  'char': {
    BR:'<br/>',
    CR: '\n',
    TAB: '\t',
    },
},true);             // 変更不可を指示

関数やクラスの外では意図的にstrictモードにしないとエラー(TypeError)が起きない。

ちなみに

"use strict";    // strictモード全開!

//  const 変数
MYAPP.namespace('lib', {
    'char': {
        BR: '<br/>',
        CR: '\n',
        TAB: '\t',
    },
}, true);
MYAPP.lib.char.BR = 'aaaaa'; ☚ここでType Error

Uncaught TypeError TypeError: Cannot assign to read only property 'BR' of object '#<Object>'

修正した結果

デバッグして止めて、スクリプト・スコープの内容を見ると、修正が漏れ過ぎ( ´∀` )

やっとのことでMYAPPにまとまった。

ネームスペースはすっきりした。

しかし、こんなコードを見た試しが無い。(大笑

パス名が付くのでコードが長くなる上、VSCodeの自動でコメントを生成するプラグインが怪しい動きをする可能性があるが、このクラス、変数はどこ?と探すのは楽かもしれない。

ps.2024/10/8

アップロード処理でvalueの無いセルデータでエラっていたので修正



[javascript]spreadSheet5

長らく放置していたセル幅高編集機能をspreadSheet5として実装した。

spreadSheet4はさっぱり進んでいないマクロ機能の実装用に残した。

操作方法:セルの境界線上にマウスポインタを乗せるとカーソルがリサイズっぽく変わりドラッグするとドットラインも表示するので好みの位置でリリースし確定する。

データ保持:セル幅やセル高を変えるとindex.html内のspread-sheetタグのdatabasename属性で指定したデータベースのcellテーブルに列ヘッダー(r0cNNN)または行ヘッダー(rNNNc0)のセルに変更内容(style:{width:’NNNpx’あるいはheight:’NNNpx’})が保持される。

確認方法:変更内容はCtrl+Sでデータをダウンロードすることを確認でき、更に変更を加えspreadSheet上にドロップすることで結果を確認できる。

永続性:再表示(F5)時も変更内容を参照し画面に反映される。

TODO1:セルのHTMLエレメントを作成する部分が初期のセル幅やセル高を前提に作ってるので、セルを初期より狭くするとセルがうまく表示されない。カーソルキーでセル移動すると補正されるケースがある。実装を見直し中。

TODO2:セル内テキストがセル幅を越える場合は…付きの表示になるが、セル高を複数行分まで広げてもセル内テキストは改行しない。canvas.measureTextを使って適切な行数を計測できそうだけど、複数行表示で自動的に省略文字(…)を書きたい場合に困り、思案中。

TODO3:初期のセル幅やセル高に戻すUIは無いので下限値が16pxになっているが、r0c{セル位置}、r{行位置}c0のデータを削除することで初期に戻すことは可能だから、コンテキストメニュー実装時に考慮。

TODO4:セル境界線上でダブルクリックすると、良い感じのセル幅に変更するUIも実装したいが、まずタグにテキストを埋め込んで実測すると遅いのは明白で、canvasで描画して調べるしかなさそうだ。

const context = document.getElementById("canvas").getContext("2d");
/* 以下必要な分繰り返す*/
context.font = "48px serif";  /* な感じでセルのテキスト属性を指定 */
const text = '適当なテキスト'; /* な感じでセルのテキストを指定 */
const textMetrics = context.measureText(text);
let width = textMetrics.width;
let height = textMetrics.height;

これを画面で見える範囲で繰り返すなら処理時間も短かくて済そう。

しかし、測定値を保持するとページスクロールとダブルクリックを最終セルまで繰り返さないとドコかで不都合な場合もありそうなので、’best-value’:「適切な測定値」とかで保持するといいかな?とか思案中。

TODO5:ドラッグ中の値を表示してない。

TODO6:ドットラインの初期位置が現在のセル幅の位置ではなくカーソルの位置になっている。FIX9/30

予想通り色々と問題が発覚しすぎ。ここまで尾を引くなら、セル描画はcanvasに任せた方が良いかも。HitTestの実装もセル単位で判れば良いし。

ps.2024/9/30 ラバーバンドの位置を調整。横スクロールのY軸調整がうまくいかないので外す。セルサイズの小数部を切り捨て(52.3px⇒52px)。画面構成の計算は単位がpxのみ対処。他単位を指定した場合は×。コードを見返してみると長いし複雑、もっと手短にしたい。

ps.2024/10/8

アップロード処理でvalueの無いセルデータでエラっていたので修正



[javascript]varとlet

再宣言の差異は

再宣言可なvarと再宣言不可のlet。

どっちがいいのか微妙だけど、外部変数の宣言の場合には・・・

概ね宣言が被る方が困るので、letにしておこう。

尚、スコープの差異は

ブロックスコープなletの方が関数スコープのvarより使いやすい。

結論、varは要らない。



[JavaScript]配列のkeyとvalueの両方を使う

const createHtmlElement = (elementName, options) => {
・・・
・・・
  const rc = Object.keys(options).map(
    (key) => (chkOriginal(key) || chkStyle(key) || chkEvent(key) || setAttribute(key)));
  );
}

と書くと、呼び出された各処理で

function chkOriginal(key) {
  const value = options[key];
  ...
}
function chkStyle(key) {
  const value = options[key];
  ...
}
function chkEvent(key) {
  const value = options[key];
  ...
}
function setAttribute(key) {
  const value = options[key];
  ...
}

と書いてたけど・・・

const createHtmlElement = (elementName, options) => {
・・・
const chkOriginal = (key,value) => {
  ...
}
const chkStyle = (key,value) => {
  ...
}
const chkEvent = (key,value) => {
  ...
}
const setAttribute = (key,value) => {
  ...
}

・・・
  const rc = Object.keys(options).map(
    const value = options[key];
    (key) => (chkOriginal(key,value) || chkStyle(key,value) || chkEvent(key,value) || setAttribute(key,value)));
  );
}

としてみた。自分で書いたコードから、ローカル関数で元関数のパラメータを見ても特に支障は無いけど、functionを使わない書き方で統一できた。

MDNを見ると、mapでも第2パラメータ(thisArgs)が使えるみたいなので、

const rc = Object.keys(options).map(function (key) {
    const value = this[key];
    return chkOriginal(key, value) || chkStyle(key, value) || chkEvent(key, value) || setAttribute(key, value);
}, options);

としてみた。

本来はコールバックに特定のオブジェクトをthisとして引き渡したい場合に使うものだし、コールバックの中でoptionsを書きたくないと意地を張ったものの、optionsを2回書いてしまう事に変わりは無いので、無駄なthisArgsの使い方になってしまった。外部の変数を見てる怪しい部分も修正したら結果がコレ。

/**
 * HTMLエレメントを作成する
 * @param {string} elementName                              エレメント名
 * @param {{attributeName:,... eventName:,...}}} options    設定内容
 * @returns {HTMLElement}                                   作成したHTMLElement
 */
const createHtmlElement = (elementName, options) => {
    const fileName = 'js/lib/createHtmlElement.js';
    const funcName = 'createHtmlElement'; //debugLog(`${fileName}:${funcName}(elementName: ${elementName}, options)`);
    /**
     * 独自の処理が必要な場合
     * @param {} param      属性
     * @returns {boolean}   結果
     */
    const chkOriginal = (param) => {
        let rc = false;
        try {
            switch (param.name) {
                case 'className': // classNameはメソッドで、\x20で文字列を区切って複数の属性を指定できる
                case 'classList': // classListはメソッド
                    let v = param.value;
                    if (!Array.isArray(v)) { v = v.split('\x20'); }
                    param.element.classList.add(...v);  // 配列を展開してクラスリストに追加する
                    rc = true;
                    break;
                case 'innerHTML': // innerHTMLはメソッド扱い    ※未使用
                    param.element.innerHTML = param.value;
                    rc = true;
                    break;
                case 'innerText': // innerTextはメソッド扱い
                    param.element.innerText = param.value;
                    rc = true;
                    break;
                case 'parent':      // parentはメソッド
                    param.value.appendChild(param.element);
                    rc = true;
                    break;
                case 'appendChild': // appendChildはメソッド    ※未使用
                    param.element.appendChild(param.value);
                    rc = true;
                    break;
                case 'insertBefore':    // insertBeforeはメソッド   ※スクロール処理で座標の小さい方向へセルを作る際に使用
                    param.value.parentNode.insertBefore(param.element, param.value);
                    rc = true;
                    break;
            }   // end of switch
        } catch (ex) {
            debugLog(`${funcName}(elementName: ${elementName}) '${param.name}'属性の固有処理に失敗 '${ex}'`);
            rc = false;
        }
        return rc;
    };
    /**
     * スタイル属性の場合
     * @param {} param      属性
     * @returns {boolean}   結果
     */
    const chkStyle = (param) => {
        let rc;
        try {
            //  style-xxxxのキーの場合
            let styleChk = param.name.match(/^style_(.*)/);
            if (styleChk) {
                let styleName = styleChk[1];
                switch (styleName) {
                    case 'width':
                        param.element.style.width = param.value;
                        break;
                    case 'height':
                        param.element.style.height = param.value;
                        break;
                    default:
                        styleChk = null;
                        break;
                }   // end of switch
            }
            rc = styleChk !== null;
        } catch (ex) {
            debugLog(`${funcName}(elementName: ${elementName}) '${param.name}'スタイル属性に${param.value}を設定失敗 '${ex}'`);
            rc = false;
        }
        return rc;
    }
    /**
     * eventの場合
     * @param {} param      属性
     * @returns {boolean}   結果
     */
    const chkEvent = (param) => {
        let rc;
        try {
            const eventList = ['ended'];    // イベントリスト
            rc = eventList.includes(param.name);   // イベントリストに含まれているかどうか
            if (rc) {   // イベントリスナを登録する
                param.element.addEventListener(param.name, param.value);
            }
        } catch (ex) {
            debugLog(`${funcName}(elementName: ${elementName}) '${param.name}'イベントリスナの登録に失敗 '${ex}'`);
            rc = false;
        }
        return rc;
    }
    /**
     * HTMLエレメントに属性を追加する
     * @param {} param      属性
     * @returns {boolean}   結果
     */
    const setAttribute = (param) => {
        try {
            param.element.setAttribute(param.name, param.value);
            return true;
        } catch (ex) {
            debugLog(`${funcName}(elementName: ${elementName}) '${param.name}'属性に${param.value}を設定失敗 '${ex}'`);
            return false;
        }
    }
    let elm = document.createElement(elementName);
    //  optionsの設定名を取得しぶん回す!
    const rc = Object.keys(options).map(function (key) {
        const value = this[key];
        const param = { 'name': key, 'value': value, 'element': elm };
        return chkOriginal(param) || chkStyle(param) || chkEvent(param) || setAttribute(param);
    }, options)
        .filter(v => !v);   // trueならば削除する
    if (0 < rc.length) {
        debugLog(`${funcName}(elementName: ${elementName}) 未処理属性数:${rc.length}件`);
    }
    return elm;
}

数か月経つと

※未使用

と書かないと、「どこかで使っている(気がする」し、

※スクロール処理で座標の小さい方向へセルを作る際に使用

とか書いておかないと、「要らない(気がする」する、

なぜか、逆バイアスがかかってしまうのは・・・謎。

あ、使い方も忘れた。

こんな感じだった。

let a = createHtmlElement('a', {
    href: url,
    download: fileName,
    text: "re-download",
});

色々設定したいHTMLエレメントを作る時に

const div = createElement('div');
shadow.addChiled(div);
div.className = 'scroll';
div.id = `div${sn}`;
div.style.height = _spreadSheet.width;
div.style.width = _spreadSheet.height;
div.tabIndex =  `${sn}`;

を1行で書ける。更にそんなモノがいっぱいある場合には、

//  シャドールートを作成
_layout.shadowRoot = (!_layout.shadowRoot) ? _spreadSheet.customElement.attachShadow({ mode: "open" }) : _layout.shadowRoot;
const shadow = _layout.shadowRoot;
//  既存のHTMLElementを削除
Array.from(_layout.shadowRoot.children).forEach((ch) => ch.remove());
//  スタイルシート部
const style = _layout.createStyle(sn, _spreadSheet.rows, _spreadSheet.cols, true, true);
shadow.appendChild(style);
//  スプレッドシート部
_layout.divTableN = createHtmlElement('div', { parent: shadow, className: 'scroll', id: `div${sn}`, style_height: _spreadSheet.width, style_width: _spreadSheet.height, tabIndex: `${sn}`, });
_layout.tableN = await _layout.createTableElement(_layout.divTableN, 'spread-sheet', `table${sn}`);
_layout.divScrollX = createHtmlElement('div', { parent: _layout.divTableN, className: 'scroll-x', id: `divScrollX${sn}`, style_height: '17px', style_width: _spreadSheet.height, tabIndex: `${sn}`, });
_layout.divScrollY = createHtmlElement('div', { parent: _layout.divTableN, className: 'scroll-y', id: `divScrollY${sn}`, style_height: _spreadSheet.width, style_width: '17px', tabIndex: `${sn}`, });

と書け、すっきりする。

もっとも、インターネットの記事でそんなケースはまず有り得ないし、必要に応じてcreateHtmlElementの機能を増設していかないと「すっきり」しないので、仕事で作るソースにも使ったことはないね。

最初はcreateDivElementとかcreateAElementとかタグ毎に作っていたけど多すぎるので、createTableElementを除いて一本化した。

createTableElementみたいに複雑で同期を取る必要もあるモノは別物にするしかないが、コード全般の流れを単純化するとスッキリした。勿論、createTableElementの中のアチコチでcreateHtmlElementを呼び出している。

今見ると、イベント登録まで入れたのはやり過ぎ感があるなぁ。



[javascript]spreadSheet4 コードのオブジェクト化

テキストを構文解析したパースした結果のオブジェクトはindexedDBに保存してあるけど、オブジェクトをテキストに戻したり、計算させるコードはJavaScriptのままだったので、中途半端だった。

あまり複雑なコトは出来なくていいので、オブジェクトをstringifyしたりcalulateしたりexecuteできるオブジェクトを考えてparserオブジェクトストアに保存すればいいかな?

そう考えると、まず俺々EBNFパーサで試してみるのが良さそうだ。

  • パースするEBNFなテキストを用意する
  • parserオブジェクトストアから俺々EBNFパーサを読みだす
  • パース部分とパース結果を手直す部分に分離
  • パース部分からdefinitionっぽいパーサ・コンビネーションを作る
  • パース結果を手直す部分から実行コードを作る
  • parseメソッドに先のテキストを読ませる
  • 何かの構文解析パーサができる

な感じだろうか

とりあえずはmakeParserメソッドを「パースした結果のオブジェクト」っぽいオブジェクトに展開。

するところから始め、stringify、calculateも「パースした結果のオブジェクト」っぽいオブジェクトに展開してみよう。

多分、

{ function_definiton: { name: x..., procedure:[.....] } }
{ return: {expr:... } }
{ if:{expr:... }, then:{...}, else:{...} }
{ while:{expr }, procedure:[.....]},
  {continue:null},
  {break:null},
{ function:{name:x..., parameter:{... } } }
{ expr:[x..., '+', x..., ...] }
{ value:{ type;integer, value:1 } }
{ set:{ name:x... }, value:{ expr or value:.... } }
{ try:[...], catch:[...], finally:[...] }

とかになるんだろう。+-と/*演算子の優先度は{}のネストでカバーすればいいし。

{ export: x..., from y... }
{ import: x..., from y... }

も必要か、javascriptのコードの呼び出しは、事前に「{function_definiton」の内部に登録しておこう。

execObjectList.map((execObject) => {
  switch() {
    case 'function_definition':
        {
        }
    ....
  }
});

と、実行用オブジェクトを種類別に仕分けてコード化すれば何とかなるだろう。



「javascript」spreadSheet4 EBNFの「,」

やっとマクロ構文を組み込み始めたが・・・

デリミタではまった。

(*$ imports: expression="EXPR" $*)
(*$ SEQUENCE SEPARATOR IS REQUIRED $*)
(* マクロ *)
macro               = { ( class declaration | function declaration | variable declaration ) }, /\s*/ ;
class declaration   = "class", class name, "{", { member declaration | method declaration } "}" ;
class name          = identifier ;
comment             = "/*", /.*/, "*/" | "//", /.*/, "\n" ;
member declaration  = [ "const" | "static" ], member name, [ "=", expression], { ",", member name, [ "=", expression] } ";" ;
member name         = identifier ;
method declaration  = [ ? ebnf reference jdoc.document ? ], [ method name ], parameter list, procedure list ;
method name         = identifier ;
function declaration= [ ? ebnf reference jdoc.document ? ], [ function name ], parameter list, procedure list ;
function name       = identifier ;
parameter list      = "(", [ parameter name, [ "=", expression ], { ",", parameter name, [ "=", expression ] } ], ")" ;
parameter name      = identifier ;
procedure list      = "{", procedure, "}";
procedure           =    {
                         (
                         | variable declaration 
                         | assignment expression
                         | branch procedure
                         | iterative procedure
                         | exception procedure
                         )
                      } ;
variable declaration= [ "const" | "let" | "static" ], variable name, [ "=", expression], { ",", variable name, [ "=", expression] } ";" ;
variable name       = identifier ;
assignment expression= variable name, [ ".", member name ] "=" expression;
branch procedure    = if procedure | switch procedure ;
if procedure        = "if", "(", expression, ")", procedure list, { "else", if procedure } ;
switch procedure    = "switch", "{", { case procedure } "}" ;
case procedure      = ( "case", expression | "default" ), ":", { procedure }, [ "break" ] ;
iterative procedure = for procedure | while procedure | do while procedure ;
for procedure       = "for", "(", assignment expression, ",",  expression  ",",  assignment expression ")" ;
while procedure     = "while", "(", expression ")", procedure list ;
do while procedure  = "do", "(", expression ")", procedure list, "while", "(", expression ")" ;
exception procedure = "try", procedure list, "catch", "(", parameter name ")", procedure list, [ "finally", procedure list ]
                    |  "throw", expression ;
identifier          = { comment }, /[A-Za-z][A-Z_a-z]/, { comment } ;

どこが間違っているのかな?

(*$ import expr from "EXPR" $*)
(*$ SEQUENCE SEPARATOR IS REQUIRED $*)
(* マクロ *)
macro               = { class declaration | function declaration | variable declaration }, /\s*/ ;
class declaration   = "class", class name, "{", member declaration, { method declaration }, "}" ;
class name          = identifier ;
comment             = "/*", /.*/, "*/" | "//", /.*/, "\n" ;
member declaration  = [ "const" | "static" ], member name, [ "=", expression], { ",", member name, [ "=", expression] }, ";" ;
member name         = identifier ;
method declaration  = [ ? ebnf reference jdoc.document ? ], [ method name ], parameter list, procedure list ;
method name         = identifier ;
function declaration= [ ? ebnf reference jdoc.document ? ], [ function name ], parameter list, procedure list ;
function name       = identifier ;
parameter list      = "(", [ parameter name, [ "=", expression ], { ",", parameter name, [ "=", expression ] } ], ")" ;
parameter name      = identifier ;
procedure list      = "{", procedure, "}";
procedure           =    { variable declaration 
                         | assignment expression
                         | branch procedure
                         | iterative procedure
                         | exception procedure
                         } ;
variable declaration= [ "const" | "let" | "static" ], variable name, [ "=", expression], { ",", variable name, [ "=", expression] }, ";" ;
variable name       = identifier ;
assignment expression= variable name, [ ".", member name ],"=", expression;
branch procedure    = if procedure | switch procedure ;
if procedure        = "if", "(", expression, ")", procedure list, { "else", if procedure } ;
switch procedure    = "switch", "{", { case procedure }, "}" ;
case procedure      = ( "case", expression | "default" ), ":", { procedure }, [ "break" ] ;
iterative procedure = for procedure | while procedure | do while procedure ;
for procedure       = "for", "(", assignment expression, ",", expression, ",", assignment expression, ")" ;
while procedure     = "while", "(", expression, ")", procedure list ;
do while procedure  = "do", "(", expression, ")", procedure list, "while", "(", expression, ")" ;
expression          = expr ;
exception procedure = "try", procedure list, "catch", "(", parameter name, ")", procedure list, [ "finally", procedure list ]
                    |  "throw", expression ;
identifier          = { comment }, /[A-Za-z][A-Z_a-z]/, { comment } ;

違いが判るだろうか?

最初は [ … […] … ] なんて囲み文字のネストは考えて無かったw!とか慌てたけど、そんなことを気にする様な気難しい文法解析方法は今回実装していない。

正解は・・・

  • importが旧仕様
    • ☓ imports: expression=“EXPR”
    • 〇 import expr from “EXPR”
  • sequenceのデリミタ(カンマ)がところどころ抜けている
    • 「}」の後
      • { … } , “;”
        • 「}」の後にトークンがあるなら、カンマで区切る必要がある
    • 「”}”」や「”)”」の前
      • { … } の } の前にカンマは不要、 ( … ) なら ) の前にカンマは不要
      • “{” … “}” の “}” の前にカンマは必須、 “(” … “)” なら “)” の前にカンマは必須

いづれも独自の仕様と云えば独自なのかもしれないけどね。

ps.import の処理が間違っていたので修正。EbnfParserクラスのparseメソッドを実行すると、export、importの情報が履歴の様に残っていたので、parseメソッド内でクリアするように変えるのでシャローコピーを各パーサに引き渡す様にした。

ps.2024/4/25

マクロファイルのアップロード、パーサ、indexedDB処理までできた。後はパーサのMap処理と実行部。どうすればいいのかは・・・やってみないと判らない。(笑



[javascript]spreadSheet4 クラス継承の見直し

  • CoreParsser
    • Parser
      • EbnfParser
        • CellValueParser
        • CellExprParser
        • ExportParser
        • ImportParser

とクラス継承をしているのに同じ名前のメソッドが内容は互いに独立しているため、ローカルメソッド名を使ってしのいでいたが、ほぼローカルメソッド名になってしまったので・・・・

CellValueParser以下は継承せず、フィールドにEbnfParserを保持し、

this._ebnfParser.parse('xxxxxxxxxxxxx')

のように変更した。

  • CellValueParser
  • CellExprParser
  • ExportParser
  • ImportParser
  • CoreParsser
    • Parser
      • EbnfParser

これにより、微妙だった初期化の手順が

  • SpreadSheetクラスで、EbnfParserクラスオブジェクトを生成しEbnfパーサを保持
    • EbnfParserクラスで、ExportParserとImportParserクラスオブジェクトを生成しExportとImportパーサを保持
  • SpreadSheetクラスで、CellValueParserクラスオブジェクトを生成しCellの値パーサを保持
  • SpreadSheetクラスで、CellExprParserクラスオブジェクトを生成しCellの数式パーサを保持

と安定してきたし、EBNFテキストでパーサを生成するクラスが全て独立したので、セルフテストの重複が減った。しかしsuper()でパーサを作るのが難しくなり、makeParserとselfTestに関連する処理をsetup()に纏める必要が出てきたついでにテンプレを作り、

/**
 *  EBNF関連のパーサのテンプレ
 */
class EbnfParserTemplate {
    /**
     *  パーサクラスオブジェクト
     * @memberof EbnfParserTemplate
     */
    _parser = null;
    /**
     *  自前のパーサ
     * @memberof EbnfParserTemplate
     */
    myParser = null;
    /**
     *  クラス名
     * @memberof EbnfParser
     */
    #className = 'EbnfParserTemplate';
    className = this.constructor.name;
    /**
     *  コンストラクタ
     */
    constructor() {
        //  パーサクラスオブジェクトを生成する
        this._parser = new Parser();
    }
    /**
     *  パーサ初期設定
     * @param {SelfTestInfo} fSelfTest 
     */
    setup(fSelfTest = false) {
        //  自前のパーサを生成する
        console.log(`${this.className}.constructor: makeParser().`);
        this.myParser = this.makeParser();
        //  セルフテストする
        if (fSelfTest) {
            const bk = this.DEBUG;
            this.DEBUG = fSelfTest;
            const selfTestRessult = this.selfTestList(this.getSelfTestList(), this.myParser);
            this.DEBUG = bk;
        }
    }
    /**
     *  パーサ生成 
     * @returns 
     */
    makeParser() {
        const myParser = undefined;
        return myParser;
    }
    /**
     *  EBNFルールと文法を作成
     * @param {string} ebnf             BNFテキスト
     * @param {Function} syntax         パーサ
     * @param {Function} evalProcInfo   パースした結果の評価関数情報
     * @returns {EbnfParseMethodResult} パース結果
     */
    parse(ebnfText, parser = this.myParser, evalProcInfo) {
        //  パース結果
        const parseResult = new EbnfParseMethodResult(/*success, result, position, result.result, definitionList, evalProcInfo*/);
        return parseResult;
    }
    /**
     * テスト処理
     * @param {Array of strung} testPatternList 
     * @param {function} parser
     * @returns {Array of ParseResult}
     */
    selfTestList(testPatternList, parser) {
        const methodName = 'selfTestList';
        const info = this.DEBUG;
        const parseResultList = testPatternList.map((test, index, a) => {
            if (info) {
                console.log(`${this.className}.${methodName}: pattern[${index + 1}/${a.length}]`);
            }
            return this.selfTest(test, parser);
        });
        return parseResultList;
    }
    /**
     * テスト処理
     * @param {string} testPattern 
     * @param {function} parser
     * @returns {Array of ParseResult}
     */
    selfTest(testPattern, parser) {
        const parseResult = this.parse(testPattern, parser);
        return parseResult;
    }
    /**
     * テストデータ取得
     * @returns {array of object}   テストデータリスト
     */
    getSelfTestList() {
        return [];
    }
}

全般的にExport、Import、Ebnf、セル値、セル数式のパーサクラスを見直したら、ゴチャゴチャしていたコンストラクタがすっきりした。

class  xxxParser extends EbnfParserTemplate{
    ・・・
    /**
     *  コンストラクタ
     * @param {EbnfParser} ebnfParser
     */
    constructor(ebnfParser) {
        super();
        this._ebnfParser = ebnfParser;
        this.setup(new SelfTestInfo(true, false, false, false));
    }
    ・・・
}

今現在のクラス継承はこんな感じ

  • CoreParser
    • Parser
  • EbnfParserTemplate
    • _parser <- new Parser()
    • EbnfParser
      • _parserList <- new ExportParser()、new ImportParser()
    • ExportParser
      • _ebnfParser <- コンストラクタのebnfParserパラメータ
    • ImportParser
      • _ebnfParser <- コンストラクタのebnfParserパラメータ
    • CellValueParser
      • _ebnfParser <- コンストラクタのebnfParserパラメータ
    • CellExprParser
      • _ebnfParser <- コンストラクタのebnfParserパラメータ



[javascript]spreadSheet4 repeateパーサの見直し

何故かEBNFのrepeateパーサだけ ‘{‘, sequence, ‘}’になっていて、気になっていた。

//  repeate     =   "{" sequence "}" ;
const repeate = _lazy(() => {
    return _map('repeate',
        '{', sequence, '}'
        , (parsed) => {
            parsed = this.arrayFlat([], parsed);
            const lparen = parsed[0];
            const seq = parsed[1];
            const rparen = parsed[2];
            let rc = seq['#sequence'];
            return { '#repeate0': rc };
        });
});

他に合わせて'{‘, choice, ‘}’にするとエラってしまう。

仕方が無いから、パースの動きをずーっと追っていくと・・・・・・・・・・・・・・・・・・・・・

灯台元暗しで、このパーサで、return { ‘#repeate0’: undefined }になっていた。

原因は、seq[‘#sequence‘];

choiceは、{#choice: xxxx}と返すので、当然の結果。

うっかりミスを減らす様に修正。

//  repeate     =   "{" choice "}" ;
const repeate = _lazy(() => {
    return _map('repeate',
        '{', choice, '}'
        , (parsed) => {
            parsed = this.arrayFlat([], parsed);
            const choiceResult = parsed[1];
            //  同じ繰り返しなら省略
            if (choiceResult['#repeate0']) {
                return choiceResult;
            }
            return { '#repeate0': choiceResult };
        });
});

やっとこれで、

{ ( A | B | C) }

の様に助長的な書き方をしなくても、

{ A | B | C }

で済むようになったし、

choice = sequence, { '|', sequence } ;

なので、{ … } の中は choiceでもsequenceでもOK。

しかし、

  • 数式のrepeate ※まだ未実装
  • ENBFのrepeate ※今回の主役
  • パーサ・クラスのrepeate ※今回の悪役
  • コア・クラスのrepeate ※今回はモブ

と、repeateが多くて紛らわしい。

ENBFのrepeateの文法は、'{‘, choice, ‘}’ になって便利になった。

しかし、パーサ・クラスのrepeateのパラメータは、ebnfParserのmakeParserメソッド中でmapメソッドのパラメータの文法部分をsequenceっぽく書きたいので、sequenceにまとめて処理している。目的が違うから仕様も違うんだけど、後で見返すとちんぷんかんぷんになってしまう。

動作確認をしているとパースの結果の内部構造が倍くらいに長くなっていたので短くした。

{
"syntax": {
  "#syntax": {
    "#rule_list": [
      {
        "rule_list": {
          "#definition": {
            "#repeate1": {
              "#choice": [
                { "#identifier": "rule" },
                { "#identifier": "special_effect" },
                { "#identifier": "comment" }
]}}}}]}}


[javascript]spreadsheet4 EBNF imports,exports

一度にマクロまで拡張すると修正が多そうなので、一旦、数式と値にEBNFを分割し、数式のEBNFから値のEBNFの(非)終端記号を参照できる様な仕組み(imports,exports)を作ってみた。

(*$ SEQUENCE SEPARATOR IS NOT REQUIRED $*)
(*$ export {value_cell,time_stamp,date,number,boolean,sqstring as singleQuoteString,text} from "CELL_VALUE"  $*)
(* セルのデータ *)
value_cell          = time_stamp | date | time | number | boolean | sqstring | text ;
time_stamp          = date ' ' time ;
date                = yyyy '/' MM '/' dd  | MM '/' dd ;
yyyy                = /\\d{4}/ ;
MM                  = /\\d{1,2}/ ;
dd                  = /\\d{1,2}/ ;
time                = HH ':' mm ':' ss | HH ':' mm  ;
HH                  = /\\d{1,2}/ ;
mm                  = /\\d{1,2}/ ;
ss                  = /\\d{1,2}/ ;
number              = /[-]?([0-9]+)([.][0-9]*)?/ ;
boolean             = /true/i | /false/i ;
sqstring            = /'.*/ ;
text                = /.+/ ;
(*$ SEQUENCE SEPARATOR IS NOT REQUIRED $*)
(*$ export expr from "EXPR" $*)
(*$ import defaultExport from "CELL_VALUE" $*)
(* セルのデータ *)
cell                = expr_cell | value_cell ;
(* 数式 *)
expr_cell           = '=' expr ;
expr                = logical_expr ;
logical_expr        = add_sub_expr [ ( '=' | '>' | '<' | '>=' | '<=' | '<>' ) add_sub_expr ] ;
add_sub_expr        = mul_div_expr { ( '+' | '-' | '&' ) mul_div_expr } ;
mul_div_expr        = factor { ( '*' | '/' ) factor } ;
factor              = value | parenthesis_expr ;
parenthesis_expr    = '(' expr ')' ;
value               = number | boolean | function_def | a1_range | a1 | dqstring ;
a1_range            = a1 ':' a1 ;
a1                  = /([A-Za-z]+[1-9][0-9]*)/ ;
dqstring            = /"[^"]*"/ ;
function_def        = symbol '(' parameters ')' ;
symbol              = /([A-Za-z][A-Za-z0-9_]*)/ ;
parameters          = [ expr ] { ',' expr } ;

node.jsのimportを参考にこんな感じになっている。

名前付き import: (*$ import { export1, export2 } from "module-name" $*)
デフォルトの import: (*$ import defaultExport from "module-name" $*)

こうすることで、

(*$ export {value_cell,time_stamp,date,number,boolean,sqstring as singleQuoteString,text} from "CELL_VALUE" $*)

値EBNF側で、{非}終端記号をindexedDBに書き込むtype名でexportする様にすれば、

(*$ import defaultExport from "CELL_VALUE" $*)

importする側はdefaultExportだけで済む。

テキストをガリガリしないでEBNFなimportParserとexportParserクラスを追加し、なんとか最低限の文法(上の2つダケ)を実装した。

(*$ SEQUENCE SEPARATOR IS NOT REQUIRED $*)
(* EXPORT *)
exportSyntax        = "export" members "from" ebnf_export_name;
members             = member | "{" member { "," member } "}" ;
member              = symbol { "as" alias } ;
alias               = symbol;
ebnf_export_name    = dqstring;
dqstring            = /"[^"]*"/ ;
symbol              = /([A-Za-z][A-Za-z0-9_]*)/ ;
(*$ SEQUENCE SEPARATOR IS NOT REQUIRED $*)
(* IMPORT *)
importSyntax        = "import" ( defaultExport | members ) "from" ebnf_export_name ;
defaultExport       = "defaultExport" ;
members             = member | "{" member { "," member } "}" ;
member              = symbol { "as" alias } ;
alias               = symbol;
ebnf_export_name    = dqstring;
dqstring            = /"[^"]*"/ ;
symbol              = /([A-Za-z][A-Za-z0-9_]*)/ ;

これらのEBNFをパースする時点ではまだimportもexportも未登録状態なので、各自がexport処理し、ebnfParserのparseの中で直接importとexportをimportさせた。

当初はebnfParser.#parse内でEBNFテキスト中のexportを処理させたが、cell_valueやcell_exprのパーサのマップを反映する前にimportしてしまったので計算するデータが全て文字になっていたから、各クラスで#makeParser後にebnfParser.exportメソッドを呼びださせた。

後、できるだけ、return [……] や {……} を、return new xxxx(….) に書換え。

なんでもEBNF化すれば良い訳ではないけれど、これに限ってはトコトンEBNF化しないと・・・




top