変奏現実

regexp ::=  "/"  /.+/ "/" /[dgimsuvy]*/

const no_space_skip = function () {
    this.fSpaceSkip = false;
    return undefined;
}.bind(this);
・・・
//  wq_string   =   '"' /(?!\\\\)[^"]*/ '"' ;
const wq_string = _map(
    no_space_skip, '"', /(?!\\)[^"]*/, '"'
    , (parsed) => {
        parsed = parsed[1]
        return { _wq_string: `${parsed}` };
    });
・・・
sequence(...parsers) {
・・・
const func =
    (target, position) => {/*sequnce*/
        const bk = this.fSpaceSkip;　　☚空白読飛状態をバックアップ
・・・
        for(let i=0;i<parsers.length;i++) {
            parsers[i](target, position);　　☚この中でno_space_skipが空白読飛状態を変更
        }
・・・
        this.fSpaceSkip = bk;　　　　　☚空白読飛状態を復元
        return 
    }
・・・
    return func;
}

/**
 * スプレッドシートの数式クラス
 */
class SpreadSheetExprParser {
    /**
     *  コンストラクタ
     * @param {SpreadSheetCustomElement} spreadSheet 
     */
    constructor(spreadSheet) {
        const _exprParser = this;
        _exprParser.className = _exprParser.name ?? _exprParser.constructor.name;
        _exprParser._spreadSheet = spreadSheet;

        this.parseEBNF(undefined);  // self test
        this.parse('=1+2+3');       // expression setup　☚ここで仮データで数式のパーサを初期設定。
    }

/**
 *  数式を構文解析する
 * @param {string} text   数式
 */
parse(text) {
    const ebnf = `  (* セルのデータ *)
    cell                ::= expr_cell | value_cell ;
    ・・・数式のEBNFテキスト・・・
    `;
    if (this.exptEbnfAnalize === undefined) {
        this.exptEbnfAnalize = this.parseEBNF(ebnf);　☚　ここで、数式用EBNFテキストを読ませて解析させる。
        ・・・・以下、解析結果をDBに保存できるようにトークン化するコールバック一式を作成。
　　　　　※コンストラクタから呼び出された時にローカルなアロー関数は参照する変数をディープコピーしてるっぽい。
    }
    ・・・・
    //  数式の纏めパーサ
    const cell = this.exptEbnfAnalize.parser['cell'];　☚　ここで数式の文法のトップを調べ、
    var result = cell(target, 0);　☚　ここで数式を読ませ解析させる。この時点で新たなローカル変数が作られ、
                                      上記のローカルなアロー関数がアクセスするローカル変数とは別腹。
    if (!result.success) {
    ・・・・

(*$ SEQUENCE SEPARATOR IS REQUIRED $*)
(* 文法   *)
syntax      =   rule list, /\s*/ ;
rule list   =   { ( rule | special effect | comment ) } + ;
rule        =   identifier, defining symbol, definitions, ";" ;
defining symbol = "=" | "::=" ;                                     (* 終端記号 '=':EBNF, '::=':BNF *)
(* 定義   *)
definitions =   definition, { "|", definition } ;                   (* 定義リスト *)
definition  =   choice ;                                            (* 定義 *)
(* リスト *)
choice      =   sequence, { "|", sequence} ;                        (* アレかコレかソレかのどれか *)
sequence    =   exception, { ",", exception } ;                     (* アレとコレとソレの一式。","は空白改行と同義  *)
exception   =   words, { "-", words } ;                             (* アレが良いが、コレとソレを除く。 *)
(* 囲み   *)
words      =   [ comments ], word, [ comments ] ;
special effect =  (*$ NO SPACE SKIP $*) "(*$", /[^\\?]*/, "$*)" ;   (* 特殊効果 *)
comments    =   ( special effect | comment ), repeat symbol;
word        =   ( sq string | wq string | wraper | special text | regexp | identifier ) ;
comment     =   (*$ NO SPACE SKIP $*) "(*", /(?![*][/])(.*)/, "*)" ; (* 注意書き *)
sq string   =   (*$ NO SPACE SKIP $*) "'", /(?!\\\\)[^']*/, "'" ;   (* ' で括られたテキスト *)
wq string   =   (*$ NO SPACE SKIP $*) '"', /(?!\\\\)[^"]*/, '"' ;   (* " で括られたテキスト *)
wraper      =   ( group | option | repeate ), repeat symbol ;
group       =   "(", choice, ")" ;                                  (* choiceを明示的に括る表現 *)
option      =   "[", choice, "]" ;                                  (* あれば尚良し *)
repeate     =   "{", sequence, "}" ;                                (* 0回以上繰り返す *: 0回以上、+:１回以上 *)
regexp      =   /.+/i ;                                             (* 正規表現されたテキスト "/"  + /.+/ "/" + { /[dgimsuvy]/ } *)
identifier  =   /[A-Za-z][A-Z_a-z0-9\\x20]*/;                       (* 識別子 *)
special text =  (*$ NO SPACE SKIP $*) "?", /[^\\?]*/, "?" ;         (* 特殊文字列 *)
repeat symbol=  [ "*" | "+" | '{', [ number ], ',', [ number ], '}']; (* 繰返し記号 *)
number      =   /\d+/ ;

/**
  * 判定式の結果で処理を分岐するパーサを作成する
  * @param {Function} expr           判定式
  * @param {Function} trueParser     結果が真の場合に実行するパーサ
  * @param {Function} falseParser    結果が偽の場合実行するパーサ
  * @returns 
  */
 branch(expr, trueParser, falseParser) {
     const methodName = 'branch';
     trueParser = this.normalizeParses(trueParser);
     falseParser = this.normalizeParses(falseParser);
     this.chkFunction(methodName, "trueParser", trueParser);
     this.chkFunction(methodName, "falseParser", falseParser);
     const func =
         /**
          *  生成した処理を分岐するパーサ
          * @param {string} target       ソースコード
          * @param {integer} position    読取り位置
          * @return {ParseInfo}          パースした結果
          */
         (target, position) => {/*branch*/
             if (expr()) {
                 return trueParser(target, position);
             } else {
                 return falseParser(target, position);
             }
         }
     return func;
 }

const identifier = _map(
    _branch(() => { return this.sequnceSeparator }, /[A-Za-z][-A-Z_a-z0-9\x20]*/, /[A-Za-z][-A-Z_a-z0-9]*/)
    , (parsed) => {
        parsed = parsed.trim();
        parsed = parsed.replaceAll(/\x20{2,}/g, '\x20');   //空白が並んでいた場合は１つにまとめる
        return { '#identifier': parsed };
    });

const sequnce = _map(
    wraper, _repeate(_branch(() => { return this.sequnceSeparator }, ",", _option(",")), wraper, 0)
    , (parsed) => {
        const methodName = "sequnceのfn";
            ・・・

？テスト？

サンプル = ？=テスト？, "TEST", "NOW" | "TEST" ;    ☚上で?テスト?を宣言すると?=テスト?がtrue,'テスト'を返すとか？

集合の積　＝ A , B , C ;        (* A　且つ、　B　且つ、　C　である *)
集合の和　＝ A | B | C ;        (* A　または、B　または、C　である *)
集合の差　＝ A - B - C ;        (* A　である、B　は除外、C　も除外 *)

/**
 *  例外（集合の差）パーサを作成する
 * @param {Array of parser} parsers     例外（集合の差）するパーサの配列
 * @return {Function} 					生成した連結パーサ
 */
exception(...parsers) {
    const methodName = 'exception';
    // パーサに正規表現やテキストが混ざっていたらパーサに変換する
    parsers = this.normalizeParses(parsers);
    this.chkFunction(methodName, "parsers", parsers);
    // パーサが単体の場合はそのまま返す
    if (parsers.length === 1) {
        this.chkFunction(methodName, "parsers[0]", parsers[0]);
        return parsers[0];
    }
    // パーサが複数の場合は、全ての判定が真の場合に成功を返すパーサを渡す
    const func =
        /**
         *  生成した例外（集合の差）パーサ
         * @param {string} target       ソースコード
         * @param {integer} position    読取り位置
         * @return {ParseInfo}          パースした結果
         */
        (target, position) => {/*sequnce*/
            const bk = this.fSpaceSkip;
            if (this.fSpaceSkip) { [target, position] = this.skipSpace(target, position); }
            const oldPosition = position;
            let result;
            for (let i = 0; i < parsers.length; i++) {
                const parser = parsers[i];
                this.chkFunction(methodName, "parser", parser);
                const parsed = parser(target, position);
                if (parsed === undefined) {
                    continue;
                }
                if ((i === 0 && parsed.success) || (i !== 0 && !parsed.success)) {
                    if (i === 0) {
                        result = parsed.result;
                    }
                } else {
                    parsed.position = oldPosition;
                    // 一つでも判定で偽となれば、このパーサ自体が失敗を返す
                    parsed.success = false;
                    this.fSpaceSkip = bk;
                    return parsed;
                }
            }
            this.fSpaceSkip = bk;
            return new ParseInfo(true, result, position);
        };
    return func;
}

(*$ SEQUENCE SEPARATOR IS NOT REQUIRED $*)
(* セルのデータ *)
cell                = expr_cell | value_cell ;
(* 値 *)
value_cell          = time_stamp | date | time | number | boolean | sqstring | text_etc ;
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_etc            = /.+/ ;
(* 数式 *)
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 } ;

xxxx(a,b,c) { // 継承先のクラスのメソッドを呼びたい場合に使用する
  return this.#xxxx(a,b,c);
}
#xxxx(a,b,c) { // 自分のクラスのメソッドをどうしても呼びたい場合に使用する　※makeParser, parse, selfTest, etc.
　本体
}

・・・各派生クラスのconstructorに以下をコピペして
this.selfTest(
    this.#getSelfTestList(), this.#parser,
    {
        className: 'EbnfParser',
        testLog: false, jsonLog: false, mapLog: false,
        parse: this.#parse.bind(this)
    }
);
と呼び出し、

・・・以下、基底クラスで、実行させる
/**
 * 作成したパーサをテストする
 * @param {Function} parser 
 * @param {string} testText 
 * @param {object} info 
 * @returns 
 */
selfTest(testText, parser, info) {
    const methodName = 'selfTest';
    if (Array.isArray(testText)) {
        const stack = testText.map((t, index, a) => {
            if (info) {
                console.log(`${info.className}.${methodName}: pattern[${index + 1}/${a.length}]`);
            }
            return this.selfTest(t, parser, info);
        });
        return stack;
    } else {
        if (info && info.testLog) {
            this.map.DEBUG = info.mapLog;
            console.log(`${info.className}.${methodName}: text:'${testText}'`);
        }
        const result = info.parse(testText, parser);
        if (info.jsonLog) {
            this.jsonStringifyLog(result);
        }
        return result;
    }
}