@stechquick/studio-cli 4.1.0-6 → 4.1.1-0

package/dist/quick/common/shrimp/omniScriptCompiler/Parser.js

@@ -0,0 +1,988 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseObj = void 0;
+const Node_1 = require("./Node");
+const Token_1 = require("./Token");
+const typeHelper_1 = require("../helpers/typeHelper");
+const QSCError_1 = require("./QSCError");
+function ParseContext(tokenInputs) {
+    this.tokenInputs = tokenInputs;
+    this.i = 0;
+    this.innerParseClosure = false;
+    this.innerParseClosureRetval = null;
+    this.innerParseEntryReasons = [];
+}
+ParseContext.prototype.getInnerParseEntryReason = function () {
+    var resLength = this.innerParseEntryReasons.length;
+    return resLength ? this.innerParseEntryReasons[resLength - 1] : null;
+};
+ParseContext.prototype.setInnerParseEntryReason = function (newReason) {
+    var oldEntryReason = this.getInnerParseEntryReason();
+    this.innerParseEntryReasons.push(newReason);
+    return oldEntryReason;
+};
+ParseContext.prototype.popInnerParseEntryReason = function () {
+    this.innerParseEntryReasons.pop();
+};
+ParseContext.prototype.searchInnerParseEntryReason = function (searchReason) {
+    for (var i = this.innerParseEntryReasons.length - 1; i >= 0; i--) {
+        if (this.innerParseEntryReasons[i] == searchReason) {
+            return true;
+        }
+    }
+    return false;
+};
+var Parse = function (tokenInputs, parseOptions) {
+    ///<param name="tokenInputs" type="[Token]" value="[new Token()]">Lexed tokens</param>
+    ///<param name="parseOptions" value="{lineBreakMode: ''}">lineBreakMode: return | multiline | discard</param>
+    var forest = [];
+    var tree = null;
+    var prevNode = null;
+    var curNode = null;
+    // var rootParse = Object.prototype.toString.call(this).constructor.name != ParseContext.name;
+    // var parseContext = !rootParse ? this : new ParseContext(tokenInputs);
+    var rootParse = this === undefined;
+    var parseContext = !rootParse ? this : new ParseContext(tokenInputs);
+    var tokens = parseContext.tokenInputs || [];
+    var options = parseOptions || {};
+    options.lineBreakMode = options.lineBreakMode || "multiline";
+    if (tokens.length == 0) {
+        return forest;
+    }
+    while (parseContext.i < tokens.length && !parseContext.innerParseClosure) {
+        curNode = new Node_1.Node(tokens[parseContext.i]);
+        if (options.lineBreakMode != "discard") {
+            if (prevNode != null && curNode.token.position.line != prevNode.token.position.line) {
+                if (options.lineBreakMode == "return") {
+                    parseContext.innerParseClosure = true;
+                    break;
+                }
+                else { // multiline
+                    if (curNode.TokObject.closer === true && rootParse === false) {
+                        //if this is a closer no line breaking, will be returning allready
+                        prevNode = null;
+                    }
+                    else {
+                        forest.push(tree);
+                        tree = null;
+                        prevNode = null;
+                    }
+                }
+            }
+        }
+        if (tree == null) {
+            if (!curNode.TokObject.canBeFirst) {
+                throw createError("(Parser)Statement can not start with " + curNode.Summarize(), "Statement can not start with " + curNode.token.value, curNode, null);
+            }
+            switch (curNode.token.type) {
+                case Lex.tok.operator:
+                    if (curNode.token.value == "(") {
+                        curNode = Lex.operators["("].CanBeTaken.call(parseContext, null, curNode);
+                    }
+                    break;
+                case Lex.tok.keyword:
+                    curNode = curNode.TokObject.CanBeTaken.call(parseContext, null, curNode);
+                    break;
+            }
+            tree = curNode;
+        }
+        else {
+            var taken = null;
+            if (curNode.TokObject.CanBeTaken != null) {
+                taken = curNode.TokObject.CanBeTaken.call(parseContext, prevNode, curNode);
+            }
+            if (taken == false) {
+                throw createError(prevNode.ShortSummarize() + " can not be preceed by " + curNode.ShortSummarize(), prevNode.token.value + " can not be preceeded by " + curNode.token.value, curNode, null);
+            }
+            if (taken == null) {
+                var taken = prevNode.TokObject.CanTake.call(parseContext, curNode, prevNode);
+                if (taken == null || taken == false) {
+                    throw createError(curNode.ShortSummarize() + " can not preceed " + prevNode.ShortSummarize(), curNode.token.value + " can not preceed " + prevNode.token.value, curNode, null);
+                }
+            }
+            if (parseContext.innerParseClosure == false && parseContext.innerParseClosureRetval != null) {
+                if (parseContext.innerParseClosureRetval.retTokenValue.indexOf(prevNode.token.value) != 0) {
+                    throw createError("matching " + parseContext.innerParseClosureRetval.retTokenValue.substring(0, 1) + " can not be found for " + parseContext.innerParseClosureRetval.retTokenValue.substring(1, 1) + ".", null, parseContext.innerParseClosureRetval.retResponsible, null);
+                }
+                prevNode.token.endPosition = parseContext.innerParseClosureRetval.retEndPosition;
+                prevNode.token.value = parseContext.innerParseClosureRetval.retTokenValue;
+                prevNode.TokObject = parseContext.innerParseClosureRetval.retTokObject;
+                parseContext.innerParseClosureRetval = null;
+            }
+            if (taken !== true) {
+                curNode = taken;
+            }
+        }
+        while (tree.parent != null) {
+            tree = tree.parent;
+        }
+        prevNode = curNode;
+        parseContext.i++;
+    }
+    if (parseContext.innerParseClosure) {
+        parseContext.i--;
+        parseContext.innerParseClosure = false;
+    }
+    if (tree != null) {
+        forest.push(tree);
+    }
+    return forest;
+};
+var parse = Parse;
+var CanTakeOperatorPlus = function (node, self) {
+    ///<param name="node" value="new Node()"></param>
+    ///<param name="self" value="new Node()"></param>
+    switch (node.token.type) {
+        case Lex.tok.string:
+            switch (self.token.value) {
+                case "+":
+                    postfix(node, self);
+                    return true;
+            }
+        case Lex.tok.identifier:
+            postfix(node, self);
+            return true;
+        case Lex.tok.number:
+            postfix(node, self);
+            return true;
+        case Lex.tok.operator:
+            switch (node.token.value) {
+                case "+":
+                case "*":
+                case "/":
+                case "-":
+                case "&&":
+                case "||":
+                    if (!self.right) {
+                        return false;
+                    }
+                    infix(node, self);
+                    return true;
+                case "!":
+                    postfix(node, self);
+                    return true;
+            }
+            return false;
+    }
+};
+var peekNext = function () {
+    ///<summary></summary>
+    ///<returns type="Isbank.OmniScript.Token" value="new Isbank.OmniScript.Token()"></returns>
+    if (this.tokenInputs.length <= this.i + 1) {
+        return null;
+    }
+    return this.tokenInputs[this.i + 1];
+};
+var checkNext = function (expectedTokenValue) {
+    var retVal = null;
+    var nextToken = peekNext.call(this);
+    if (nextToken === null) {
+        return expectedTokenValue === null;
+    }
+    if (nextToken.value === expectedTokenValue && nextToken.type != "string") {
+        retVal = true;
+    }
+    else {
+        retVal = false;
+    }
+    return retVal;
+};
+var assertNext = function (expectedTokenValue) {
+    var checkRet = checkNext.call(this, expectedTokenValue);
+    if (checkRet === true) {
+        this.i++;
+        return;
+    }
+    else if (checkRet === false) {
+        unexpectedToken.call(this, expectedTokenValue);
+    }
+};
+var unexpectedToken = function (expectedTokenValue) {
+    var expected = expectedTokenValue;
+    if (new typeHelper_1.TypeHelper().isArray(expected)) {
+        expected = expected.join(",");
+    }
+    throw createError("(Parser)Unexpected token: " + this.tokenInputs[this.i].Summarize() + " Expected: " + expected, "Unexpected token: " + this.tokenInputs[this.i].value + " Expected: " + expected, null, this.tokenInputs[this.i]);
+};
+var assertRetResp = function (expectedTokenValue) {
+    var expecteds = expectedTokenValue;
+    if (!new typeHelper_1.TypeHelper().isArray(expecteds)) {
+        expecteds = [expecteds];
+    }
+    var found = false;
+    for (var i = 0; i < expecteds.length && !found; i++) {
+        if (this.innerParseClosureRetval.retResponsible.token.value == expecteds[i]) {
+            found = true;
+        }
+    }
+    if (!found) {
+        unexpectedToken.call(this, expectedTokenValue);
+    }
+};
+var assertEntryReasonExistInStack = function (reasonToSearch) {
+    if (!this.searchInnerParseEntryReason(reasonToSearch)) {
+        throw createError(this.tokenInputs[this.i].Summarize() + " can only be used inside " + reasonToSearch + " body", this.tokenInputs[this.i].value + " can only be used inside " + reasonToSearch + " body", null, this.tokenInputs[this.i].value);
+    }
+};
+var Lex = {
+    tok: {
+        operator: Token_1.Token.Types.operator,
+        string: Token_1.Token.Types.string,
+        number: Token_1.Token.Types.number,
+        identifier: Token_1.Token.Types.identifier,
+        keyword: Token_1.Token.Types.keyword
+    },
+    strings: {
+        main: {
+            canBeFirst: true,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        if (node.token.value === "{") {
+                            self.right = [];
+                            var statementCounter = 0;
+                            var next = null, loop = false;
+                            do {
+                                this.i++;
+                                loop = false;
+                                var parsedForest = parse.call(this, null, { lineBreakMode: "return" }); // string statements can not be multiline / 56041 for now... (*)
+                                //(*) -> still using forest for future prevention of evaluator changes :)
+                                assertRetResp.call(this, "}");
+                                self.right.push(parsedForest);
+                                self.token.value += ("{" + statementCounter++ + "}");
+                                this.innerParseClosureRetval = null;
+                                next = peekNext.call(this);
+                                if (next !== null && next.type === Lex.tok.string) {
+                                    self.token.value += next.value;
+                                    this.i++;
+                                    next = peekNext.call(this);
+                                    if (next !== null && next.value === "{") {
+                                        loop = true;
+                                        this.i++;
+                                    }
+                                }
+                            } while (loop);
+                            return self;
+                        }
+                        else {
+                            infix(node, self);
+                        }
+                        return true;
+                }
+            }
+        }
+    },
+    numbers: {
+        main: {
+            canBeFirst: true,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        infix(node, self);
+                        return true;
+                }
+            }
+        }
+    },
+    identifiers: {
+        main: {
+            canBeFirst: true,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        infix(node, self);
+                        return true;
+                }
+            }
+        }
+    },
+    keywords: {
+        "if": {
+            canBeFirst: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="self" value="new Node()"></param>
+                if (node != null) {
+                    return false;
+                }
+                var myEntryReason = this.getInnerParseEntryReason();
+                var setInnerParseContext = function () {
+                    if (myEntryReason === "elseif") {
+                        this.innerParseClosure = true;
+                    }
+                    else {
+                        this.innerParseClosureRetval = null;
+                    }
+                };
+                assertNext.call(this, "(");
+                this.i++;
+                self.left = parse.call(this, null, { lineBreakMode: "discard" })[0];
+                assertRetResp.call(this, ")");
+                this.innerParseClosureRetval = null;
+                assertNext.call(this, "{");
+                this.i++;
+                this.setInnerParseEntryReason("if");
+                self.right = [parse.call(this, null, { lineBreakMode: "multiline" }), null];
+                this.popInnerParseEntryReason();
+                assertRetResp.call(this, "}");
+                if (checkNext.call(this, "else") === true) {
+                    this.innerParseClosureRetval = null;
+                    this.i++;
+                    if (checkNext.call(this, "if") === true) { // else if {
+                        this.i++;
+                        this.setInnerParseEntryReason("elseif");
+                        self.right[1] = parse.call(this, null, { lineBreakMode: "multiline" });
+                        this.popInnerParseEntryReason();
+                        // check } maybe ??
+                        setInnerParseContext.call(this);
+                    }
+                    else { //else {
+                        assertNext.call(this, "{");
+                        this.i++;
+                        this.setInnerParseEntryReason("else");
+                        self.right[1] = parse.call(this, null, { lineBreakMode: "multiline" });
+                        this.popInnerParseEntryReason();
+                        assertRetResp.call(this, "}");
+                        setInnerParseContext.call(this);
+                    }
+                }
+                else {
+                    setInnerParseContext.call(this);
+                }
+                return self;
+            }
+        },
+        "foreach": {
+            canBeFirst: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="self" value="new Node()"></param>
+                if (node != null) {
+                    return false;
+                }
+                var setInnerParseContext = function () {
+                    this.innerParseClosureRetval = null;
+                };
+                assertNext.call(this, "(");
+                var identifier = peekNext.call(this);
+                if (identifier.type != Lex.tok.identifier) {
+                    return false;
+                }
+                this.i++;
+                var inn = peekNext.call(this);
+                this.i++;
+                if (inn.type != Lex.tok.keyword || inn.value != "in") {
+                    unexpectedToken.call(this, "in");
+                }
+                this.i++;
+                inn = new Node_1.Node(inn);
+                identifier = new Node_1.Node(identifier);
+                inn.right = parse.call(this, null, { lineBreakMode: "return" })[0];
+                inn.left = identifier;
+                self.left = inn;
+                assertRetResp.call(this, ")");
+                this.innerParseClosureRetval = null;
+                assertNext.call(this, "{");
+                this.i++;
+                this.setInnerParseEntryReason("foreach");
+                self.right = [parse.call(this, null, { lineBreakMode: "multiline" })];
+                this.popInnerParseEntryReason();
+                assertRetResp.call(this, "}");
+                setInnerParseContext.call(this);
+                return self;
+            }
+        },
+        "in": {
+            canBeFirst: false,
+            CanBeTaken: function () {
+                return false;
+            }
+        },
+        "break": {
+            canBeFirst: true,
+            CanBeTaken: function (node, self) {
+                if (node != null) {
+                    return false;
+                }
+                assertEntryReasonExistInStack.call(this, "foreach");
+                return self;
+            }
+        },
+        "continue": {
+            canBeFirst: true,
+            CanBeTaken: function (node, self) {
+                if (node != null) {
+                    return false;
+                }
+                assertEntryReasonExistInStack.call(this, "foreach");
+                return self;
+            }
+        }
+    },
+    operators: {
+        "()": {
+            wasOpenable: true,
+            concatable: true,
+            canBeFirst: false,
+            value: "()",
+            presedence: -1,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                infix(node, self);
+                return true;
+            }
+        },
+        "(": {
+            openable: true,
+            canBeFirst: true, presedence: -1,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                var parsed = [];
+                while (true) {
+                    parsed.push(parse.call(this, null, { lineBreakMode: "return" })[0]);
+                    if (this.innerParseClosureRetval.retResponsible.token.value == ",") {
+                        this.innerParseClosureRetval = null;
+                        this.i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                postfix(parsed, self);
+                return self;
+            },
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                if (node == null) {
+                    this.i++;
+                    var parsed = parse.call(this, null, { lineBreakMode: "return" })[0];
+                    this.innerParseClosureRetval = null;
+                    return parsed;
+                }
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        if (node.TokObject.wasOpenable === true) {
+                            // calling an openable. no differecent than identifier
+                            infix(self, node);
+                            return true;
+                        }
+                        // self is presedence operator
+                        this.i++;
+                        var parsed = parse.call(this, null, { lineBreakMode: "return" })[0];
+                        this.innerParseClosureRetval = null;
+                        postfix(parsed, node);
+                        return parsed;
+                    case Lex.tok.number:
+                        return false;
+                    case Lex.tok.identifier:
+                        infix(self, node);
+                        return true;
+                }
+            }
+        },
+        ")": {
+            canBeFirst: false, presedence: 9,
+            closer: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                if (node != null) {
+                    switch (node.token.type) {
+                        case Lex.tok.operator:
+                            //if (node.TokObject.openable != true && node.TokObject.wasOpenable != true) {
+                            //    return false;
+                            //} evaluator -> and2
+                            if (node.token.value == "(") { // açılmanın üstüne kapama -> ()
+                                node.token.value = Lex.operators["()"].value;
+                                node.TokObject = Lex.operators["()"];
+                                node.token.endPosition = self.token.position;
+                                return node;
+                            }
+                            break;
+                    }
+                }
+                this.innerParseClosure = true;
+                this.innerParseClosureRetval = {
+                    retTokenValue: Lex.operators["()"].value,
+                    retTokObject: Lex.operators["()"],
+                    retEndPosition: self.token.position,
+                    retResponsible: self
+                };
+                return true;
+            }
+        },
+        "{}": {
+            concatable: true,
+            canBeFirst: false,
+            value: "{}",
+            wasOpenable: true,
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        switch (node.token.value) {
+                            case Lex.operators["!"]:
+                                return false;
+                        }
+                        infix(node, self);
+                        return true;
+                }
+            }
+        },
+        "{": {
+            openable: true,
+            canBeFirst: true, value: "{",
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                var parsed = [];
+                var curParsed = null;
+                while (true) {
+                    curParsed = parse.call(this, null, { lineBreakMode: "discard" })[0];
+                    assertRetResp.call(this, ["}", ","]);
+                    if (curParsed.token.value != "=") {
+                        throw createError("(Parser)object creation scope <<{}>> must consist of assignments <<=>>, not expected: " + curParsed.Summarize(), "object creation scope <<{}>> must consist of assignments <<=>>, not expected: " + curParsed.token.value, curParsed, null);
+                    }
+                    parsed.push(curParsed);
+                    if (this.innerParseClosureRetval.retResponsible.token.value == ",") {
+                        this.innerParseClosureRetval = null;
+                        this.i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                postfix(parsed, self);
+                return self;
+            }
+        },
+        "}": {
+            value: "}",
+            canBeFirst: true,
+            closer: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                if (node != null) {
+                    switch (node.token.type) {
+                        case Lex.tok.operator:
+                            if (node.TokObject.openable != true && node.TokObject.wasOpenable != true) {
+                                return false;
+                            }
+                            if (node.token.value == "{") { // açılmanın üstüne kapama -> {}
+                                node.token.value = Lex.operators["{}"].value;
+                                node.TokObject = Lex.operators["{}"];
+                                node.token.endPosition = self.token.position;
+                                return node;
+                            }
+                            break;
+                    }
+                }
+                this.innerParseClosure = true;
+                this.innerParseClosureRetval = {
+                    retTokenValue: Lex.operators["{}"].value,
+                    retTokObject: Lex.operators["{}"],
+                    retEndPosition: self.token.position,
+                    retResponsible: self
+                };
+                return true;
+            }
+        },
+        "[]": {
+            wasOpenable: true,
+            concatable: true,
+            canBeFirst: false,
+            presedence: -1,
+            value: "[]",
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        switch (node.token.value) {
+                            case Lex.operators["["]:
+                            case Lex.operators["!"]:
+                                return false;
+                        }
+                        infix(node, self);
+                        return true;
+                }
+            }
+        },
+        "[": {
+            openable: true,
+            presedence: -1,
+            value: "[",
+            canBeFirst: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        if (node.TokObject.wasOpenable === true || node.TokObject.openable === true || node.token.value === "=") {
+                            return null; // be handled with [].CanTake, ().CanTake || (.CanTake...
+                        }
+                        throw createError("(Parser)not implemented 16", "not implemented 16", node, null); //concat two arrays maybe ?? [2,3]+[4,5,6]
+                        return true;
+                    case Lex.tok.number:
+                        return false;
+                    case Lex.tok.identifier:
+                        infix(self, node);
+                        return true;
+                }
+            },
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                var parsed = [];
+                while (true) {
+                    parsed.push(parse.call(this, null, { lineBreakMode: "return" })[0]);
+                    if (this.innerParseClosureRetval.retResponsible.token.value == ",") {
+                        this.innerParseClosureRetval = null;
+                        this.i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                postfix(parsed, self);
+                return self;
+            }
+        },
+        "]": {
+            value: "]",
+            canBeFirst: false,
+            closer: true,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                if (node != null) {
+                    switch (node.token.type) {
+                        case Lex.tok.operator:
+                            if (node.token.value == "[") { // açılmanın üstüne kapama -> []
+                                node.token.value = Lex.operators["[]"].value;
+                                node.TokObject = Lex.operators["[]"];
+                                node.token.endPosition = self.token.position;
+                                return node;
+                            }
+                            if (node.TokObject.wasOpenable != true) {
+                                return false;
+                            }
+                    }
+                }
+                this.innerParseClosure = true;
+                this.innerParseClosureRetval = {
+                    retTokenValue: Lex.operators["[]"].value,
+                    retTokObject: Lex.operators["[]"],
+                    retEndPosition: self.token.position,
+                    retResponsible: self
+                };
+                return true;
+            }
+        },
+        "+": {
+            concatable: false,
+            canBeFirst: false, presedence: 5,
+            CanTake: CanTakeOperatorPlus
+        },
+        "-": {
+            concatable: false,
+            canBeFirst: true, presedence: 5,
+            CanTake: CanTakeOperatorPlus
+        },
+        "*": {
+            concatable: false,
+            canBeFirst: false, presedence: 6,
+            CanTake: CanTakeOperatorPlus
+        },
+        "/": {
+            concatable: false,
+            canBeFirst: false, presedence: 6,
+            CanTake: CanTakeOperatorPlus
+        },
+        "&&": {
+            concatable: false,
+            canBeFirst: false, presedence: 2,
+            CanTake: CanTakeOperatorPlus
+        },
+        "||": {
+            concatable: false,
+            canBeFirst: false, presedence: 2,
+            CanTake: CanTakeOperatorPlus
+        },
+        "!": {
+            canBeFirst: true, concatable: false,
+            presedence: 7,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.number:
+                    case Lex.tok.identifier:
+                    case Lex.tok.string:
+                        return false;
+                }
+            },
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        return false;
+                }
+                postfix(node, self);
+                return true;
+            }
+        },
+        "?": {
+            canBeFirst: false
+        },
+        ":": {
+            canBeFirst: false,
+            CanTake: function () {
+                //sadece dışarısı object creation'larda ({a=5}) = kullanılmalı hatasını versin diye. Başka bir amaç yok...
+                return true;
+            }
+        },
+        "%": {
+            canBeFirst: false
+        },
+        ".": {
+            concatable: true,
+            presedence: 8,
+            canBeFirst: false,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.identifier:
+                        infix(self, node);
+                        return true;
+                }
+            },
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.identifier:
+                        postfix(node, self);
+                        return true;
+                }
+            }
+        },
+        "&": {
+            canBeFirst: false
+        },
+        "|": {
+            canBeFirst: false
+        },
+        ">": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        "<": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        ">=": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        "<=": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        "==": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        "!=": {
+            concatable: false,
+            canBeFirst: false, presedence: 4,
+            CanTake: CanTakeOperatorPlus
+        },
+        "=": {
+            canBeFirst: false, presedence: -1,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                var head = node;
+                while (head.parent != null) {
+                    // burada scope'ı ayırmak lazım. SM.go(alper{a=5,b=6}
+                    head = head.parent;
+                }
+                var permitted = {
+                    "[]": 1, identifier: 1, ".": 1, string: 1
+                };
+                if (permitted[head.token.type] == null && permitted[head.token.value] == null) {
+                    throw createError("(Parser)left hand side of = has errors: " + self.Summarize(), "left hand side of = has errors: " + self.token.value, self, null);
+                }
+                infix(self, node);
+                return true;
+            },
+            CanTake: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                var parsed = parse.call(this, null, { lineBreakMode: "return" })[0];
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        if (node.token.value == "=") {
+                            return false;
+                        }
+                        break;
+                }
+                postfix(parsed, self);
+                if (this.innerParseClosureRetval != null) {
+                    var retRespTokVal = this.innerParseClosureRetval.retResponsible.token.value;
+                    if (retRespTokVal == "," || retRespTokVal == "}" || retRespTokVal == ")") { // bitiş sona gelmesi değil de , dolayısı ile
+                        this.innerParseClosure = true; // benim değil, üstten girenin
+                    }
+                }
+                return parsed;
+            }
+        },
+        ",": {
+            canBeFirst: false, presedence: -1,
+            CanBeTaken: function (node, self) {
+                ///<param name="node" value="new Node()"></param>
+                ///<param name="self" value="new Node()"></param>
+                switch (node.token.type) {
+                    case Lex.tok.operator:
+                        if (node.TokObject.wasOpenable != true) {
+                            //if (node.token.value != "()") {
+                            return false;
+                        }
+                        break;
+                }
+                this.innerParseClosure = true;
+                this.innerParseClosureRetval = {
+                    retTokenValue: null,
+                    retTokObject: null,
+                    retEndPosition: null,
+                    retResponsible: self
+                };
+                return true;
+            }
+        }
+    }
+};
+Parse.Dict = Lex;
+var postfix = function (newNode, self) {
+    ///<param name="newNode" value="new Node()"></param>
+    ///<param name="self" value="new Node()"></param>
+    if (!new typeHelper_1.TypeHelper().isArray(newNode)) {
+        newNode = [newNode];
+    }
+    for (var i = 0; i < newNode.length; i++) {
+        if (newNode[i].parent != null) {
+            throw createError("(Parser)unexpected postfix: newnodes parent is not null: " + newNode[i].Summarize(), "unexpected postfix: newnodes parent is not null:" + newNode[i].token.value, newNode[i], null);
+        }
+        newNode[i].parent = self;
+    }
+    if (self.right == null) {
+        self.right = newNode.length > 1 ? newNode : newNode[0];
+    }
+    else {
+        throw createError("(Parser)unexpected postfix: selfs right is not null" + self.Summarize(), "unexpected postfix: selfs right is not null" + self.token.value, self, null);
+    }
+};
+var putInPlace = function (destNode, sourceNode) {
+    ///<param name="destNode" value="new Node()"></param>
+    ///<param name="sourceNode" value="new Node()"></param>
+    if (destNode.parent == null) {
+        destNode.parent = sourceNode;
+        if (sourceNode.left == null) {
+            sourceNode.left = destNode;
+        }
+        else if (sourceNode.right == null) {
+            sourceNode.right = destNode;
+        }
+        else {
+            throw createError("(Parser)Can not put in place source has both left and right: " + sourceNode.Summarize(), "Can not put in place source has both left and right: " + sourceNode.token.value, sourceNode, null);
+        }
+    }
+    else {
+        destNode.parent.right = sourceNode;
+        sourceNode.parent = destNode.parent;
+        destNode.parent = sourceNode;
+        if (sourceNode.left == null) {
+            sourceNode.left = destNode;
+        }
+        else {
+            throw createError("(Parser)Can not put in place, incomming source nodes left is not null: " + sourceNode.Summarize(), "Can not put in place, incomming source nodes left is not null: " + sourceNode.token.value, sourceNode, null);
+        }
+    }
+};
+var infix = function (newNode, self) {
+    ///<param name="newNode" value="new Node()"></param>
+    ///<param name="self" value="new Node()"></param>
+    if (self.parent == null) {
+        self.parent = newNode;
+        if (newNode.left == null) {
+            newNode.left = self;
+        }
+        else {
+            throw createError("(Parser)unexpected infix: newNode left is not null " + newNode.Summarize(), "unexpected infix: newNode left is not null " + newNode.token.value, newNode, null);
+        }
+    }
+    else {
+        var target = self;
+        while (true) {
+            if (target.parent == null || target.parent.TokObject.presedence < newNode.TokObject.presedence) {
+                break;
+            }
+            if (newNode.TokObject.presedence == -1 && target.parent.TokObject.concatable != true) {
+                break;
+            }
+            target = target.parent;
+        }
+        putInPlace(target, newNode);
+    }
+};
+var parseExObj = function (message, responsibleNode) {
+    return {
+        message: "(Parser)" + message,
+        responsibleNode: responsibleNode
+    };
+};
+/**
+ *
+ * @param {string} consoleMsg
+ * @param {string | undefined} msg
+ * @param {Node | undefined} responsibleNode
+ * @param {Token | undefined} responsibleToken
+ */
+var createError = function (consoleMsg, msg, responsibleNode, responsibleToken) {
+    var pos = { line: 0, column: 0 };
+    var endPos = { line: 0, column: 0 };
+    if (responsibleNode) {
+        pos = (responsibleNode.token && responsibleNode.token.position) || pos;
+        endPos = (responsibleNode.token && responsibleNode.token.endPosition) || endPos;
+    }
+    else if (responsibleToken) {
+        pos = responsibleToken.position || pos;
+        endPos = responsibleToken.endPosition || endPos;
+    }
+    return new QSCError_1.QSCError({
+        message: consoleMsg, intelliMsg: msg,
+        stLine: pos.line, stColumn: pos.line,
+        eLine: endPos.line, eColumn: endPos.column,
+        responsibleNode: responsibleNode
+    });
+};
+var ParseObj = { Parse: Parse };
+exports.ParseObj = ParseObj;
+//# sourceMappingURL=Parser.js.map