From fc650edf6a1ad7b043ccd92495d8e600fd094963 Mon Sep 17 00:00:00 2001
From: Kyle Gunger <kgunger12@gmail.com>
Date: Sat, 20 Nov 2021 16:59:28 -0500
Subject: [EVAL] Flush out some helper funcs (again)

---
 src/texec/eval.go | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 91 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/texec/eval.go b/src/texec/eval.go
index 4aefd5a..b6c0020 100644
--- a/src/texec/eval.go
+++ b/src/texec/eval.go
@@ -16,7 +16,8 @@
 
 package texec
 
-// Don't want to deal with this rn
+import "tparse"
+import "fmt"
 
 /*
 	So here's what I care to support at present:
@@ -35,6 +36,95 @@ package texec
 //# Helper Funcs #
 //################
 
+// Error helper
+
+func errOut(path TArtifact, place tparse.Token) {
+	fmt.Println("Error in eval:")
+	fmt.Println(path)
+	fmt.Println(place)
+	panic("EVAL ERROR")
+}
+
+// Names of artifacts, finding artifacts
+
+func getDefNames(def tparse.Node) []string {
+	out := []string{}
+	for i := 0; i < len(def.Sub); i++ {
+		if def.Sub[i].Data.Data == "vlist" && def.Sub[i].Data.Type == 10 {
+			vl := def.Sub[i]
+			for i := 0; i < len(vl.Sub); i++ {
+				if vl.Sub[i].Data.Type == tparse.DEFWORD {
+					out = append(out, vl.Sub[i].Data.Data)
+				} else if vl.Sub[i].Data.Data == "=" && vl.Sub[i].Sub[0].Data.Type == tparse.DEFWORD {
+					out = append(out, vl.Sub[i].Sub[0].Data.Data)
+				}
+			}
+		}
+	}
+	return out
+}
+
+func getBlockName(block tparse.Node) []string {
+	out := []string{}
+	for i := 0; i < len(block.Sub[0].Sub); i++ {
+		if block.Sub[0].Sub[i].Data.Type == tparse.DEFWORD {
+			out = append(out, block.Sub[0].Sub[i].Data.Data)
+		}
+	}
+	return out
+}
+
+func getTypeName(t tparse.Node) []string {
+	out := []string{}
+	for i := 0; i < len(t.Sub); i++ {
+		if t.Sub[i].Data.Type == tparse.DEFWORD {
+			out = append(out, t.Sub[i].Data.Data)
+		}
+	}
+	return out
+}
+
+// Get the list of names defined by the block or variable definition
+func getNames(root tparse.Node) []string {
+	switch root.Data.Data {
+	case "block":
+		return getBlockName(root)
+	case "define":
+		return getDefNames(root)
+	case "raw", "switch", "enum":
+		return getTypeName(root)
+	}
+
+	return []string{}
+}
+
+// Find an artifact from a path and the root node
+func getArtifact(a TArtifact, root *TModule) *tparse.Node {
+	mod := root
+	for i := 0; i < len(a.Path); i++ {
+		for j := 0; j < len(mod.Sub); j++ {
+			if mod.Sub[j].Name == a.Path[i] {
+				mod = &(mod.Sub[j])
+				break
+			}
+		}
+	}
+
+	for i := 0; i < len(mod.Artifacts); i++ {
+		n := getNames(mod.Artifacts[i])
+		for i := 0; i < len(n); i++ {
+			if n[i] == a.Name {
+				return &(mod.Artifacts[i])
+			}
+		}
+	}
+
+	return nil
+}
+
+// Type related stuff
+
+// Checking type equality
 func equateType(a, b TType) bool {
 	if len(a.Pre) != len(b.Pre) || len(a.Post) != len(b.Post) {
 		return false
-- 
cgit v1.2.3