From 20c38dbe4cc8813fbd5b838c230a8c720add06d5 Mon Sep 17 00:00:00 2001 From: Nat Quayle Nelson Date: Thu, 30 Oct 2025 20:13:51 -0500 Subject: [PATCH] More GDScript fixes --- hank-godot/scripts/HInterface.gd | 33 +- hank-godot/scripts/HParser.gd | 351 +++ hank-godot/scripts/Parser.gd | 3110 ++++++++++++++++++++--- hank-godot/scripts/Story.gd | 16 +- hank-godot/scripts/_GeneratedFiles.json | 3 +- hank/Story.hx | 2 + 6 files changed, 3183 insertions(+), 332 deletions(-) create mode 100644 hank-godot/scripts/HParser.gd diff --git a/hank-godot/scripts/HInterface.gd b/hank-godot/scripts/HInterface.gd index 68904eb..ca7adfb 100644 --- a/hank-godot/scripts/HInterface.gd +++ b/hank-godot/scripts/HInterface.gd @@ -448,26 +448,21 @@ static func isTruthy(viewCounts2: Variant, v) -> bool: if (((v as Variant) is StoryNode)): var node: StoryNode = (v as StoryNode) return viewCounts2.__get(node) > 0 - - if true: - var _g: Variant = Type._typeof(v) - match (_g._index): - 1, 2: - return v > 0 - 3: - return v - _: - if (((v as Variant) is String)): - var val: String = (v as String) - match (val): - "false": - return false - "true": - return true - _: - assert(false, str("" + str(v) + ": " + str(Type._typeof(v)) + " cannot be coerced to a boolean")) + if (((v as Variant) is bool)): + return v + else: + if (((v as Variant) is int) || ((v as Variant) is float)): + return v > 0 + else: + if (((v as Variant) is String)): + if (v == "false"): + return false else: - assert(false, str("" + str(v) + ": " + str(Type._typeof(v)) + " cannot be coerced to a boolean")) + return v.length > 0 + + assert(false, str("" + str(v) + " cannot be coerced to a boolean")) + + return false static func valueOf(viewCounts2: Variant, val): var tempResult diff --git a/hank-godot/scripts/HParser.gd b/hank-godot/scripts/HParser.gd new file mode 100644 index 0000000..ed28dcd --- /dev/null +++ b/hank-godot/scripts/HParser.gd @@ -0,0 +1,351 @@ +class_name HParser + +static var symbols: Array[Variant] = [] +static var choices: int = 0 + +var buffers: Array[HankBuffer] = [] +var ast: Array[Variant] = [] + +func _init() -> void: + choices = 0 + symbols.push_back({ + "key": "INCLUDE ", + "value": HParser.include + }) + symbols.push_back({ + "key": "<-", + "value": HParser.thread + }) + symbols.push_back({ + "key": "->", + "value": HParser.divert + }) + symbols.push_back({ + "key": "===", + "value": HParser.knot + }) + symbols.push_back({ + "key": "==", + "value": HParser.knot + }) + symbols.push_back({ + "key": "=", + "value": HParser.stitch + }) + symbols.push_back({ + "key": "~", + "value": HParser.haxeLine + }) + symbols.push_back({ + "key": "```", + "value": HParser.haxeBlock + }) + symbols.push_back({ + "key": "-", + "value": HParser.gather + }) + symbols.push_back({ + "key": "*", + "value": HParser.choice + }) + symbols.push_back({ + "key": "+", + "value": HParser.choice + }) + symbols.push_back({ + "key": "#", + "value": HParser.tag + }) + +func parseString(h: String) -> Array[Variant]: + var stringBuffer: HankBuffer = HankBuffer.Dummy(h) + var parsedAST: Array[Variant] = ([] as Array[Variant]) + + while true: + var position: Position = stringBuffer.position() + stringBuffer.skipWhitespace("") + if (stringBuffer.isEmpty()): + break + var expr: Variant = HParser.parseExpr(stringBuffer, position) + match (expr._index): + 0: + var _g: String = expr.path + var file: String = _g + assert(false, str("cannot include files from within an embedded Hank block")) + 6: + pass + _: + parsedAST.push_back({ + "position": position, + "expr": expr + }) + if !(!stringBuffer.isEmpty()): + break + + return parsedAST + +func parseFile(f: String, files = null, includedFile: bool = false) -> Array[Variant]: + var directory: String = "" + var tempNumber + var startIndex: int = -1 + + if (startIndex < 0): + tempNumber = f.rfind("/") + else: + var tempString + var endIndex: int = startIndex + f.length() + if (endIndex < 0): + tempString = f.substr(0) + else: + tempString = f.substr(0, endIndex) + tempNumber = (tempString).rfind("/") + + var lastSlashIdx: int = tempNumber + + if (lastSlashIdx != -1): + directory = f.substr(0, lastSlashIdx + 1) + f = f.substr(lastSlashIdx + 1) + + if true: + var _this: Array[HankBuffer] = self.buffers + var x: HankBuffer = HankBuffer.FromFile(directory + f, files) + if true: + _this.insert(0, x) + null + + while (self.buffers.size() > 0): + var position: Position = self.buffers[0].position() + self.buffers[0].skipWhitespace("") + if (self.buffers[0].isEmpty()): + var _this: Array[HankBuffer] = self.buffers + var x: HankBuffer = self.buffers[0] + var index: int = _this.find(x) + if (index >= 0): + _this.remove_at(index) + true + else: + false + else: + var expr: Variant = HParser.parseExpr(self.buffers[0], position) + match (expr._index): + 0: + var _g: String = expr.path + var file: String = _g + self.parseFile(directory + file, files, true) + 6: + pass + _: + self.ast.push_back({ + "position": position, + "expr": expr + }) + + var parsedAST: Array[Variant] = self.ast + + if (!includedFile): + self.ast = ([] as Array[Variant]) + + return parsedAST + +static func parseExpr(buffer: HankBuffer, position: Position) -> Variant: + var line: Variant = buffer.peekLine("") + + match (line._index): + 0: + var _g: String = line.v + var line2: String = _g + if (StringTools.trim(line2).length() == 0): + return { "_index": 6 } + var _g2: int = 0 + var _g1: Array[Variant] = symbols + while (_g2 < _g1.size()): + var rule: Variant = _g1[_g2] + _g2 += 1 + var symbol: String = rule.get("key") + var rule2 = rule.get("value") + if (StringTools.startsWith(StringTools.trim(line2), symbol)): + buffer.skipWhitespace("") + return rule2.call(buffer, position) + return HParser.output(buffer, position) + 1: + assert(false, str("Tried to parse expr when no lines were left in file")) + + return null + +static func lineTokens(buffer: HankBuffer, n: int, position: Position, throwOnMismatch: bool = true, rtrim: bool = true) -> Array[String]: + var line: String = Extensions.unwrap(buffer.takeLine("")) + + if (rtrim): + var tempRight + var l: int = line.length() + var r: int = 0 + while (r < l && StringTools.isSpace(line, l - r - 1)): + r += 1 + if (r > 0): + tempRight = line.substr(0, l - r) + else: + tempRight = line + line = tempRight + + var tokens: Array[String] = Array(Array(line.split(" ")), Variant.Type.TYPE_STRING, "", null) + + if (tokens.size() != n): + if (throwOnMismatch): + assert(false, str("Wrong number of tokens at " + str(position) + ": " + str(tokens.size()) + " tokens provided--should be " + str(n) + ".\nLine: `" + line + "`\nTokens: " + str(tokens))) + else: + return tokens.slice(0, n) + + return tokens + +static func include(buffer: HankBuffer, position: Position) -> Variant: + var tokens: Array[String] = HParser.lineTokens(buffer, 2, position, true, true) + + return { "_index": 0, "path": tokens[1] } + +static func divert(buffer: HankBuffer, position: Position) -> Variant: + var line: String = Extensions.unwrap(buffer.takeLine("")) + var _g: Array[String] = ([] as Array[String]) + var _g1: int = 0 + var _g2: Array[String] = Array(Array(line.split("->")), Variant.Type.TYPE_STRING, "", null) + + while (_g1 < _g2.size()): + var t: String = _g2[_g1] + _g1 += 1 + _g.push_back(StringTools.trim(t)) + + var targets: Array[String] = (_g).slice(1) + + return { "_index": 2, "targets": targets } + +static func thread(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("<-") + buffer.skipWhitespace("") + + var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, true, true) + + return { "_index": 3, "target": tokens[0] } + +static func output(buffer: HankBuffer, position: Position) -> Variant: + return { "_index": 1, "o": Output.parse(buffer, false) } + +static func knot(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("==") + + if (buffer.peekAhead(0, 1) == "="): + buffer.drop("=") + + buffer.skipWhitespace("") + + var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, false, true) + + return { "_index": 4, "name": tokens[0] } + +static func stitch(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("=") + buffer.skipWhitespace("") + + var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, false, true) + + return { "_index": 5, "name": tokens[0] } + +static func haxeLine(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("~") + + return { "_index": 7, "haxe": Extensions.unwrap(buffer.takeLine("lr")) } + +static func gather(buffer: HankBuffer, position: Position) -> Variant: + var depth: int = buffer.countConsecutive("-") + + buffer.skipWhitespace("") + + var label: Variant = buffer.expressionIfNext("(", ")") + + buffer.skipWhitespace("\n") + + return { "_index": 9, "label": label, "depth": depth, "expr": { "_index": 6 } } + +static func choice(buffer: HankBuffer, position: Position) -> Variant: + var symbol: String = buffer.peek(1) + var onceOnly: bool = symbol == "*" + var depth: int = buffer.countConsecutive(symbol) + + buffer.skipWhitespace("") + + var label: Variant = buffer.expressionIfNext("(", ")") + + buffer.skipWhitespace("") + + var condition: Variant = buffer.expressionIfNext("{", "}?") + + buffer.skipWhitespace("") + + var output: Output = Output.parse(buffer, false) + var divertTarget: Variant = output.takeInlineDivert() + + choices += 1 + + var tempNumber: int = choices - 1 + + return { "_index": 10, "c": { + "id": tempNumber, + "onceOnly": onceOnly, + "label": label, + "condition": condition, + "depth": depth, + "output": output, + "divertTarget": divertTarget, + "tags": ([] as Array[String]) + } } + +static func tag(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("#") + + var tagLine: String = Extensions.unwrap(buffer.takeLine("lr")) + var tags: Array[String] = Extensions.tokenize(tagLine) + var expr: Variant = HParser.parseExpr(buffer, position) + + if (expr._index == 10): + var _g: Variant = expr.c + var c: Variant = _g + c.set("tags", tags) + else: + haxe_Log.trace.call("Warning! Can't apply tags to " + str(expr), { + "fileName": "../hank/HParser.hx", + "lineNumber": 234, + "className": "hank.HParser", + "methodName": "tag" + }) + + return expr + +static func haxeBlock(buffer: HankBuffer, position: Position) -> Variant: + buffer.drop("```\n") + + var rawContents: String = Extensions.unwrap(buffer.takeUntil((["```"] as Array[String]), false, true)).get("output") + var processedContents: String = "" + var blockBuffer: HankBuffer = HankBuffer.Dummy(rawContents) + + while true: + var nextLine: String = Extensions.unwrap(blockBuffer.takeLine("lr")) + if (nextLine == ",,,"): + var embeddedHankBlock: String = Extensions.unwrap(blockBuffer.takeUntil(([",,,"] as Array[String]), false, true)).get("output") + processedContents += "story.runEmbeddedHank(\"" + HParser.escapeQuotes(embeddedHankBlock) + "\"); " + else: + if (StringTools.startsWith(nextLine, ",")): + nextLine = StringTools.trim(nextLine.substr(1)) + processedContents += "story.runEmbeddedHank(\"" + HParser.escapeQuotes(nextLine) + "\"); " + else: + processedContents += nextLine + " " + if !(!blockBuffer.isEmpty()): + break + + return { "_index": 8, "haxe": processedContents } + +static func escapeQuotes(s: String) -> String: + var escaped: String = s + + escaped = StringTools.replace(escaped, "'", "\\'") + escaped = StringTools.replace(escaped, "\"", "\\\"") + + return escaped + diff --git a/hank-godot/scripts/Parser.gd b/hank-godot/scripts/Parser.gd index 1badbb1..99763c8 100644 --- a/hank-godot/scripts/Parser.gd +++ b/hank-godot/scripts/Parser.gd @@ -1,351 +1,2849 @@ class_name Parser -static var symbols: Array[Variant] = [] -static var choices: int = 0 - -var buffers: Array[HankBuffer] = [] -var ast: Array[Variant] = [] +var line: int +var opChars: String +var identChars: String +var opPriority: Variant +var opRightAssoc: Variant +var preprocesorValues: Variant = haxe_ds_StringMap.new() +var allowJSON: bool +var allowTypes: bool +var allowMetadata: bool +var resumeErrors: bool +var input: String +var readPos: int +var char: int +var ops: Array[bool] +var idents: Array[bool] +var uid: int = 0 +var tokens: haxe_ds_GenericStack +var preprocStack: Array[Variant] func _init() -> void: - choices = 0 - symbols.push_back({ - "key": "INCLUDE ", - "value": Parser.include - }) - symbols.push_back({ - "key": "<-", - "value": Parser.thread - }) - symbols.push_back({ - "key": "->", - "value": Parser.divert - }) - symbols.push_back({ - "key": "===", - "value": Parser.knot - }) - symbols.push_back({ - "key": "==", - "value": Parser.knot - }) - symbols.push_back({ - "key": "=", - "value": Parser.stitch - }) - symbols.push_back({ - "key": "~", - "value": Parser.haxeLine - }) - symbols.push_back({ - "key": "```", - "value": Parser.haxeBlock - }) - symbols.push_back({ - "key": "-", - "value": Parser.gather - }) - symbols.push_back({ - "key": "*", - "value": Parser.choice - }) - symbols.push_back({ - "key": "+", - "value": Parser.choice - }) - symbols.push_back({ - "key": "#", - "value": Parser.tag - }) + self.line = 1 + self.opChars = "+*/-=!><&|^%~" + self.identChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_" -func parseString(h: String) -> Array[Variant]: - var stringBuffer: HankBuffer = HankBuffer.Dummy(h) - var parsedAST: Array[Variant] = ([] as Array[Variant]) + var priorities: Array[Array[String]] = ([(["%"] as Array[String]), (["*", "/"] as Array[String]), (["+", "-"] as Array[String]), (["<<", ">>", ">>>"] as Array[String]), (["|", "&", "^"] as Array[String]), (["==", "!=", ">", "<", ">=", "<="] as Array[String]), (["..."] as Array[String]), (["&&"] as Array[String]), (["||"] as Array[String]), (["=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "&=", "^=", "=>"] as Array[String]), (["->"] as Array[String])] as Array[Array[String]]) - while true: - var position: Position = stringBuffer.position() - stringBuffer.skipWhitespace("") - if (stringBuffer.isEmpty()): - break - var expr: Variant = Parser.parseExpr(stringBuffer, position) - match (expr._index): - 0: - var _g: String = expr.path - var file: String = _g - assert(false, str("cannot include files from within an embedded Hank block")) - 6: - pass - _: - parsedAST.push_back({ - "position": position, - "expr": expr - }) - if !(!stringBuffer.isEmpty()): - break + self.opPriority = haxe_ds_StringMap.new() + self.opRightAssoc = haxe_ds_StringMap.new() - return parsedAST + var _g: int = 0 + var _g1: int = priorities.size() -func parseFile(f: String, files = null, includedFile: bool = false) -> Array[Variant]: - var directory: String = "" - var tempNumber - var startIndex: int = -1 - - if (startIndex < 0): - tempNumber = f.rfind("/") - else: - var tempString - var endIndex: int = startIndex + f.length() - if (endIndex < 0): - tempString = f.substr(0) - else: - tempString = f.substr(0, endIndex) - tempNumber = (tempString).rfind("/") - - var lastSlashIdx: int = tempNumber - - if (lastSlashIdx != -1): - directory = f.substr(0, lastSlashIdx + 1) - f = f.substr(lastSlashIdx + 1) + while (_g < _g1): + var tempNumber + _g += 1 + tempNumber = _g - 1 + var i: int = tempNumber + var _g2: int = 0 + var _g3: Array[String] = priorities[i] + while (_g2 < _g3.size()): + var x: String = _g3[_g2] + _g2 += 1 + self.opPriority.__set(x, i) + if (i == 9): + self.opRightAssoc.__set(x, true) if true: - var _this: Array[HankBuffer] = self.buffers - var x: HankBuffer = HankBuffer.FromFile(directory + f, files) - if true: - _this.insert(0, x) - null - - while (self.buffers.size() > 0): - var position: Position = self.buffers[0].position() - self.buffers[0].skipWhitespace("") - if (self.buffers[0].isEmpty()): - var _this: Array[HankBuffer] = self.buffers - var x: HankBuffer = self.buffers[0] - var index: int = _this.find(x) - if (index >= 0): - _this.remove_at(index) - true - else: - false + var x: String = "!" + var tempNumber1 + if (x == "++" || x == "--"): + tempNumber1 = -1 else: - var expr: Variant = Parser.parseExpr(self.buffers[0], position) - match (expr._index): - 0: - var _g: String = expr.path - var file: String = _g - self.parseFile(directory + file, files, true) - 6: - pass - _: - self.ast.push_back({ - "position": position, - "expr": expr - }) + tempNumber1 = -2 + self.opPriority.__set(x, tempNumber1) + if true: + var x: String = "++" + var tempNumber2 + if (x == "++" || x == "--"): + tempNumber2 = -1 + else: + tempNumber2 = -2 + self.opPriority.__set(x, tempNumber2) + if true: + var x: String = "--" + var tempNumber3 + if (x == "++" || x == "--"): + tempNumber3 = -1 + else: + tempNumber3 = -2 + self.opPriority.__set(x, tempNumber3) + if true: + var x: String = "~" + var tempNumber4 + if (x == "++" || x == "--"): + tempNumber4 = -1 + else: + tempNumber4 = -2 + self.opPriority.__set(x, tempNumber4) - var parsedAST: Array[Variant] = self.ast +func error(err: Variant, pmin: int, pmax: int) -> void: + if (!self.resumeErrors): + assert(false, str(err)) - if (!includedFile): - self.ast = ([] as Array[Variant]) +func invalidChar(c: int) -> void: + if (!self.resumeErrors): + assert(false, str({ "_index": 0, "c": c })) - return parsedAST +func initParser(origin) -> void: + self.preprocStack = ([] as Array[Variant]) + self.tokens = haxe_ds_GenericStack.new() + self.char = -1 + self.ops = [] + self.idents = [] + self.uid = 0 -static func parseExpr(buffer: HankBuffer, position: Position) -> Variant: - var line: Variant = buffer.peekLine("") + if true: + var _g: int = 0 + var _g1: int = self.opChars.length() + while (_g < _g1): + var tempNumber + if true: + _g += 1 + tempNumber = _g - 1 + var i: int = tempNumber + var tempIndex + if true: + var _this: String = self.opChars + if (i >= 0 && i < _this.length()): + tempIndex = _this.unicode_at(i) + else: + tempIndex = null + self.ops[tempIndex] = true + if true: + var _g: int = 0 + var _g1: int = self.identChars.length() + while (_g < _g1): + var tempNumber1 + if true: + _g += 1 + tempNumber1 = _g - 1 + var i: int = tempNumber1 + var tempIndex1 + if true: + var _this: String = self.identChars + if (i >= 0 && i < _this.length()): + tempIndex1 = _this.unicode_at(i) + else: + tempIndex1 = null + self.idents[tempIndex1] = true - match (line._index): - 0: - var _g: String = line.v - var line2: String = _g - if (StringTools.trim(line2).length() == 0): - return { "_index": 6 } - var _g2: int = 0 - var _g1: Array[Variant] = symbols - while (_g2 < _g1.size()): - var rule: Variant = _g1[_g2] - _g2 += 1 - var symbol: String = rule.get("key") - var rule2 = rule.get("value") - if (StringTools.startsWith(StringTools.trim(line2), symbol)): - buffer.skipWhitespace("") - return rule2.call(buffer, position) - return Parser.output(buffer, position) - 1: - assert(false, str("Tried to parse expr when no lines were left in file")) +func parseString(s: String, origin = "hscript") -> Variant: + self.initParser(origin) + self.input = s + self.readPos = 0 + + var a: Array[Variant] = [] + + while (true): + var tk = self.token() + if (tk == { "_index": 0 }): + break + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + self.parseFullExpr(a) + + var tempResult + + if (a.size() == 1): + tempResult = a[0] + else: + tempResult = { "_index": 4, "e": a } + + return tempResult + +func unexpected(tk: Variant): + var err: Variant = { "_index": 1, "s": self.tokenString(tk) } + + if (!self.resumeErrors): + assert(false, str(err)) return null -static func lineTokens(buffer: HankBuffer, n: int, position: Position, throwOnMismatch: bool = true, rtrim: bool = true) -> Array[String]: - var line: String = Extensions.unwrap(buffer.takeLine("")) +func push(tk: Variant) -> void: + var _this: haxe_ds_GenericStack = self.tokens - if (rtrim): - var tempRight - var l: int = line.length() - var r: int = 0 - while (r < l && StringTools.isSpace(line, l - r - 1)): - r += 1 - if (r > 0): - tempRight = line.substr(0, l - r) - else: - tempRight = line - line = tempRight + _this.head = haxe_ds_GenericCell.new(tk, _this.head) - var tokens: Array[String] = Array(Array(line.split(" ")), Variant.Type.TYPE_STRING, "", null) +func ensure(tk) -> void: + var t = self.token() - if (tokens.size() != n): - if (throwOnMismatch): - assert(false, str("Wrong number of tokens at " + str(position) + ": " + str(tokens.size()) + " tokens provided--should be " + str(n) + ".\nLine: `" + line + "`\nTokens: " + str(tokens))) - else: - return tokens.slice(0, n) + if (t != tk): + self.unexpected(t) - return tokens +func ensureToken(tk) -> void: + var t = self.token() -static func include(buffer: HankBuffer, position: Position) -> Variant: - var tokens: Array[String] = Parser.lineTokens(buffer, 2, position, true, true) + if (!Type.enumEq(t, tk)): + self.unexpected(t) - return { "_index": 0, "path": tokens[1] } +func maybe(tk) -> bool: + var t = self.token() -static func divert(buffer: HankBuffer, position: Position) -> Variant: - var line: String = Extensions.unwrap(buffer.takeLine("")) - var _g: Array[String] = ([] as Array[String]) - var _g1: int = 0 - var _g2: Array[String] = Array(Array(line.split("->")), Variant.Type.TYPE_STRING, "", null) + if (Type.enumEq(t, tk)): + return true - while (_g1 < _g2.size()): - var t: String = _g2[_g1] - _g1 += 1 - _g.push_back(StringTools.trim(t)) + var _this: haxe_ds_GenericStack = self.tokens - var targets: Array[String] = (_g).slice(1) + _this.head = haxe_ds_GenericCell.new(t, _this.head) - return { "_index": 2, "targets": targets } + return false -static func thread(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("<-") - buffer.skipWhitespace("") +func getIdent() -> String: + var tk = self.token() - var tokens: Array[String] = Parser.lineTokens(buffer, 1, position, true, true) - - return { "_index": 3, "target": tokens[0] } - -static func output(buffer: HankBuffer, position: Position) -> Variant: - return { "_index": 1, "o": Output.parse(buffer, false) } - -static func knot(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("==") - - if (buffer.peekAhead(0, 1) == "="): - buffer.drop("=") - - buffer.skipWhitespace("") - - var tokens: Array[String] = Parser.lineTokens(buffer, 1, position, false, true) - - return { "_index": 4, "name": tokens[0] } - -static func stitch(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("=") - buffer.skipWhitespace("") - - var tokens: Array[String] = Parser.lineTokens(buffer, 1, position, false, true) - - return { "_index": 5, "name": tokens[0] } - -static func haxeLine(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("~") - - return { "_index": 7, "haxe": Extensions.unwrap(buffer.takeLine("lr")) } - -static func gather(buffer: HankBuffer, position: Position) -> Variant: - var depth: int = buffer.countConsecutive("-") - - buffer.skipWhitespace("") - - var label: Variant = buffer.expressionIfNext("(", ")") - - buffer.skipWhitespace("\n") - - return { "_index": 9, "label": label, "depth": depth, "expr": { "_index": 6 } } - -static func choice(buffer: HankBuffer, position: Position) -> Variant: - var symbol: String = buffer.peek(1) - var onceOnly: bool = symbol == "*" - var depth: int = buffer.countConsecutive(symbol) - - buffer.skipWhitespace("") - - var label: Variant = buffer.expressionIfNext("(", ")") - - buffer.skipWhitespace("") - - var condition: Variant = buffer.expressionIfNext("{", "}?") - - buffer.skipWhitespace("") - - var output: Output = Output.parse(buffer, false) - var divertTarget: Variant = output.takeInlineDivert() - - choices += 1 - - var tempNumber: int = choices - 1 - - return { "_index": 10, "c": { - "id": tempNumber, - "onceOnly": onceOnly, - "label": label, - "condition": condition, - "depth": depth, - "output": output, - "divertTarget": divertTarget, - "tags": ([] as Array[String]) - } } - -static func tag(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("#") - - var tagLine: String = Extensions.unwrap(buffer.takeLine("lr")) - var tags: Array[String] = Extensions.tokenize(tagLine) - var expr: Variant = Parser.parseExpr(buffer, position) - - if (expr._index == 10): - var _g: Variant = expr.c - var c: Variant = _g - c.set("tags", tags) + if (tk == null): + self.unexpected(tk) + return null else: - haxe_Log.trace.call("Warning! Can't apply tags to " + str(expr), { - "fileName": "../hank/Parser.hx", - "lineNumber": 234, - "className": "hank.Parser", - "methodName": "tag" - }) + if (tk._index == 2): + var _g: String = tk.s + var id: String = _g + return id + else: + self.unexpected(tk) + return null - return expr +func expr(e: Variant) -> Variant: + return e -static func haxeBlock(buffer: HankBuffer, position: Position) -> Variant: - buffer.drop("```\n") +func pmin(e: Variant) -> int: + return 0 - var rawContents: String = Extensions.unwrap(buffer.takeUntil((["```"] as Array[String]), false, true)).get("output") - var processedContents: String = "" - var blockBuffer: HankBuffer = HankBuffer.Dummy(rawContents) +func pmax(e: Variant) -> int: + return 0 + +func mk(e: Variant, pmin = null, pmax = null) -> Variant: + return e + +func isBlock(e) -> bool: + if (e == null): + return false + + var tempResult + + if true: + var _g: Variant = e + match (_g._index): + 2: + var _g1: String = _g.n + var _g2 = _g.t + var _g3 = _g.e + if true: + var t = _g2 + var e2 = _g3 + if (e2 != null): + tempResult = self.isBlock(e2) + else: + if (t != null): + if (t == null): + tempResult = false + else: + if (t._index == 2): + var _g4: Array[Variant] = t.fields + tempResult = true + else: + tempResult = false + else: + tempResult = false + 4: + var _g2: Array[Variant] = _g.e + tempResult = true + 6: + var _g1: String = _g.op + var _g2: Variant = _g.e1 + var _g3: Variant = _g.e2 + if true: + var e2: Variant = _g3 + tempResult = self.isBlock(e2) + 7: + var _g1: String = _g.op + var _g2: bool = _g.prefix + var _g3: Variant = _g.e + if true: + var prefix: bool = _g2 + var e2: Variant = _g3 + tempResult = !prefix && self.isBlock(e2) + 9: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e1 + var _g3 = _g.e2 + if true: + var e1: Variant = _g2 + var e2 = _g3 + if (e2 != null): + tempResult = self.isBlock(e2) + else: + tempResult = self.isBlock(e1) + 10: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e + if true: + var e2: Variant = _g2 + tempResult = self.isBlock(e2) + 11: + var _g1: String = _g.v + var _g2: Variant = _g.it + var _g3: Variant = _g.e + if true: + var e2: Variant = _g3 + tempResult = self.isBlock(e2) + 14: + var _g1: Array[Variant] = _g.args + var _g2: Variant = _g.e + var _g3 = _g.name + var _g4 = _g.ret + if true: + var e2: Variant = _g2 + tempResult = self.isBlock(e2) + 15: + var _g2 = _g.e + if true: + var e2 = _g2 + tempResult = e2 != null && self.isBlock(e2) + 20: + var _g1: Variant = _g.e + var _g2: String = _g.v + var _g3 = _g.t + var _g4: Variant = _g.ecatch + if true: + var e2: Variant = _g4 + tempResult = self.isBlock(e2) + 21: + var _g2: Array[Variant] = _g.fl + tempResult = true + 23: + var _g1: Variant = _g.e + var _g2: Array[Variant] = _g.cases + var _g3 = _g.defaultExpr + tempResult = true + 24: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e + if true: + var e2: Variant = _g2 + tempResult = self.isBlock(e2) + 25: + var _g1: String = _g.name + var _g2: Array[Variant] = _g.args + var _g3: Variant = _g.e + if true: + var e2: Variant = _g3 + tempResult = self.isBlock(e2) + _: + tempResult = false + + return tempResult + +func parseFullExpr(exprs: Array[Variant]) -> void: + var e = self.parseExpr() + + exprs.push_back(e) + + var tk = self.token() while true: - var nextLine: String = Extensions.unwrap(blockBuffer.takeLine("lr")) - if (nextLine == ",,,"): - var embeddedHankBlock: String = Extensions.unwrap(blockBuffer.takeUntil(([",,,"] as Array[String]), false, true)).get("output") - processedContents += "story.runEmbeddedHank(\"" + Parser.escapeQuotes(embeddedHankBlock) + "\"); " + var tempRight + var _g: Variant = e + if (_g._index == 2): + var _g1: String = _g.n + var _g2 = _g.t + var _g3 = _g.e + tempRight = true else: - if (StringTools.startsWith(nextLine, ",")): - nextLine = StringTools.trim(nextLine.substr(1)) - processedContents += "story.runEmbeddedHank(\"" + Parser.escapeQuotes(nextLine) + "\"); " + tempRight = false + if !(tk == { "_index": 9 } && e != null && tempRight): + break + e = self.parseStructure("var") + exprs.push_back(e) + tk = self.token() + + if (tk != { "_index": 10 } && tk != { "_index": 0 }): + if (self.isBlock(e)): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + self.unexpected(tk) + +func parseObject(p1) -> Variant: + var fl: Array[Variant] = [] + + while (true): + var tk = self.token() + var id = null + if (tk == null): + self.unexpected(tk) + break + else: + match (tk._index): + 1: + var _g: Variant = tk.c + var c: Variant = _g + if (!self.allowJSON): + self.unexpected(tk) + if (c._index == 2): + var _g2: String = c.s + var s: String = _g2 + id = s + else: + self.unexpected(tk) + 2: + var _g: String = tk.s + var i: String = _g + id = i + 7: + break + _: + self.unexpected(tk) + break + var t = self.token() + if (t != { "_index": 14 }): + self.unexpected(t) + fl.push_back({ + "name": id, + "e": self.parseExpr() + }) + tk = self.token() + if (tk == null): + self.unexpected(tk) + else: + match (tk._index): + 7: + break + 9: + pass + _: + self.unexpected(tk) + + return self.parseExprNext({ "_index": 21, "fl": fl }) + +func parseExpr(): + var tk = self.token() + + if (tk == null): + return self.unexpected(tk) + else: + match (tk._index): + 1: + var _g: Variant = tk.c + if true: + var c: Variant = _g + return self.parseExprNext({ "_index": 0, "c": c }) + 2: + var _g: String = tk.s + if true: + var id: String = _g + if true: + var e = self.parseStructure(id) + if (e == null): + e = { "_index": 1, "v": id } + return self.parseExprNext(e) + 3: + var _g: String = tk.s + var op: String = _g + if (op == "-"): + var start: int = 0 + var e = self.parseExpr() + if (e == null): + return self.makeUnop(op, e) + if true: + var _g2: Variant = e + if (_g2._index == 0): + var _g3: Variant = _g2.c + match (_g3._index): + 0: + var _g4: int = _g3.v + var i: int = _g4 + return { "_index": 0, "c": { "_index": 0, "v": -i } } + 1: + var _g4: float = _g3.f + var f: float = _g4 + return { "_index": 0, "c": { "_index": 1, "f": -f } } + _: + return self.makeUnop(op, e) + else: + return self.makeUnop(op, e) + var tempLeft + var this1: Variant = self.opPriority + tempLeft = this1.__get(op) + if (tempLeft < 0): + return self.makeUnop(op, self.parseExpr()) + return self.unexpected(tk) + 4: + tk = self.token() + if (tk == { "_index": 5 }): + if true: + var tk2 = { "_index": 3, "s": "->" } + var t = self.token() + if (!Type.enumEq(t, tk2)): + self.unexpected(t) + var eret = self.parseExpr() + return { "_index": 14, "args": ([] as Array[Variant]), "e": { "_index": 15, "e": eret } } + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + var e = self.parseExpr() + tk = self.token() + if (tk == null): + pass + else: + match (tk._index): + 5: + return self.parseExprNext({ "_index": 3, "e": e }) + 9: + if true: + var _g: Variant = e + if (_g._index == 1): + var _g2: String = _g.v + if true: + var v: String = _g2 + return self.parseLambda(([{ + "name": v + }] as Array[Variant]), 0) + else: + pass + 14: + var t: Variant = self.parseType() + tk = self.token() + if (tk == null): + pass + else: + match (tk._index): + 5: + return self.parseExprNext({ "_index": 26, "e": e, "t": t }) + 9: + if true: + var _g: Variant = e + if (_g._index == 1): + var _g2: String = _g.v + if true: + var v: String = _g2 + return self.parseLambda(([{ + "name": v, + "t": t + }] as Array[Variant]), 0) + else: + pass + _: + pass + _: + pass + return self.unexpected(tk) + 6: + tk = self.token() + if (tk == null): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + match (tk._index): + 1: + var _g: Variant = tk.c + if true: + var c: Variant = _g + if (self.allowJSON): + if (c._index == 2): + var _g2: String = c.s + if true: + var tk2 = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk2, _this.head) + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (tk2 == null): + pass + else: + if (tk2._index == 14): + return self.parseExprNext(self.parseObject(0)) + else: + pass + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + 2: + var _g: String = tk.s + if true: + var tk2 = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk2, _this.head) + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (tk2 == null): + pass + else: + if (tk2._index == 14): + return self.parseExprNext(self.parseObject(0)) + else: + pass + 7: + return self.parseExprNext({ "_index": 21, "fl": ([] as Array[Variant]) }) + _: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + var a: Array[Variant] = [] + while (true): + self.parseFullExpr(a) + tk = self.token() + if (tk == { "_index": 7 } || self.resumeErrors && tk == { "_index": 0 }): + break + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return { "_index": 4, "e": a } + 11: + var a: Array[Variant] = [] + tk = self.token() + while (tk != { "_index": 12 } && (!self.resumeErrors || tk != { "_index": 0 })): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + a.push_back(self.parseExpr()) + tk = self.token() + if (tk == { "_index": 9 }): + tk = self.token() + if (a.size() == 1 && a[0] != null): + if true: + var _g: Variant = a[0] + match (_g._index): + 10: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e + if true: + var tempRight + if true: + self.uid += 1 + tempRight = self.uid - 1 + var tmp: String = "__a_" + str(tempRight) + var tempExpr + if true: + var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) } + tempExpr = e + var e: Variant = tempExpr + return self.parseExprNext(e) + 11: + var _g1: String = _g.v + var _g2: Variant = _g.it + var _g3: Variant = _g.e + if true: + var tempRight1 + if true: + self.uid += 1 + tempRight1 = self.uid - 1 + var tmp: String = "__a_" + str(tempRight1) + var tempExpr1 + if true: + var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) } + tempExpr1 = e + var e: Variant = tempExpr1 + return self.parseExprNext(e) + 24: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e + if true: + var tempRight2 + if true: + self.uid += 1 + tempRight2 = self.uid - 1 + var tmp: String = "__a_" + str(tempRight2) + var tempExpr2 + if true: + var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) } + tempExpr2 = e + var e: Variant = tempExpr2 + return self.parseExprNext(e) + _: + pass + return self.parseExprNext({ "_index": 17, "e": a }) + 15: + var _g: String = tk.s + if true: + var id: String = _g + if (self.allowMetadata): + var args = self.parseMetaArgs() + var tempResult + if true: + var e: Variant = { "_index": 25, "name": id, "args": args, "e": self.parseExpr() } + tempResult = e + return tempResult + else: + return self.unexpected(tk) + _: + return self.unexpected(tk) + +func parseLambda(args: Array[Variant], pmin) -> Variant: + while (true): + var id: String = self.getIdent() + var tempMaybeCType + if (self.maybe({ "_index": 14 })): + tempMaybeCType = self.parseType() + else: + tempMaybeCType = null + var t = tempMaybeCType + args.push_back({ + "name": id, + "t": t + }) + var tk = self.token() + if (tk == null): + self.unexpected(tk) + break + else: + match (tk._index): + 5: + break + 9: + pass + _: + self.unexpected(tk) + break + + if true: + var tk = { "_index": 3, "s": "->" } + var t = self.token() + if (!Type.enumEq(t, tk)): + self.unexpected(t) + + var eret = self.parseExpr() + + return { "_index": 14, "args": args, "e": { "_index": 15, "e": eret } } + +func parseMetaArgs(): + var tk = self.token() + + if (tk != { "_index": 4 }): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return null + + var args: Array[Variant] = ([] as Array[Variant]) + + tk = self.token() + + if (tk != { "_index": 5 }): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + while (true): + args.push_back(self.parseExpr()) + if true: + var _g = self.token() + if (_g == null): + var tk2 = _g + self.unexpected(tk2) + else: + match (_g._index): + 5: + break + 9: + pass + _: + var tk2 = _g + self.unexpected(tk2) + + return args + +func mapCompr(tmp: String, e: Variant): + if (e == null): + return null + + var tempExpr + + match (e._index): + 3: + var _g: Variant = e.e + if true: + var e2: Variant = _g + tempExpr = { "_index": 3, "e": self.mapCompr(tmp, e2) } + 4: + var _g: Array[Variant] = e.e + if (_g.size() == 1): + var _g2: Variant = _g[0] + if true: + var e2: Variant = _g2 + tempExpr = { "_index": 4, "e": ([self.mapCompr(tmp, e2)] as Array[Variant]) } else: - processedContents += nextLine + " " - if !(!blockBuffer.isEmpty()): + tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) } + 9: + var _g: Variant = e.cond + var _g1: Variant = e.e1 + var _g2 = e.e2 + if true: + var cond: Variant = _g + var e1: Variant = _g1 + var e2 = _g2 + if (e2 == null): + tempExpr = { "_index": 9, "cond": cond, "e1": self.mapCompr(tmp, e1), "e2": null } + else: + tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) } + 10: + var _g: Variant = e.cond + var _g1: Variant = e.e + if true: + var cond: Variant = _g + var e2: Variant = _g1 + tempExpr = { "_index": 10, "cond": cond, "e": self.mapCompr(tmp, e2) } + 11: + var _g: String = e.v + var _g1: Variant = e.it + var _g2: Variant = e.e + if true: + var v: String = _g + var it: Variant = _g1 + var e2: Variant = _g2 + tempExpr = { "_index": 11, "v": v, "it": it, "e": self.mapCompr(tmp, e2) } + 24: + var _g: Variant = e.cond + var _g1: Variant = e.e + if true: + var cond: Variant = _g + var e2: Variant = _g1 + tempExpr = { "_index": 24, "cond": cond, "e": self.mapCompr(tmp, e2) } + _: + tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) } + + return tempExpr + +func makeUnop(op: String, e): + if (e == null && self.resumeErrors): + return null + + var tempResult + + if true: + var _g: Variant = e + match (_g._index): + 6: + var _g1: String = _g.op + var _g2: Variant = _g.e1 + var _g3: Variant = _g.e2 + if true: + var bop: String = _g1 + var e1: Variant = _g2 + var e2: Variant = _g3 + if true: + var e3: Variant = { "_index": 6, "op": bop, "e1": self.makeUnop(op, e1), "e2": e2 } + tempResult = e3 + 22: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e1 + var _g3: Variant = _g.e2 + if true: + var e1: Variant = _g1 + var e2: Variant = _g2 + var e3: Variant = _g3 + if true: + var e4: Variant = { "_index": 22, "cond": self.makeUnop(op, e1), "e1": e2, "e2": e3 } + tempResult = e4 + _: + tempResult = { "_index": 7, "op": op, "prefix": true, "e": e } + + return tempResult + +func makeBinop(op: String, e1: Variant, e) -> Variant: + if (e == null && self.resumeErrors): + return { "_index": 6, "op": op, "e1": e1, "e2": e } + + var tempResult + + if true: + var _g: Variant = e + match (_g._index): + 6: + var _g1: String = _g.op + var _g2: Variant = _g.e1 + var _g3: Variant = _g.e2 + if true: + var op2: String = _g1 + var e2: Variant = _g2 + var e3: Variant = _g3 + var tempLeft + if true: + var this1: Variant = self.opPriority + tempLeft = this1.__get(op) + var tempRight + if true: + var this1: Variant = self.opPriority + tempRight = this1.__get(op2) + var tempBool + if true: + var this1: Variant = self.opRightAssoc + tempBool = this1.exists(op) + if (tempLeft <= tempRight && !tempBool): + var e4: Variant = { "_index": 6, "op": op2, "e1": self.makeBinop(op, e1, e2), "e2": e3 } + tempResult = e4 + else: + tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e } + 22: + var _g1: Variant = _g.cond + var _g2: Variant = _g.e1 + var _g3: Variant = _g.e2 + if true: + var e2: Variant = _g1 + var e3: Variant = _g2 + var e4: Variant = _g3 + var tempBool1 + if true: + var this1: Variant = self.opRightAssoc + tempBool1 = this1.exists(op) + if (tempBool1): + tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e } + else: + var e5: Variant = { "_index": 22, "cond": self.makeBinop(op, e1, e2), "e1": e3, "e2": e4 } + tempResult = e5 + _: + tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e } + + return tempResult + +func parseStructure(id: String): + var tempResult + + match (id): + "break": + tempResult = { "_index": 12 } + "continue": + tempResult = { "_index": 13 } + "do": + var e = self.parseExpr() + var tk = self.token() + if (tk == null): + self.unexpected(tk) + else: + if (tk._index == 2): + var _g: String = tk.s + if (_g == "while"): + pass + else: + self.unexpected(tk) + else: + self.unexpected(tk) + var econd = self.parseExpr() + tempResult = { "_index": 24, "cond": econd, "e": e } + "else": + tempResult = self.unexpected({ "_index": 2, "s": id }) + "for": + if true: + var t = self.token() + if (t != { "_index": 4 }): + self.unexpected(t) + var vname: String = self.getIdent() + if true: + var tk = { "_index": 2, "s": "in" } + var t = self.token() + if (!Type.enumEq(t, tk)): + self.unexpected(t) + var eiter = self.parseExpr() + if true: + var t = self.token() + if (t != { "_index": 5 }): + self.unexpected(t) + var e = self.parseExpr() + tempResult = { "_index": 11, "v": vname, "it": eiter, "e": e } + "function": + var tk = self.token() + var name = null + if (tk == null): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + if (tk._index == 2): + var _g: String = tk.s + var id2: String = _g + name = id2 + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + var inf: Variant = self.parseFunctionDecl() + tempResult = { "_index": 14, "args": inf.get("args"), "e": inf.get("body"), "name": name, "ret": inf.get("ret") } + "if": + if true: + var t = self.token() + if (t != { "_index": 4 }): + self.unexpected(t) + var cond = self.parseExpr() + if true: + var t = self.token() + if (t != { "_index": 5 }): + self.unexpected(t) + var e1 = self.parseExpr() + var e2 = null + var semic: bool = false + var tk = self.token() + if (tk == { "_index": 10 }): + semic = true + tk = self.token() + if (Type.enumEq(tk, { "_index": 2, "s": "else" })): + e2 = self.parseExpr() + else: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (semic): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new({ "_index": 10 }, _this.head) + tempResult = { "_index": 9, "cond": cond, "e1": e1, "e2": e2 } + "inline": + if (!self.maybe({ "_index": 2, "s": "function" })): + self.unexpected({ "_index": 2, "s": "inline" }) + return self.parseStructure("function") + "new": + var a: Array[String] = [] + a.push_back(self.getIdent()) + while (true): + var tk = self.token() + if (tk == null): + self.unexpected(tk) + break + else: + match (tk._index): + 4: + break + 8: + a.push_back(self.getIdent()) + _: + self.unexpected(tk) + break + var args: Array[Variant] = self.parseExprList({ "_index": 5 }) + if true: + var tempString + if true: + var result: String = "" + var len: int = a.size() + if true: + var _g: int = 0 + var _g1: int = len + while (_g < _g1): + var tempNumber + if true: + _g += 1 + tempNumber = _g - 1 + var i: int = tempNumber + var tempString1 + if (i == len - 1): + tempString1 = "" + else: + tempString1 = "." + result += str(a[i]) + (tempString1) + tempString = result + var e: Variant = { "_index": 18, "cl": tempString, "params": args } + tempResult = e + "return": + var tk = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + var tempMaybeExpr + if (tk == { "_index": 10 }): + tempMaybeExpr = null + else: + tempMaybeExpr = self.parseExpr() + var e = tempMaybeExpr + tempResult = { "_index": 15, "e": e } + "switch": + var e = self.parseExpr() + var def = null + var cases: Array[Variant] = ([] as Array[Variant]) + if true: + var t = self.token() + if (t != { "_index": 6 }): + self.unexpected(t) + while (true): + var tk = self.token() + if (tk == null): + self.unexpected(tk) + break + else: + match (tk._index): + 2: + var _g: String = tk.s + match (_g): + "case": + var c: Variant = { + "values": ([] as Array[Variant]), + "expr": null + } + cases.push_back(c) + while (true): + var e2 = self.parseExpr() + c.get("values").push_back(e2) + tk = self.token() + if (tk == null): + self.unexpected(tk) + break + else: + match (tk._index): + 9: + pass + 14: + break + _: + self.unexpected(tk) + break + var exprs: Array[Variant] = ([] as Array[Variant]) + while (true): + tk = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (tk == null): + self.parseFullExpr(exprs) + else: + match (tk._index): + 0: + if (self.resumeErrors): + break + else: + self.parseFullExpr(exprs) + 2: + var _g2: String = tk.s + match (_g2): + "case", "default": + break + _: + self.parseFullExpr(exprs) + 7: + break + _: + self.parseFullExpr(exprs) + var tempRight + if (exprs.size() == 1): + tempRight = exprs[0] + else: + if (exprs.size() == 0): + tempRight = { "_index": 4, "e": ([] as Array[Variant]) } + else: + tempRight = { "_index": 4, "e": exprs } + c.set("expr", tempRight) + "default": + if (def != null): + self.unexpected(tk) + if true: + var t = self.token() + if (t != { "_index": 14 }): + self.unexpected(t) + var exprs: Array[Variant] = ([] as Array[Variant]) + while (true): + tk = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (tk == null): + self.parseFullExpr(exprs) + else: + match (tk._index): + 0: + if (self.resumeErrors): + break + else: + self.parseFullExpr(exprs) + 2: + var _g2: String = tk.s + match (_g2): + "case", "default": + break + _: + self.parseFullExpr(exprs) + 7: + break + _: + self.parseFullExpr(exprs) + var tempRight1 + if (exprs.size() == 1): + tempRight1 = exprs[0] + else: + if (exprs.size() == 0): + tempRight1 = { "_index": 4, "e": ([] as Array[Variant]) } + else: + tempRight1 = { "_index": 4, "e": exprs } + def = tempRight1 + _: + self.unexpected(tk) + break + 7: + break + _: + self.unexpected(tk) + break + tempResult = { "_index": 23, "e": e, "cases": cases, "defaultExpr": def } + "throw": + var e = self.parseExpr() + tempResult = { "_index": 19, "e": e } + "try": + var e = self.parseExpr() + if true: + var tk = { "_index": 2, "s": "catch" } + var t = self.token() + if (!Type.enumEq(t, tk)): + self.unexpected(t) + if true: + var t = self.token() + if (t != { "_index": 4 }): + self.unexpected(t) + var vname: String = self.getIdent() + if true: + var t = self.token() + if (t != { "_index": 14 }): + self.unexpected(t) + var t = null + if (self.allowTypes): + t = self.parseType() + else: + var tk = { "_index": 2, "s": "Dynamic" } + var t2 = self.token() + if (!Type.enumEq(t2, tk)): + self.unexpected(t2) + var t1 = self.token() + if (t1 != { "_index": 5 }): + self.unexpected(t1) + var ec = self.parseExpr() + tempResult = { "_index": 20, "e": e, "v": vname, "t": t, "ecatch": ec } + "var": + var ident: String = self.getIdent() + var tk = self.token() + var t = null + if (tk == { "_index": 14 } && self.allowTypes): + t = self.parseType() + tk = self.token() + var e = null + if (Type.enumEq(tk, { "_index": 3, "s": "=" })): + e = self.parseExpr() + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + tempResult = { "_index": 2, "n": ident, "t": t, "e": e } + "while": + var econd = self.parseExpr() + var e = self.parseExpr() + tempResult = { "_index": 10, "cond": econd, "e": e } + _: + tempResult = null + + return tempResult + +func parseExprNext(e1: Variant) -> Variant: + var tk = self.token() + + if (tk == null): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return e1 + else: + match (tk._index): + 3: + var _g: String = tk.s + var op: String = _g + if (op == "->"): + match (e1._index): + 1: + var _g2: String = e1.v + if true: + var i: String = _g2 + if true: + var eret = self.parseExpr() + return { "_index": 14, "args": ([{ + "name": i + }] as Array[Variant]), "e": { "_index": 15, "e": eret } } + 3: + var _g2: Variant = e1.e + if true: + var _hx_tmp + _hx_tmp = _g2 + if ((_hx_tmp)._index == 1): + var _g3: String = _hx_tmp.v + if true: + var i: String = _g3 + if true: + var eret = self.parseExpr() + return { "_index": 14, "args": ([{ + "name": i + }] as Array[Variant]), "e": { "_index": 15, "e": eret } } + else: + pass + 26: + var _g2: Variant = e1.e + var _g1: Variant = e1.t + if true: + var _hx_tmp + _hx_tmp = _g2 + if ((_hx_tmp)._index == 1): + var _g3: String = _hx_tmp.v + if true: + var i: String = _g3 + var t: Variant = _g1 + if true: + var eret = self.parseExpr() + return { "_index": 14, "args": ([{ + "name": i, + "t": t + }] as Array[Variant]), "e": { "_index": 15, "e": eret } } + else: + pass + _: + pass + self.unexpected(tk) + var tempLeft + var this1: Variant = self.opPriority + tempLeft = this1.__get(op) + if (tempLeft == -1): + var tempBool + if (e1._index == 3): + var _g2: Variant = e1.e + tempBool = true + else: + tempBool = false + if (self.isBlock(e1) || (tempBool)): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return e1 + return self.parseExprNext({ "_index": 7, "op": op, "prefix": false, "e": e1 }) + return self.makeBinop(op, e1, self.parseExpr()) + 4: + var tempExpr + var e: Variant = { "_index": 8, "e": e1, "params": self.parseExprList({ "_index": 5 }) } + tempExpr = e + return self.parseExprNext(tempExpr) + 8: + var field: String = self.getIdent() + return self.parseExprNext({ "_index": 5, "e": e1, "f": field }) + 11: + var e2 = self.parseExpr() + if true: + var t = self.token() + if (t != { "_index": 12 }): + self.unexpected(t) + return self.parseExprNext({ "_index": 16, "e": e1, "index": e2 }) + 13: + var e2 = self.parseExpr() + if true: + var t = self.token() + if (t != { "_index": 14 }): + self.unexpected(t) + var e3 = self.parseExpr() + return { "_index": 22, "cond": e1, "e1": e2, "e2": e3 } + _: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return e1 + +func parseFunctionArgs() -> Array[Variant]: + var args: Array[Variant] = [] + var tk = self.token() + + if (tk != { "_index": 5 }): + var done: bool = false + while (!done): + var name = null + var opt: bool = false + if (tk == null): + pass + else: + if (tk._index == 13): + opt = true + tk = self.token() + else: + pass + if (tk == null): + self.unexpected(tk) + break + else: + if (tk._index == 2): + var _g: String = tk.s + var id: String = _g + name = id + else: + self.unexpected(tk) + break + var arg: Variant = { + "name": name + } + args.push_back(arg) + if (opt): + arg.set("opt", true) + if (self.allowTypes): + if (self.maybe({ "_index": 14 })): + arg.set("t", self.parseType()) + if (self.maybe({ "_index": 3, "s": "=" })): + arg.set("value", self.parseExpr()) + tk = self.token() + if (tk == null): + self.unexpected(tk) + else: + match (tk._index): + 5: + done = true + 9: + tk = self.token() + _: + self.unexpected(tk) + + return args + +func parseFunctionDecl() -> Variant: + var t = self.token() + + if (t != { "_index": 4 }): + self.unexpected(t) + + var args: Array[Variant] = self.parseFunctionArgs() + var ret = null + + if (self.allowTypes): + var tk = self.token() + if (tk != { "_index": 14 }): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + ret = self.parseType() + + return { + "args": args, + "ret": ret, + "body": self.parseExpr() + } + +func parsePath() -> Array[String]: + var path: Array[String] = ([self.getIdent()] as Array[String]) + + while (true): + var t = self.token() + if (t != { "_index": 8 }): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + break + path.push_back(self.getIdent()) + + return path + +func parseType() -> Variant: + var _gthis: Parser = self + var t = self.token() + + if (t == null): + return self.unexpected(t) + else: + match (t._index): + 2: + var _g: String = t.s + if true: + var v: String = _g + if true: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + var path: Array[String] = self.parsePath() + var params = null + t = self.token() + if (t == null): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + else: + if (t._index == 3): + var _g2: String = t.s + if true: + var op: String = _g2 + if (op == "<"): + params = ([] as Array[Variant]) + while (true): + params.push_back(self.parseType()) + t = self.token() + if (t == null): + pass + else: + match (t._index): + 3: + var _g3: String = t.s + if true: + var op2: String = _g3 + if true: + if (op2 == ">"): + break + var tempMaybeNumber + if (0 < op2.length()): + tempMaybeNumber = op2.unicode_at(0) + else: + tempMaybeNumber = null + if ((tempMaybeNumber) == 62): + if true: + var _this: haxe_ds_GenericStack = self.tokens + var item: Variant = { "_index": 3, "s": op2.substr(1) } + _this.head = haxe_ds_GenericCell.new(item, _this.head) + break + 9: + continue + _: + pass + self.unexpected(t) + break + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + return self.parseTypeNext({ "_index": 0, "path": path, "params": params }) + 4: + var a = self.token() + var b = self.token() + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(b, _this.head) + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(a, _this.head) + var withReturn = func(args: Array[Variant]) -> Variant: + if true: + var _g = _gthis.token() + if (_g == null): + var t2 = _g + _gthis.unexpected(t2) + else: + if (_g._index == 3): + var _g1: String = _g.s + if (_g1 == "->"): + pass + else: + var t2 = _g + _gthis.unexpected(t2) + else: + var t2 = _g + _gthis.unexpected(t2) + return { "_index": 1, "args": args, "ret": _gthis.parseType() } + if (a == null): + var t2: Variant = self.parseType() + var tempResult + if true: + var _g = self.token() + if (_g == null): + var t3 = _g + tempResult = self.unexpected(t3) + else: + match (_g._index): + 5: + tempResult = self.parseTypeNext({ "_index": 3, "t": t2 }) + 9: + var args: Array[Variant] = ([t2] as Array[Variant]) + while (true): + args.push_back(self.parseType()) + if (!self.maybe({ "_index": 9 })): + break + if true: + var t3 = self.token() + if (t3 != { "_index": 5 }): + self.unexpected(t3) + tempResult = withReturn.call(args) + _: + var t3 = _g + tempResult = self.unexpected(t3) + return tempResult + else: + match (a._index): + 2: + var _g: String = a.s + if (b == null): + var t2: Variant = self.parseType() + var tempResult1 + if true: + var _g2 = self.token() + if (_g2 == null): + var t3 = _g2 + tempResult1 = self.unexpected(t3) + else: + match (_g2._index): + 5: + tempResult1 = self.parseTypeNext({ "_index": 3, "t": t2 }) + 9: + var args: Array[Variant] = ([t2] as Array[Variant]) + while (true): + args.push_back(self.parseType()) + if (!self.maybe({ "_index": 9 })): + break + if true: + var t3 = self.token() + if (t3 != { "_index": 5 }): + self.unexpected(t3) + tempResult1 = withReturn.call(args) + _: + var t3 = _g2 + tempResult1 = self.unexpected(t3) + return tempResult1 + else: + if (b._index == 14): + var tempArray + if true: + var _g2: Array[Variant] = ([] as Array[Variant]) + if true: + var _g1: int = 0 + var _g3: Array[Variant] = self.parseFunctionArgs() + while (_g1 < _g3.size()): + var arg: Variant = _g3[_g1] + _g1 += 1 + if true: + var _g4 = arg.get("value") + if (_g4 == null): + pass + else: + var v = _g4 + if (!self.resumeErrors): + assert(false, str({ "_index": 9, "msg": "Default values not allowed in function types" })) + var tempCType + if (arg.get("opt")): + tempCType = { "_index": 4, "t": arg.get("t") } + else: + tempCType = arg.get("t") + _g2.push_back({ "_index": 5, "n": arg.get("name"), "t": tempCType }) + tempArray = _g2 + var args: Array[Variant] = tempArray + return withReturn.call(args) + else: + var t2: Variant = self.parseType() + var tempResult2 + if true: + var _g2 = self.token() + if (_g2 == null): + var t3 = _g2 + tempResult2 = self.unexpected(t3) + else: + match (_g2._index): + 5: + tempResult2 = self.parseTypeNext({ "_index": 3, "t": t2 }) + 9: + var args: Array[Variant] = ([t2] as Array[Variant]) + while (true): + args.push_back(self.parseType()) + if (!self.maybe({ "_index": 9 })): + break + if true: + var t3 = self.token() + if (t3 != { "_index": 5 }): + self.unexpected(t3) + tempResult2 = withReturn.call(args) + _: + var t3 = _g2 + tempResult2 = self.unexpected(t3) + return tempResult2 + 5: + var tempArray1 + if true: + var _g: Array[Variant] = ([] as Array[Variant]) + if true: + var _g1: int = 0 + var _g2: Array[Variant] = self.parseFunctionArgs() + while (_g1 < _g2.size()): + var arg: Variant = _g2[_g1] + _g1 += 1 + if true: + var _g3 = arg.get("value") + if (_g3 == null): + pass + else: + var v = _g3 + if (!self.resumeErrors): + assert(false, str({ "_index": 9, "msg": "Default values not allowed in function types" })) + var tempCType1 + if (arg.get("opt")): + tempCType1 = { "_index": 4, "t": arg.get("t") } + else: + tempCType1 = arg.get("t") + _g.push_back({ "_index": 5, "n": arg.get("name"), "t": tempCType1 }) + tempArray1 = _g + var args: Array[Variant] = tempArray1 + return withReturn.call(args) + _: + var t2: Variant = self.parseType() + var tempResult3 + if true: + var _g = self.token() + if (_g == null): + var t3 = _g + tempResult3 = self.unexpected(t3) + else: + match (_g._index): + 5: + tempResult3 = self.parseTypeNext({ "_index": 3, "t": t2 }) + 9: + var args: Array[Variant] = ([t2] as Array[Variant]) + while (true): + args.push_back(self.parseType()) + if (!self.maybe({ "_index": 9 })): + break + if true: + var t3 = self.token() + if (t3 != { "_index": 5 }): + self.unexpected(t3) + tempResult3 = withReturn.call(args) + _: + var t3 = _g + tempResult3 = self.unexpected(t3) + return tempResult3 + 6: + var fields: Array[Variant] = ([] as Array[Variant]) + var meta = null + while (true): + t = self.token() + if (t == null): + self.unexpected(t) + break + else: + match (t._index): + 2: + var _g: String = t.s + if (_g == "var"): + var name: String = self.getIdent() + if true: + var t2 = self.token() + if (t2 != { "_index": 14 }): + self.unexpected(t2) + fields.push_back({ + "name": name, + "t": self.parseType(), + "meta": meta + }) + meta = null + if true: + var t2 = self.token() + if (t2 != { "_index": 10 }): + self.unexpected(t2) + else: + var name: String = _g + var t1 = self.token() + if (t1 != { "_index": 14 }): + self.unexpected(t1) + fields.push_back({ + "name": name, + "t": self.parseType(), + "meta": meta + }) + t = self.token() + if (t == null): + self.unexpected(t) + else: + match (t._index): + 7: + break + 9: + pass + _: + self.unexpected(t) + 7: + break + 15: + var _g: String = t.s + if true: + var name: String = _g + if true: + if (meta == null): + meta = ([] as Array[Variant]) + meta.push_back({ + "name": name, + "params": self.parseMetaArgs() + }) + _: + self.unexpected(t) + break + return self.parseTypeNext({ "_index": 2, "fields": fields }) + _: + return self.unexpected(t) + +func parseTypeNext(t: Variant) -> Variant: + var tk = self.token() + + if (tk == null): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return t + else: + if (tk._index == 3): + var _g: String = tk.s + var op: String = _g + if (op != "->"): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return t + else: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + return t + + var t2: Variant = self.parseType() + + if (t2._index == 1): + var _g: Array[Variant] = t2.args + var _g1: Variant = t2.ret + var args: Array[Variant] = _g + args.push_front(t) + return t2 + else: + return { "_index": 1, "args": ([t] as Array[Variant]), "ret": t2 } + +func parseExprList(etk) -> Array[Variant]: + var args: Array[Variant] = [] + var tk = self.token() + + if (tk == etk): + return args + + var _this: haxe_ds_GenericStack = self.tokens + + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + + while (true): + args.push_back(self.parseExpr()) + tk = self.token() + if (tk == null): + if (tk == etk): + break + self.unexpected(tk) + break + else: + if (tk._index == 9): + pass + else: + if (tk == etk): + break + self.unexpected(tk) + break + + return args + +func parseModule(content: String, origin = "hscript") -> Array[Variant]: + self.initParser(origin) + self.input = content + self.readPos = 0 + self.allowTypes = true + self.allowMetadata = true + + var decls: Array[Variant] = ([] as Array[Variant]) + + while (true): + var tk = self.token() + if (tk == { "_index": 0 }): + break + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + decls.push_back(self.parseModuleDecl()) + + return decls + +func parseMetadata() -> Array[Variant]: + var meta: Array[Variant] = ([] as Array[Variant]) + + while (true): + var tk = self.token() + if (tk == null): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + break + else: + if (tk._index == 15): + var _g: String = tk.s + var name: String = _g + meta.push_back({ + "name": name, + "params": self.parseMetaArgs() + }) + else: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + break + + return meta + +func parseParams() -> Variant: + if (self.maybe({ "_index": 3, "s": "<" })): + if (!self.resumeErrors): + assert(false, str({ "_index": 7, "op": "Unsupported class type parameters" })) + + return { + } + +func parseModuleDecl() -> Variant: + var meta: Array[Variant] = self.parseMetadata() + var ident: String = self.getIdent() + var isPrivate: bool = false + var isExtern: bool = false + + while (true): + match (ident): + "extern": + isExtern = true + "private": + isPrivate = true + _: + break + ident = self.getIdent() + + match (ident): + "class": + var name: String = self.getIdent() + var params: Variant = self.parseParams() + var extend = null + var implement: Array[Variant] = ([] as Array[Variant]) + while (true): + var t = self.token() + if (t == null): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + break + else: + if (t._index == 2): + var _g: String = t.s + match (_g): + "extends": + extend = self.parseType() + "implements": + implement.push_back(self.parseType()) + _: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + break + else: + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + break + var fields: Array[Variant] = ([] as Array[Variant]) + if true: + var t = self.token() + if (t != { "_index": 6 }): + self.unexpected(t) + while (!self.maybe({ "_index": 7 })): + fields.push_back(self.parseField()) + return { "_index": 2, "c": { + "name": name, + "meta": meta, + "params": params, + "extend": extend, + "implement": implement, + "fields": fields, + "isPrivate": isPrivate, + "isExtern": isExtern + } } + "import": + var path: Array[String] = ([self.getIdent()] as Array[String]) + var star: bool = false + while (true): + var t = self.token() + if (t != { "_index": 8 }): + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(t, _this.head) + break + t = self.token() + if (t == null): + self.unexpected(t) + else: + match (t._index): + 2: + var _g: String = t.s + var id: String = _g + path.push_back(id) + 3: + var _g: String = t.s + if (_g == "*"): + star = true + else: + self.unexpected(t) + _: + self.unexpected(t) + if true: + var t = self.token() + if (t != { "_index": 10 }): + self.unexpected(t) + return { "_index": 1, "path": path, "everything": star } + "package": + var path: Array[String] = self.parsePath() + if true: + var t = self.token() + if (t != { "_index": 10 }): + self.unexpected(t) + return { "_index": 0, "path": path } + "typedef": + var name: String = self.getIdent() + var params: Variant = self.parseParams() + if true: + var tk = { "_index": 3, "s": "=" } + var t = self.token() + if (!Type.enumEq(t, tk)): + self.unexpected(t) + var t: Variant = self.parseType() + return { "_index": 3, "c": { + "name": name, + "meta": meta, + "params": params, + "isPrivate": isPrivate, + "t": t + } } + _: + self.unexpected({ "_index": 2, "s": ident }) + + return null + +func parseField() -> Variant: + var meta: Array[Variant] = self.parseMetadata() + var access: Array[FieldAccess.FieldAccess] = ([] as Array[FieldAccess.FieldAccess]) + + while (true): + var id: String = self.getIdent() + match (id): + "function": + var name: String = self.getIdent() + var inf: Variant = self.parseFunctionDecl() + return { + "name": name, + "meta": meta, + "access": access, + "kind": { "_index": 0, "f": { + "args": inf.get("args"), + "expr": inf.get("body"), + "ret": inf.get("ret") + } } + } + "inline": + access.push_back(FieldAccess.FieldAccess.AInline) + "macro": + access.push_back(FieldAccess.FieldAccess.AMacro) + "override": + access.push_back(FieldAccess.FieldAccess.AOverride) + "private": + access.push_back(FieldAccess.FieldAccess.APrivate) + "public": + access.push_back(FieldAccess.FieldAccess.APublic) + "static": + access.push_back(FieldAccess.FieldAccess.AStatic) + "var": + var name: String = self.getIdent() + var __get = null + var __set = null + if (self.maybe({ "_index": 4 })): + __get = self.getIdent() + if true: + var t = self.token() + if (t != { "_index": 9 }): + self.unexpected(t) + __set = self.getIdent() + if true: + var t = self.token() + if (t != { "_index": 5 }): + self.unexpected(t) + var tempMaybeCType + if (self.maybe({ "_index": 14 })): + tempMaybeCType = self.parseType() + else: + tempMaybeCType = null + var type = tempMaybeCType + var tempMaybeExpr + if (self.maybe({ "_index": 3, "s": "=" })): + tempMaybeExpr = self.parseExpr() + else: + tempMaybeExpr = null + var expr = tempMaybeExpr + if (expr != null): + if (self.isBlock(expr)): + self.maybe({ "_index": 10 }) + else: + var t = self.token() + if (t != { "_index": 10 }): + self.unexpected(t) + else: + var tempBool + if (type == null): + tempBool = false + else: + if (type._index == 2): + var _g: Array[Variant] = type.fields + tempBool = true + else: + tempBool = false + if (type != null && (tempBool)): + self.maybe({ "_index": 10 }) + else: + var t = self.token() + if (t != { "_index": 10 }): + self.unexpected(t) + return { + "name": name, + "meta": meta, + "access": access, + "kind": { "_index": 1, "v": { + "get": __get, + "set": __set, + "type": type, + "expr": expr + } } + } + _: + self.unexpected({ "_index": 2, "s": id }) + break + + return null + +func readChar() -> int: + var s: String = self.input + + self.readPos += 1 + + var tempNumber: int = self.readPos - 1 + var index: int = tempNumber + var tempResult: int = s.unicode_at.call(index) + + return tempResult + +func readString(until: int) -> String: + var c: int = 0 + var b_b: String = "" + var esc: bool = false + var old: int = self.line + var s: String = self.input + + while (true): + var tempNumber + if true: + var s2: String = self.input + var tempNumber1 + if true: + self.readPos += 1 + tempNumber1 = self.readPos - 1 + var index: int = tempNumber1 + tempNumber = s2.unicode_at.call(index) + var c2: int = tempNumber + if (esc): + esc = false + match (c2): + 47: + if (self.allowJSON): + b_b += char(c2) + else: + self.invalidChar(c2) + 34, 39, 92: + b_b += char(c2) + 110: + b_b += "\n" + 114: + b_b += "\r" + 116: + b_b += "\t" + 117: + if (!self.allowJSON): + self.invalidChar(c2) + var k: int = 0 + var _g: int = 0 + while (_g < 4): + var tempNumber2 + _g += 1 + tempNumber2 = _g - 1 + var i: int = tempNumber2 + k <<= 4 + var tempNumber3 + if true: + var s2: String = self.input + var tempNumber4 + if true: + self.readPos += 1 + tempNumber4 = self.readPos - 1 + var index: int = tempNumber4 + tempNumber3 = s2.unicode_at.call(index) + var char2: int = tempNumber3 + match (char2): + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + k += char2 - 48 + 65, 66, 67, 68, 69, 70: + k += char2 - 55 + 97, 98, 99, 100, 101, 102: + k += char2 - 87 + _: + self.invalidChar(char2) + b_b += char(k) + _: + self.invalidChar(c2) + else: + if (c2 == 92): + esc = true + else: + if (c2 == until): + break + else: + if (c2 == 10): + self.line += 1 + b_b += char(c2) + + return b_b + +func token(): + if (self.tokens.head != null): + var tempResult + if true: + var _this: haxe_ds_GenericStack = self.tokens + var k: haxe_ds_GenericCell = _this.head + if (k == null): + tempResult = null + else: + _this.head = k.next + tempResult = k.elt + return tempResult + + var char2 + + if (self.char < 0): + var tempRight + if true: + var s: String = self.input + var tempNumber + if true: + self.readPos += 1 + tempNumber = self.readPos - 1 + var index: int = tempNumber + tempRight = s.unicode_at.call(index) + char2 = tempRight + else: + char2 = self.char + self.char = -1 + + while (true): + match (char2): + 0: + return { "_index": 0 } + 10: + self.line += 1 + 9, 13, 32: + pass + 34, 39: + return { "_index": 1, "c": { "_index": 2, "s": self.readString(char2) } } + 35: + var tempRight1 + if true: + var s: String = self.input + var tempNumber1 + if true: + self.readPos += 1 + tempNumber1 = self.readPos - 1 + var index: int = tempNumber1 + tempRight1 = s.unicode_at.call(index) + char2 = tempRight1 + if (self.idents[char2]): + var id: String = char(char2) + while (true): + var tempRight2 + if true: + var s: String = self.input + var tempNumber2 + if true: + self.readPos += 1 + tempNumber2 = self.readPos - 1 + var index: int = tempNumber2 + tempRight2 = s.unicode_at.call(index) + char2 = tempRight2 + if (!self.idents[char2]): + self.char = char2 + return self.preprocess(id) + id += char(char2) + self.invalidChar(char2) + 40: + return { "_index": 4 } + 41: + return { "_index": 5 } + 44: + return { "_index": 9 } + 46: + var tempRight3 + if true: + var s: String = self.input + var tempNumber3 + if true: + self.readPos += 1 + tempNumber3 = self.readPos - 1 + var index: int = tempNumber3 + tempRight3 = s.unicode_at.call(index) + char2 = tempRight3 + match (char2): + 46: + var tempRight4 + if true: + var s: String = self.input + var tempNumber4 + if true: + self.readPos += 1 + tempNumber4 = self.readPos - 1 + var index: int = tempNumber4 + tempRight4 = s.unicode_at.call(index) + char2 = tempRight4 + if (char2 != 46): + self.invalidChar(char2) + return { "_index": 3, "s": "..." } + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + var n: int = char2 - 48 + var _exp: int = 1 + while (true): + var tempRight5 + if true: + var s: String = self.input + var tempNumber5 + if true: + self.readPos += 1 + tempNumber5 = self.readPos - 1 + var index: int = tempNumber5 + tempRight5 = s.unicode_at.call(index) + char2 = tempRight5 + _exp *= 10 + match (char2): + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + n = n * 10 + (char2 - 48) + _: + self.char = char2 + return { "_index": 1, "c": { "_index": 1, "f": n / _exp } } + _: + self.char = char2 + return { "_index": 8 } + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + var n: float = (char2 - 48) * 1.0 + var _exp: float = 0. + while (true): + var tempRight6 + if true: + var s: String = self.input + var tempNumber6 + if true: + self.readPos += 1 + tempNumber6 = self.readPos - 1 + var index: int = tempNumber6 + tempRight6 = s.unicode_at.call(index) + char2 = tempRight6 + _exp *= 10 + match (char2): + 46: + if (_exp > 0): + var tempLeft + if true: + var s: String = self.input + var tempNumber7 + if true: + self.readPos += 1 + tempNumber7 = self.readPos - 1 + var index: int = tempNumber7 + tempLeft = s.unicode_at.call(index) + if (_exp == 10 && tempLeft == 46): + if true: + var tk: Variant = { "_index": 3, "s": "..." } + if true: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + var i: int = int(n) + var tempConst + if (i == n): + tempConst = { "_index": 0, "v": i } + else: + tempConst = { "_index": 1, "f": n } + return { "_index": 1, "c": tempConst } + self.invalidChar(char2) + _exp = 1. + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + n = n * 10 + (char2 - 48) + 69, 101: + var tk = self.token() + var _pow = null + if (tk == null): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + match (tk._index): + 1: + var _g: Variant = tk.c + if (_g._index == 0): + var _g2: int = _g.v + if true: + var e: int = _g2 + _pow = e + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + 3: + var _g: String = tk.s + if (_g == "-"): + tk = self.token() + if (tk == null): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + if (tk._index == 1): + var _g2: Variant = tk.c + if (_g2._index == 0): + var _g3: int = _g2.v + if true: + var e: int = _g3 + _pow = -e + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + else: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + _: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) + if (_pow == null): + self.invalidChar(char2) + return { "_index": 1, "c": { "_index": 1, "f": pow(10, _pow) / _exp * n * 10 } } + 120: + if (n > 0 || _exp > 0): + self.invalidChar(char2) + var n2: int = 0 + while (true): + var tempRight7 + if true: + var s: String = self.input + var tempNumber8 + if true: + self.readPos += 1 + tempNumber8 = self.readPos - 1 + var index: int = tempNumber8 + tempRight7 = s.unicode_at.call(index) + char2 = tempRight7 + match (char2): + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57: + n2 = (n2 << 4) + char2 - 48 + 65, 66, 67, 68, 69, 70: + n2 = (n2 << 4) + (char2 - 55) + 97, 98, 99, 100, 101, 102: + n2 = (n2 << 4) + (char2 - 87) + _: + self.char = char2 + return { "_index": 1, "c": { "_index": 0, "v": n2 } } + _: + self.char = char2 + var i: int = int(n) + var tempConst1 + if (_exp > 0): + tempConst1 = { "_index": 1, "f": n * 10 / _exp } + else: + if (i == n): + tempConst1 = { "_index": 0, "v": i } + else: + tempConst1 = { "_index": 1, "f": n } + return { "_index": 1, "c": tempConst1 } + 58: + return { "_index": 14 } + 59: + return { "_index": 10 } + 61: + var tempRight8 + if true: + var s: String = self.input + var tempNumber9 + if true: + self.readPos += 1 + tempNumber9 = self.readPos - 1 + var index: int = tempNumber9 + tempRight8 = s.unicode_at.call(index) + char2 = tempRight8 + if (char2 == 61): + return { "_index": 3, "s": "==" } + else: + if (char2 == 62): + return { "_index": 3, "s": "=>" } + self.char = char2 + return { "_index": 3, "s": "=" } + 63: + return { "_index": 13 } + 64: + var tempRight9 + if true: + var s: String = self.input + var tempNumber10 + if true: + self.readPos += 1 + tempNumber10 = self.readPos - 1 + var index: int = tempNumber10 + tempRight9 = s.unicode_at.call(index) + char2 = tempRight9 + if (self.idents[char2] || char2 == 58): + var id: String = char(char2) + while (true): + var tempRight10 + if true: + var s: String = self.input + var tempNumber11 + if true: + self.readPos += 1 + tempNumber11 = self.readPos - 1 + var index: int = tempNumber11 + tempRight10 = s.unicode_at.call(index) + char2 = tempRight10 + if (!self.idents[char2]): + self.char = char2 + return { "_index": 15, "s": id } + id += char(char2) + self.invalidChar(char2) + 91: + return { "_index": 11 } + 93: + return { "_index": 12 } + 123: + return { "_index": 6 } + 125: + return { "_index": 7 } + _: + if (self.ops[char2]): + var op: String = char(char2) + while (true): + var tempRight11 + if true: + var s: String = self.input + var tempNumber12 + if true: + self.readPos += 1 + tempNumber12 = self.readPos - 1 + var index: int = tempNumber12 + tempRight11 = s.unicode_at.call(index) + char2 = tempRight11 + if (!self.ops[char2]): + self.char = char2 + return { "_index": 3, "s": op } + var pop: String = op + op += char(char2) + var tempBool + if true: + var this1: Variant = self.opPriority + tempBool = this1.exists(op) + var tempRight12 + if true: + var this1: Variant = self.opPriority + tempRight12 = this1.exists(pop) + if (!tempBool && tempRight12): + if (op == "//" || op == "/*"): + return self.tokenComment(op, char2) + self.char = char2 + return { "_index": 3, "s": pop } + if (self.idents[char2]): + var id: String = char(char2) + while (true): + var tempRight13 + if true: + var s: String = self.input + var tempNumber13 + if true: + self.readPos += 1 + tempNumber13 = self.readPos - 1 + var index: int = tempNumber13 + tempRight13 = s.unicode_at.call(index) + char2 = tempRight13 + if (!self.idents[char2]): + self.char = char2 + return { "_index": 2, "s": id } + id += char(char2) + self.invalidChar(char2) + var tempRight14 + if true: + var s: String = self.input + var tempNumber14 + if true: + self.readPos += 1 + tempNumber14 = self.readPos - 1 + var index: int = tempNumber14 + tempRight14 = s.unicode_at.call(index) + char2 = tempRight14 + + return null + +func preprocValue(id: String): + var this1: Variant = self.preprocesorValues + var tempResult = this1.__get(id) + + return tempResult + +func parsePreproCond() -> Variant: + var tk = self.token() + var tempResult + + if (tk == null): + tempResult = self.unexpected(tk) + else: + match (tk._index): + 2: + var _g: String = tk.s + var id: String = _g + tempResult = { "_index": 1, "v": id } + 3: + var _g: String = tk.s + if (_g == "!"): + var e: Variant = { "_index": 7, "op": "!", "prefix": true, "e": self.parsePreproCond() } + tempResult = e + else: + tempResult = self.unexpected(tk) + 4: + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new({ "_index": 4 }, _this.head) + tempResult = self.parseExpr() + _: + tempResult = self.unexpected(tk) + + return tempResult + +func evalPreproCond(e: Variant) -> bool: + match (e._index): + 1: + var _g: String = e.v + var id: String = _g + return self.preprocValue(id) != null + 3: + var _g: Variant = e.e + if true: + var e2: Variant = _g + return self.evalPreproCond(e2) + 6: + var _g: String = e.op + var _g1: Variant = e.e1 + var _g2: Variant = e.e2 + match (_g): + "&&": + var e1: Variant = _g1 + var e2: Variant = _g2 + return self.evalPreproCond(e1) && self.evalPreproCond(e2) + "||": + var e1: Variant = _g1 + var e2: Variant = _g2 + return self.evalPreproCond(e1) || self.evalPreproCond(e2) + _: + if true: + var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) } + var pmin: int = self.readPos + var pmax: int = self.readPos + if (!self.resumeErrors): + assert(false, str(err)) + return false + 7: + var _g: String = e.op + var _g1: bool = e.prefix + var _g2: Variant = e.e + if (_g == "!"): + var e2: Variant = _g2 + return !self.evalPreproCond(e2) + else: + if true: + var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) } + var pmin: int = self.readPos + var pmax: int = self.readPos + if (!self.resumeErrors): + assert(false, str(err)) + return false + _: + if true: + var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) } + var pmin: int = self.readPos + var pmax: int = self.readPos + if (!self.resumeErrors): + assert(false, str(err)) + return false + +func preprocess(id: String) -> Variant: + match (id): + "else", "elseif": + if (self.preprocStack.size() > 0): + if (self.preprocStack[self.preprocStack.size() - 1].get("r")): + self.preprocStack[self.preprocStack.size() - 1].set("r", false) + self.skipTokens() + return self.token() + else: + if (id == "else"): + self.preprocStack.pop_back() + self.preprocStack.push_back({ + "r": true + }) + return self.token() + else: + self.preprocStack.pop_back() + return self.preprocess("if") + else: + return { "_index": 16, "s": id } + "end": + if (self.preprocStack.size() > 0): + self.preprocStack.pop_back() + return self.token() + else: + return { "_index": 16, "s": id } + "if": + var e: Variant = self.parsePreproCond() + if (self.evalPreproCond(e)): + self.preprocStack.push_back({ + "r": true + }) + return self.token() + self.preprocStack.push_back({ + "r": false + }) + self.skipTokens() + return self.token() + _: + return { "_index": 16, "s": id } + +func skipTokens() -> void: + var spos: int = self.preprocStack.size() - 1 + var obj: Variant = self.preprocStack[spos] + var pos: int = self.readPos + + while (true): + var tk = self.token() + if (tk == { "_index": 0 }): + if (!self.resumeErrors): + assert(false, str({ "_index": 4, "msg": "Unclosed" })) + if (self.preprocStack[spos] != obj): + var _this: haxe_ds_GenericStack = self.tokens + _this.head = haxe_ds_GenericCell.new(tk, _this.head) break - return { "_index": 8, "haxe": processedContents } +func tokenComment(op: String, char2: int): + var tempMaybeNumber -static func escapeQuotes(s: String) -> String: - var escaped: String = s + if (1 < op.length()): + tempMaybeNumber = op.unicode_at(1) + else: + tempMaybeNumber = null - escaped = StringTools.replace(escaped, "'", "\\'") - escaped = StringTools.replace(escaped, "\"", "\\\"") + var c = tempMaybeNumber + var s: String = self.input - return escaped + if (c == 47): + while (char2 != 13 && char2 != 10): + var tempRight + if true: + var s2: String = self.input + var tempNumber + if true: + self.readPos += 1 + tempNumber = self.readPos - 1 + var index: int = tempNumber + tempRight = s2.unicode_at.call(index) + char2 = tempRight + self.char = char2 + return self.token() + if (c == 42): + var old: int = self.line + if (op == "/**/"): + self.char = char2 + return self.token() + while (true): + while (char2 != 42): + if (char2 == 10): + self.line += 1 + var tempRight1 + if true: + var s2: String = self.input + var tempNumber1 + if true: + self.readPos += 1 + tempNumber1 = self.readPos - 1 + var index: int = tempNumber1 + tempRight1 = s2.unicode_at.call(index) + char2 = tempRight1 + var tempRight2 + if true: + var s2: String = self.input + var tempNumber2 + if true: + self.readPos += 1 + tempNumber2 = self.readPos - 1 + var index: int = tempNumber2 + tempRight2 = s2.unicode_at.call(index) + char2 = tempRight2 + if (char2 == 47): + break + return self.token() + + self.char = char2 + + return { "_index": 3, "s": op } + +func constString(c: Variant) -> String: + var tempResult + + match (c._index): + 0: + var _g: int = c.v + var v: int = _g + tempResult = str(v) + 1: + var _g: float = c.f + var f: float = _g + tempResult = str(f) + 2: + var _g: String = c.s + var s: String = _g + tempResult = s + + return tempResult + +func tokenString(t: Variant) -> String: + var tempResult + + match (t._index): + 0: + tempResult = "" + 1: + var _g: Variant = t.c + var c: Variant = _g + tempResult = self.constString(c) + 2: + var _g: String = t.s + if true: + var s: String = _g + tempResult = s + 3: + var _g: String = t.s + if true: + var s: String = _g + tempResult = s + 4: + tempResult = "(" + 5: + tempResult = ")" + 6: + tempResult = "{" + 7: + tempResult = "}" + 8: + tempResult = "." + 9: + tempResult = "," + 10: + tempResult = ";" + 11: + tempResult = "[" + 12: + tempResult = "]" + 13: + tempResult = "?" + 14: + tempResult = ":" + 15: + var _g: String = t.s + if true: + var id: String = _g + tempResult = "@" + id + 16: + var _g: String = t.s + if true: + var id: String = _g + tempResult = "#" + id + + return tempResult diff --git a/hank-godot/scripts/Story.gd b/hank-godot/scripts/Story.gd index c5fc032..de18e99 100644 --- a/hank-godot/scripts/Story.gd +++ b/hank-godot/scripts/Story.gd @@ -9,7 +9,7 @@ var storyTree: StoryNode var viewCounts: Variant var nodeScopes: Array[StoryNode] var altInstances: Variant = haxe_ds_ObjectMap.new() -var parser: Parser +var parser: HParser var embedMode: EmbedMode.EmbedMode = EmbedMode.EmbedMode.Tunnel var embeddedBlocks: Array[Story] = [] var parent: Variant = { "_index": 1 } @@ -17,7 +17,7 @@ var choicesTaken: Array[int] = [] var weaveDepth: int = 0 var storedFrame: Variant = { "_index": 1 } -func _init(r: Random, p: Parser, ast2: Array[Variant], st: StoryNode, sc: Array[StoryNode], vc: Variant, hi: HInterface) -> void: +func _init(r: Random, p: HParser, ast2: Array[Variant], st: StoryNode, sc: Array[StoryNode], vc: Variant, hi: HInterface) -> void: self.insertionHooks = haxe_ds_StringMap.new() self.random = r self.parser = p @@ -341,6 +341,8 @@ func nextChoiceFrame() -> Variant: self.weaveDepth = fallback.get("choiceInfo").get("depth") + 1 return self.nextFrame() + return null + func traceChoiceArray(choices: Array[Variant]) -> void: var _g: int = 0 @@ -367,14 +369,14 @@ func traceChoiceArray(choices: Array[Variant]) -> void: tempRight = result haxe_Log.trace.call("" + ChoiceExtension.toString(choiceInfo) + ": #" + tempRight, { "fileName": "../hank/Story.hx", - "lineNumber": 373, + "lineNumber": 374, "className": "hank.Story", "methodName": "traceChoiceArray" }) haxe_Log.trace.call("---", { "fileName": "../hank/Story.hx", - "lineNumber": 375, + "lineNumber": 376, "className": "hank.Story", "methodName": "traceChoiceArray" }) @@ -439,6 +441,8 @@ func fallbackChoice() -> Variant: else: assert(false, str("there is no fallback choice!")) + return null + func gotoNextGather() -> void: var gatherIndex: int = ASTExtension.findNextGather(self.ast, self.currentFile(), self.exprIndex + 1, self.weaveDepth) @@ -758,7 +762,7 @@ static func FromAST(script: String, ast2: Array[Variant], randomSeed = null) -> var nodeScopes2: Array[StoryNode] = ([storyTree2] as Array[StoryNode]) var viewCounts2: Variant = storyTree2.createViewCounts() var hInterface2: HInterface = HInterface.new(storyTree2, viewCounts2) - var story: Story = Story.new(random2, Parser.new(), ast2, storyTree2, nodeScopes2, viewCounts2, hInterface2) + var story: Story = Story.new(random2, HParser.new(), ast2, storyTree2, nodeScopes2, viewCounts2, hInterface2) hInterface2.setStory(story) hInterface2.addVariable("story", story) @@ -768,7 +772,7 @@ static func FromAST(script: String, ast2: Array[Variant], randomSeed = null) -> return story static func FromFile(script: String, files = null, randomSeed = null) -> Story: - var parser2: Parser = Parser.new() + var parser2: HParser = HParser.new() var ast2: Array[Variant] = parser2.parseFile(script, files, false) return Story.FromAST(script, ast2, randomSeed) diff --git a/hank-godot/scripts/_GeneratedFiles.json b/hank-godot/scripts/_GeneratedFiles.json index c2a5079..c23731c 100644 --- a/hank-godot/scripts/_GeneratedFiles.json +++ b/hank-godot/scripts/_GeneratedFiles.json @@ -46,6 +46,7 @@ "IntIterator.gd", "HankBuffer.gd", "HankAssert.gd", + "HParser.gd", "HInterface.gd", "Extensions.gd", "Exception.gd", @@ -53,7 +54,7 @@ "CallStack.gd", "Alt.gd" ], - "id": 29, + "id": 33, "wasCached": false, "version": 1 } \ No newline at end of file diff --git a/hank/Story.hx b/hank/Story.hx index 7958818..93bbf1c 100644 --- a/hank/Story.hx +++ b/hank/Story.hx @@ -366,6 +366,7 @@ class Story { return nextFrame(); } } + untyped __gdscript__('return null'); } private function traceChoiceArray(choices:Array) { @@ -421,6 +422,7 @@ class Story { } else { throw 'there is no fallback choice!'; } + untyped __gdscript__('return null'); } private function gotoNextGather() {