1st

interpreter.go

@@ -1 +1,137 @@
 package interpreter
+
+import (
+	"regexp"
+	"strings"
+)
+
+type Interpreter struct {
+	RegexMap RegexMap
+	Funcs    Funcs
+	// Env   map[string]string
+	// Funcs map[string]func(args ...string) string
+	// Vars  map[string]string
+	Statments      Statments
+	LogicSplitters []string
+}
+type Funcs map[string]*Func
+type Func struct {
+	Name     string
+	Function Function
+}
+type Function func(args ...any) string
+type Statments map[string]*Statment
+type Statment struct {
+	Name       string
+	Value      string
+	RegexSplit []string
+}
+
+type RegexMap map[string]*Regex
+type Regex struct {
+	Name  string
+	Value string
+}
+
+func New() *Interpreter {
+	i := &Interpreter{}
+	return i
+}
+
+type InterpreterInterface interface {
+}
+
+func (i *Interpreter) Regex(name string, regx string) *Regex {
+	i.RegexMap = make(RegexMap)
+	i.RegexMap[name] = &Regex{
+		Name:  name,
+		Value: regx,
+	}
+	return i.RegexMap[name]
+}
+
+func (i *Interpreter) AddStatment(name string, stmnt string) *Statment {
+	if _, ok := i.Statments[name]; !ok {
+		i.Statments = make(Statments)
+	}
+	i.Statments[name] = &Statment{
+		Value: stmnt,
+		Name:  name,
+	}
+	return i.Statments[name]
+}
+func (fncs Funcs) GetFunc(funcName string) *Func {
+	fn := fncs[funcName]
+	return fn
+}
+func (i *Interpreter) Func(funcName string, fn func(args ...any) string) *Func {
+	if i.Funcs == nil {
+		i.Funcs = make(Funcs)
+	}
+	newFunc := &Func{
+		Name:     funcName,
+		Function: fn,
+	}
+	i.Funcs[funcName] = newFunc
+	return i.Funcs[funcName]
+}
+func (i *Interpreter) GetRegex(name string) *Regex {
+	return i.RegexMap[name]
+}
+
+func (i *Interpreter) CutPrefix(slc []string, prefix string) []string {
+	//TODO: get the slc from the struct... need to implement the setter before
+	for i, v := range slc {
+		clean, _ := strings.CutPrefix(v, prefix)
+		slc[i] = clean
+	}
+
+	return slc
+}
+
+func (s *Statment) SplitStatementByRegex(regx *Regex) *Statment {
+
+	input := s.Value
+	re := regexp.MustCompile(string(regx.Value))
+	matches := re.FindAllStringSubmatch(input, -1)
+	if len(matches) == 0 {
+		return s // Return original if no backticks found
+	}
+
+	result := []string{}
+	lastIndex := 0
+
+	for _, match := range matches {
+
+		startIndex := strings.Index(input, match[0])
+
+		if startIndex > lastIndex {
+			result = append(result, input[lastIndex:startIndex])
+		}
+
+		result = append(result, match[1]) // Append the content within backticks
+		lastIndex = startIndex + len(match[0])
+	}
+
+	if lastIndex < len(input) {
+		result = append(result, input[lastIndex:])
+	}
+	s.RegexSplit = result
+
+	return s
+}
+func (s Statments) ForEach(fn func(stmnt *Statment)) {
+	for _, stmntData := range s {
+		fn(stmntData)
+	}
+}
+
+// func (i *Interpreter) AddLogicSplitters(splitter ...string) {
+// 	for _, s := range splitter {
+// 		i.addLogicSplitter(s)
+// 	}
+// }
+
+// func (i *Interpreter) addLogicSplitter(splitter string) {
+// 	i.LogicSplitters = append(i.LogicSplitters, splitter)
+// }