From 079d5594000fad9bd1b7812063f1dcf09f55bccb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Christian=20Fra=C3=9F?= <fenris@greenscale.de>
Date: Sun, 20 Mar 2022 21:42:17 +0100
Subject: [PATCH] [upd] plankton

---
 lib/plankton/plankton.d.ts |  26 +--------
 lib/plankton/plankton.js   | 113 +++++++++++++++++--------------------
 2 files changed, 54 insertions(+), 85 deletions(-)

diff --git a/lib/plankton/plankton.d.ts b/lib/plankton/plankton.d.ts
index 158b960..76da119 100644
--- a/lib/plankton/plankton.d.ts
+++ b/lib/plankton/plankton.d.ts
@@ -1354,14 +1354,7 @@ declare namespace lib_plankton.lang {
     /**
      * @author fenris
      */
-    function default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }: {
-        lexer_rules: Array<{
-            type: string;
-            parameters?: Object;
-        }>;
-        parser_start: string;
-        parser_rules: Array<type_raw_parser_rule>;
-    }): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
+    function default_raw(input: any): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
 }
 declare namespace lib_plankton.lang {
     /**
@@ -1401,21 +1394,6 @@ declare namespace lib_plankton.lang {
         /**
          * @author fenris
          */
-        static default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }: {
-            lexer_rules: Array<{
-                type: string;
-                parameters?: Object;
-            }>;
-            parser_start: string;
-            parser_rules: Array<{
-                premise: string;
-                conclusion: Array<{
-                    type: string;
-                    parameters?: Object;
-                }>;
-                label?: string;
-                right_to_left?: boolean;
-            }>;
-        }): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
+        static default_raw(input: any): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
     }
 }
diff --git a/lib/plankton/plankton.js b/lib/plankton/plankton.js
index 94b5e0c..5d50f91 100644
--- a/lib/plankton/plankton.js
+++ b/lib/plankton/plankton.js
@@ -3350,8 +3350,8 @@ var lib_plankton;
         /**
          * @author fenris
          */
-        function default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
-            return (this.default({
+        function default_raw_v1({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
+            return (reader_default({
                 "lexer_rules": lexer_rules.map((lexerrule_raw) => {
                     switch (lexerrule_raw.type) {
                         case "ignore": {
@@ -3410,6 +3410,54 @@ var lib_plankton;
                 }),
             }));
         }
+        /**
+         * @author fenris
+         */
+        function default_raw_v2({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
+            return default_raw_v1({
+                "lexer_rules": lexer_rules.map((rule) => {
+                    if (rule["name"] === null) {
+                        return {
+                            "type": "ignore",
+                            "parameters": {
+                                "pattern": rule["pattern"],
+                            }
+                        };
+                    }
+                    else {
+                        return {
+                            "type": ((rule["pass"] === true)
+                                ? "string"
+                                : "void"),
+                            "parameters": {
+                                "pattern": rule["pattern"],
+                                "id": rule["name"],
+                            }
+                        };
+                    }
+                }),
+                "parser_start": parser_start,
+                "parser_rules": parser_rules,
+            });
+        }
+        /**
+         * @author fenris
+         */
+        function default_raw(input) {
+            switch (input["version"]) {
+                default:
+                case "1":
+                    {
+                        return default_raw_v1(input);
+                        break;
+                    }
+                case "2":
+                    {
+                        return default_raw_v2(input);
+                        break;
+                    }
+            }
+        }
         lang.default_raw = default_raw;
     })(lang = lib_plankton.lang || (lib_plankton.lang = {}));
 })(lib_plankton || (lib_plankton = {}));
@@ -3480,65 +3528,8 @@ var lib_plankton;
             /**
              * @author fenris
              */
-            static default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
-                return (this.default({
-                    "lexer_rules": lexer_rules.map((lexerrule_raw) => {
-                        switch (lexerrule_raw.type) {
-                            case "ignore": {
-                                return lang.class_lexerrule.pattern_ignore(lexerrule_raw.parameters["pattern"]);
-                                break;
-                            }
-                            case "void": {
-                                return lang.class_lexerrule.pattern_void(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
-                                break;
-                            }
-                            case "boolean": {
-                                return lang.class_lexerrule.pattern_boolean(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"], lexerrule_raw.parameters["value"]);
-                                break;
-                            }
-                            case "int": {
-                                return lang.class_lexerrule.pattern_int(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
-                                break;
-                            }
-                            case "float": {
-                                return lang.class_lexerrule.pattern_float(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
-                                break;
-                            }
-                            case "string": {
-                                return lang.class_lexerrule.pattern_string(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
-                                break;
-                            }
-                            default: {
-                                throw (new Error(`unhandled type for raw lexer-rule '${lexerrule_raw.type}'`));
-                                break;
-                            }
-                        }
-                    }),
-                    "parser_start": parser_start,
-                    "parser_rules": parser_rules.map((parserrule_raw) => {
-                        return ({
-                            "label": parserrule_raw.label,
-                            "premise": parserrule_raw.premise,
-                            "conclusion": parserrule_raw.conclusion.map(entry => {
-                                switch (entry.type) {
-                                    case "terminal": {
-                                        return (new lib_plankton.lang.class_symbol_terminal({ "id": entry.parameters["id"] }));
-                                        break;
-                                    }
-                                    case "variable": {
-                                        return (new lib_plankton.lang.class_symbol_variable(entry.parameters["id"]));
-                                        break;
-                                    }
-                                    default: {
-                                        throw (new Error(`unhandled type for raw parser-rule '${entry.type}'`));
-                                        break;
-                                    }
-                                }
-                            }),
-                            "right_to_left": parserrule_raw.right_to_left,
-                        });
-                    }),
-                }));
+            static default_raw(input) {
+                return lang.default_raw(input);
             }
         }
         lang.class_reader = class_reader;