ed/LangStudies
1
0
Fork 0
mirror of https://github.com/Ed94/LangStudies.git synced 2025-06-15 11:31:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

Lecture 6 complete.

Browse Source
This commit is contained in:
Edward R. Gonzalez
2022-07-20 14:57:26 -04:00
parent f85c9615e4
commit de420a8111
8 changed files with 243 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
App/EoI/Scripts/EoI_Viewer.gd
View File

@ -18,16 +18,18 @@ var eva = preload("Eva.gd").new()
# UX --------------------------------------------------------
onready var Editor = get_node("Editor_TEdit")
onready var Output = get_node("Output_TEdit")
onready var Debug = get_node("Debug_TEdit")
onready var Eva_Btn = get_node("VBox/Eva_Interpret_Btn")
onready var Back_Btn = get_node("VBox/Back_Btn")
func evaBtn_pressed():
eva.init(Editor.text)
eva.init(Editor.text, Output)
var ast = eva.parse()
Output.text = eva.eval(ast)
Debug.text = JSON.print(eva.Records, "\t")
func backBtn_pressed():
queue_free()

234
App/EoI/Scripts/Eva.gd
View File

@ -2,20 +2,24 @@ extends Object
var SRegEx = preload("res://RegM/Scripts/SRegex.gd").new()
# ---------------------------------------------------------- Lexer
const TType : Dictionary = \
{
fmt_S = "Formatting",
fmt_S = "Formatting",
cmt_SL = "Comment Single-Line",
cmt_ML = "Comment Multi-Line",
def_Start = "Expression Start",
def_End = "Expression End",
def_Var = "Variable",
literal_Number = "LIteral: Number",
literal_Number = "Literal: Number",
literal_String = "Literal: String",
operator = "Operator"
op_Assgin = "Assignment",
op_Numeric = "op_Numeric",
identifier = "Identifier"
}
const Spec : Dictionary = \
@ -26,26 +30,37 @@ const Spec : Dictionary = \
TType.fmt_S : "start whitespace.repeat(1-).lazy",
TType.def_Start : "start \\(",
TType.def_End : "start \\)",
TType.def_End : "start \\)",
TType.def_Var : "start \"var\"",
TType.literal_Number : \
"""start
set(+ \\-).repeat(0-1)
set(+ \\-).repeat(0-1)
( set(0-9).repeat(1-) \\. ).repeat(0-1)
set(0-9).repeat(1-)
""",
TType.literal_String : "start \\\" !set( \\\" ).repeat(0-) \\\" ",
TType.operator : "start set(+ \\-)",
TType.op_Assgin : "start \"set\"",
TType.op_Numeric : "start set(+ \\- * /)",
TType.identifier :
"""start
(
set(A-z).repeat(1-)
set(\\- _).repeat(0-1)
)
.repeat(0-1)
"""
}
class Token:
var Type : String
var Value : String
func is_Literal():
return Type == TType.literal_Number || Type == TType.literal_String;
func is_Literal():
return Type == TType.literal_Number || Type == TType.literal_String;
var SourceText : String
var Cursor : int
@ -56,13 +71,16 @@ var TokenIndex : int = 0
func compile_regex():
for type in TType.values() :
var \
regex = RegEx.new()
regex.compile( SRegEx.transpile(Spec[type]) )
var regex = RegEx.new()
var result = SRegEx.compile(Spec[type])
regex.compile( result )
SpecRegex[type] = regex
func init(programSrcText):
func init(programSrcText, errorOutput):
ErrorOutput = errorOutput
SourceText = programSrcText
Cursor = 0
TokenIndex = 0
@ -73,7 +91,6 @@ func init(programSrcText):
tokenize()
func next_Token():
var nextToken = null
if Tokens.size() > TokenIndex :
@ -122,11 +139,11 @@ func tokenize():
break;
if error :
var assertStrTmplt = "next_token: Source text not understood by tokenizer at Cursor pos: {value} -: {txt}"
var assertStrTmplt = "Lexer - tokenize: Source text not understood by tokenizer at Cursor pos: {value} -: {txt}"
var assertStr = assertStrTmplt.format({"value" : Cursor, "txt" : srcLeft})
assert(true != true, assertStr)
throw(assertStr)
return
# ---------------------------------------------------------- Lexer
# ---------------------------------------------------------- Lexer END
# ---------------------------------------------------------- Parser
@ -137,8 +154,15 @@ const NType = \
literal_Number = "Literal: Number",
literal_String = "Literal: String",
op_Assign = "Assignment",
op_Add = "+",
op_Mult = "*"
op_Sub = "-",
op_Mult = "*",
op_Div = "/",
identifier = "Identifier",
variable = "Variable"
}
class ASTNode:
@ -170,7 +194,6 @@ class ASTNode:
func string():
return arg(1).substr(1, arg(1).length() -2)
# Serialization ----------------------------------------------------
func array_Serialize(array, fn_objSerializer) :
@ -216,12 +239,12 @@ var NextToken : Token
func eat(tokenType):
var currToken = NextToken
assert(currToken != null, "eat: NextToken was null")
check(currToken != null, "Parser - eat: NextToken was null")
var assertStrTmplt = "eat: Unexpected token: {value}, expected: {type}"
var assertStrTmplt = "Parser - eat: Unexpected token: {value}, expected: {type}"
var assertStr = assertStrTmplt.format({"value" : currToken.Value, "type" : tokenType})
assert(currToken.Type == tokenType, assertStr)
check(currToken.Type == tokenType, assertStr)
NextToken = next_Token()
@ -232,6 +255,9 @@ func parse():
if NextToken.Type == TType.def_Start:
return parse_Expression()
if NextToken.Type == TType.identifier:
return parse_Identifier()
if NextToken.is_Literal():
return parse_Literal()
@ -240,37 +266,102 @@ func parse_Expression():
eat(TType.def_Start)
var node : ASTNode
if NextToken.Type == TType.operator:
node = parse_Operator()
if NextToken.Type == TType.def_Var:
node = parse_Variable()
if NextToken.Type == TType.op_Assgin:
node = parse_op_Assign()
elif NextToken.Type == TType.op_Numeric:
node = parse_op_Numeric()
var arg = 1
while NextToken.Type != TType.def_End:
node.add_Expr( parse_Literal() )
if NextToken.Type == TType.def_Start:
node.add_Expr( parse_Expression() )
else :
node.add_Expr( parse_Literal() )
if NextToken.is_Literal():
elif NextToken.is_Literal():
node = parse_Literal()
eat(TType.def_End)
return node
func parse_Operator():
func parse_Variable():
var \
node = ASTNode.new()
node.set_Type(NType.variable)
eat(TType.def_Var)
check( NextToken.Type == TType.identifier,
String("Parser - parse_Variable: NextToken should have been identifier. TokenData - Type: {type} Value: {value}") \
.format({"type" : NextToken.Type, "value" : NextToken.Value })
)
node.add_TokenValue( NextToken )
eat(TType.identifier)
if NextToken.Type == TType.def_Start :
node.add_Expr( parse_Expression() )
else :
node.add_Expr( parse_Literal() )
return node
func parse_Identifier():
var \
node = ASTNode.new()
node.set_Type(NType.identifier)
node.add_TokenValue(NextToken)
eat(TType.identifier)
return node
func parse_op_Assign():
var \
node = ASTNode.new()
node.set_type(NType.op_Assign)
eat(TType.op_Assgin)
check( NextToken.Type != TType.identifier,
String("Parser - parse_op_Assign: NextToken should have been identifier, Type: {type} Value: {value}") \
.format({"type" : NextToken.Type, "value" : NextToken.Value })
)
node.add_TokenValue( NextToken.Value )
if NextToken.is_Literal() :
node.add_Expr( parse_Literal() )
elif NextToken.Type == TType.def_Start :
node.add_Expr( parse_Expression() )
return node
func parse_op_Numeric():
var node = ASTNode.new()
match NextToken.Value:
NType.op_Add:
node.set_Type(NType.op_Add)
NType.op_Sub:
node.set_Type(NType.op_Sub)
NType.op_Mult:
node.set_Type(NType.op_Mult)
NType.op_Div:
node.set_Type(NType.op_Div)
eat(TType.operator)
eat(TType.op_Numeric)
return node
func parse_Literal():
var \
node = ASTNode.new()
var node = ASTNode.new()
match NextToken.Type:
TType.literal_Number:
@ -289,28 +380,93 @@ func parse_Literal():
# ---------------------------------------------------------- Parser END
# ---------------------------------------------------------- Environment
var Records : Dictionary
func env_DefineVar(symbol : String, value) :
Records[symbol] = value
func env_Lookup(symbol : String) :
check(Records.has(symbol), String("Symbol not found in environment records"))
return Records[symbol]
# ---------------------------------------------------------- Environment END
class_name Eva
# ---------------------------------------------------------- GLOBALS
var ErrorOutput
# ---------------------------------------------------------- GLOBALS END
# ---------------------------------------------------------- UTILITIES
func check( condition : bool, message : String):
assert(condition, message)
ErrorOutput.text = "Eva - Error: " + message
func throw( message ):
assert(false, message)
ErrorOutput.text = "Eva - Error: " + message
# ---------------------------------------------------------- UTILITIES END
func eval( ast ):
if ast.is_Number() :
return float(ast.arg(1))
if ast.type() == NType.identifier :
return env_Lookup( ast.arg(1) )
if ast.type() == NType.variable :
var symbol = ast.arg(1)
var value = eval( ast.arg(2) )
env_DefineVar(symbol, value)
return value
if ast.is_String() :
return ast.string()
return String( eval_Numeric(ast) )
var msgT = "eval - Unimplemented: {ast}"
var msg = msgT.format({"ast" : JSON.print(ast.to_SExpression(), "\t") })
throw(msg)
func eval_Numeric( ast ):
if ast.is_Number() :
return float(ast.arg(1))
if ast.type() == NType.op_Add:
return String(eval( ast.arg(1) ) + eval( ast.arg(2) ))
var result = 0.0; var index = 1
while index <= ast.num_args():
result += eval_Numeric( ast.arg(index) )
index += 1
return result
if ast.type() == NType.op_Sub:
var result = 0.0; var index = 1
while index <= ast.num_args():
result -= eval_Numeric( ast.arg(index) )
index += 1
return result
if ast.type() == NType.op_Mult:
return String(eval( ast.arg(1) ) * eval( ast.arg(2) ))
throw("Unimplemented")
var result = 1.0; var index = 1
while index <= ast.num_args():
result *= eval_Numeric( ast.arg(index) )
index += 1
return result
if ast.type() == NType.op_Div:
var result = 1.0; var index = 1
while index <= ast.num_args():
result /= eval_Numeric( ast.arg(index) )
result += 1
return result