More GDScript fixes
This commit is contained in:
351
hank-godot/scripts/HParser.gd
Normal file
351
hank-godot/scripts/HParser.gd
Normal file
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user