extract variables function ready and implementing the first pass
[TinyThreePassCompiler/.git] / compiler.go
1 package main
2
3 import (
4         "fmt"
5         "strings"
6
7         "golang.org/x/exp/slices"
8 )
9
10 type op int
11
12 const (
13         imm op = iota
14         arg
15         plus
16         min
17         mul
18         div
19 )
20
21 type AST struct {
22         Op     op
23         Left   *AST
24         Right  *AST
25         Value  int
26         Parent *AST
27 }
28
29 func main() {
30         //a := &AST{Op: imm, N: 5
31         //b := &AST{Op: plus, A: a, B: &AST{Op: arg, N: 0}}
32         input := "[ a b ] a*a + b*b"
33         //value := []rune(input)
34
35         variables, program := extractVariables(input)
36
37         fmt.Println(variables, program)
38         var Tree AST
39         firstPass(program, &Tree)
40         //si es una letra y el stack esta sin setear pon en el A del stack un AST arg
41         //si es una operacion setea la op en el stack
42         //si es un abrir parentesis apunta al lado que este disponible del AST
43         //si es una letra y ya esta seteada la op mete un AST arg a la otra letra
44         //si es un cerrar parentesis coge para el pai.
45
46         //los numeros se portan justo como las letras.
47
48 }
49
50 func firstPass(variables, program []rune, node *AST) {
51         switch program[0] {
52         case '-':
53                 node.Op = min
54                 firstPass(variables, program[1:], node)
55         case '+':
56                 node.Op = plus
57                 firstPass(variables, program[1:], node)
58         case '*':
59                 node.Op = mul
60                 firstPass(variables, program[1:], node)
61         case '/':
62                 node.Op = div
63                 firstPass(variables, program[1:], node)
64         case '(':
65                 if node.Left != nil {
66                         firstPass(variables, program[1:], node.Left)
67                 } else {
68                         firstPass(variables, program[1:], node.Right)
69                 }
70         case ')':
71                 return
72
73         default:
74                 if program[0] > 47 && program[0] < 58 {
75                         var zeroOp op
76                         if node.Op == zeroOp {
77                                 node.Left = &AST{Op: imm, Value: int(program[0]) - 48}
78                                 firstPass(variables, program[1:], node)
79                                 //a := &AST{Op: imm, N: 5
80                         } else {
81                                 node.Right = &AST{Op: imm, Value: int(program[0]) - 48}
82                                 firstPass(variables, program[1:], node)
83                         }
84                 } else if slices.Contains(variables, program[0]) {
85                         var zeroOp op
86                         if node.Op == zeroOp {
87                                 node.Left = &AST{Op: imm, Value: int(program[0]) - 48}
88                                 firstPass(variables, program[1:], node)
89                                 //a := &AST{Op: imm, N: 5
90                         } else {
91                                 node.Right = &AST{Op: imm, Value: int(program[0]) - 48}
92                                 firstPass(variables, program[1:], node)
93                         }
94
95                 }
96
97         }
98         return
99
100 }
101
102 // extractVariables receives the original program string and converts it in
103 // two rune slices, the first containing the variables and a second containing
104 // the trimmed program
105 func extractVariables(input string) ([]rune, []rune) {
106         variables := strings.Split(input, "]")
107         // Cleaning out the variables that are gettting extracted
108         variables[0] = strings.Split(variables[0], "[")[1]
109         variables[0] = strings.Trim(variables[0], " ")
110         cleanVariables := []rune(variables[0])
111         var resultVariables []rune
112         for _, v := range cleanVariables {
113                 if v != ' ' {
114                         resultVariables = append(resultVariables, v)
115                 }
116         }
117
118         //Cleaning out the program that is getting extracted
119         variables[1] = strings.Trim(variables[1], " ")
120         cleanProgram := []rune(variables[1])
121         var resultProgram []rune
122         for _, v := range cleanProgram {
123                 if v != ' ' {
124                         resultProgram = append(resultProgram, v)
125
126                 }
127
128         }
129
130         return resultVariables, resultProgram
131 }