varaq-interpreter-go/varaq/interpreter.go

package varaq

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"math"
	"math/rand"
	"net"
	"net/http"
	"os"
	"runtime"
	"strconv"
	"strings"
	"time"
)

var globals = map[string]Expr{}
var stack = make([]Expr, 0)
var s = bufio.NewScanner(os.Stdin)

func get(k string) Expr {
	return globals[k]
}

func put(k string, v Expr) {
	globals[k] = v
}

func push(o Expr) {
	stack = append(stack, o)
}

func top() (Expr, error) {
	n := len(stack) - 1
	if n < 0 {
		return Expr{}, fmt.Errorf("stack underflow")
	}
	return stack[n], nil
}

func pop() (Expr, error) {
	res, e := top()
	if e != nil {
		return Expr{}, e
	}
	n := len(stack) - 1
	stack = stack[:n]
	return res, nil
}

func popExpr() (Expr, error) {
	a, e := pop()
	if e != nil {
		return Expr{}, e
	}
	if a.Tok == IDENTIFIER {
		a = get(a.Value.(string))
	}
	return a, nil
}

func pop2Expr() (Expr, Expr, error) {
	b, e := popExpr()
	if e != nil {
		return Expr{}, Expr{}, e
	}

	a, e := popExpr()
	if e != nil {
		return Expr{}, Expr{}, e
	}

	return b, a, nil
}

func identifierToObj(c Expr, idx int, argv []string, w io.Writer) error {
	k, k_ok := c.Value.(string)
	if k_ok {
		o := get(k)
		if o.Tok == UNDEFINED {
			return fmt.Errorf("identifier %s undefined @%v", k, idx)
		} else if o.Tok == FUNCTION {
			e := Interpret(o, argv, w)
			if e != nil {
				if e == fmt.Errorf("escape") {
					return nil
				}
				return e
			}
		} else {
			push(o)
		}
	} else {
		return fmt.Errorf("idenifier not string @%v", idx)
	}

	return nil
}

func (c Expr) idToExpr(idx int, argv []string, w io.Writer) (Expr, error) {
	e := identifierToObj(c, idx, argv, w)
	if e != nil {
		return Expr{UNDEFINED, nil, nil, 0}, e
	}

	vv, e2 := pop()
	if e2 != nil {
		return Expr{UNDEFINED, nil, nil, 0}, e2
	}

	return vv, nil
}

func (c Expr) idToS(idx int, argv []string, w io.Writer) (string, error) {
	v, e := c.idToExpr(idx, argv, w)
	if e != nil {
		return "", e
	}

	return fmt.Sprintf("%b", v.Value), nil
}

func popArgs(idx int, argv []string, w io.Writer) (Expr, Expr, error) {
	b, e := pop()
	if e != nil {
		return Expr{UNDEFINED, nil, nil, 0}, Expr{UNDEFINED, nil, nil, 0}, e
	}
	if b.Tok == IDENTIFIER {
		b, e = b.idToExpr(idx, argv, w)
		if e != nil {
			return Expr{UNDEFINED, nil, nil, 0}, Expr{UNDEFINED, nil, nil, 0}, e
		}
	}
	a, e := pop()
	if e != nil {
		return Expr{UNDEFINED, nil, nil, 0}, Expr{UNDEFINED, nil, nil, 0}, e
	}
	if a.Tok == IDENTIFIER {
		a, e = a.idToExpr(idx, argv, w)
		if e != nil {
			return Expr{UNDEFINED, nil, nil, 0}, Expr{UNDEFINED, nil, nil, 0}, e
		}
	}

	return a, b, nil
}

func Interpret(code Expr, argv []string, w io.Writer) error {
	for idx, c := range code.Exprs {
		switch c.Tok {
		case NUMBER:
			push(c)
		case STRING:
			push(c)
		case LIST:
			push(c)
		case FUNCTION:
			push(c)
		case TRUE:
			push(Expr{BOOLEAN, nil, true, 0})
		case FALSE:
			push(Expr{BOOLEAN, nil, false, 0})
		case POP:
			_, e := pop()
			if e != nil {
				return e
			}
		case DUP:
			obj, e := pop()
			if e != nil {
				return e
			}
			push(obj)
			push(obj)
		case EXCH:
			obj1, e1 := pop()
			if e1 != nil {
				return e1
			}
			obj2, e2 := pop()
			if e2 != nil {
				return e2
			}
			push(obj1)
			push(obj2)
		case OVER:
			n := len(stack) - 1
			if n-1 < 0 {
				return fmt.Errorf("over: stack underflow")
			}
			push(stack[n-1])
		case ROT:
			n := len(stack) - 1
			if n-3 < 0 {
				return fmt.Errorf("stack underflow, must have 3 or more")
			}

			push(stack[n-2])
			stack = append(stack[:n-2], stack[n-3:]...)
		case DEPTH:
			push(Expr{NUMBER, nil, float64(len(stack)), 0})
		case CLEAR:
			stack = nil
			stack = make([]Expr, 0)
		case IDENTIFIER:
			if idx-1 >= 0 && code.Exprs[idx-1].Tok == TILDE {
				push(c)
			} else {
				e := identifierToObj(c, idx, argv, w)
				if e != nil {
					return e
				}
			}
		case REMEMBER:
			push(Expr{REMEMBER, nil, "REMEMBER", 0})
		case FORGET:
			v, e := pop()
			if e != nil {
				return e
			}
			for {
				if v.Tok == REMEMBER || len(stack) == 0 {
					break
				}
				v, e = pop()
				if e != nil {
					return e
				}
			}
		case DUMP:
			for n := len(stack) - 1; n >= 0; n-- {
				fmt.Fprintf(w, "%v\n", stack[n])
			}
			fmt.Fprintf(w, "=== end of dump ===\n")
		case NAME:
			fun, e := pop()
			if e != nil {
				return e
			}
			name, en := pop()
			if en != nil {
				return en
			}
			namev, n_ok := name.Value.(string)
			if fun.Tok == FUNCTION && name.Tok == IDENTIFIER && n_ok {
				put(namev, fun)
			} else {
				return fmt.Errorf("cannot bind name @%v", idx)
			}
		case SET:
			name, en := pop()
			if en != nil {
				return en
			}
			o, e := pop()
			if e != nil {
				return e
			}
			n, n_ok := name.Value.(string)
			if (name.Tok == IDENTIFIER || name.Tok == STRING) && n_ok {
				put(n, o)
			} else {
				return fmt.Errorf("cannot set, name is not a string @%v", idx)
			}
		case IFYES:
			fun, ef := pop()
			if ef != nil {
				return ef
			}
			logical, el := pop()
			if el != nil {
				return el
			}
			if fun.Tok == FUNCTION && logical.Tok == BOOLEAN {
				if logical.Value.(bool) {
					Interpret(fun, argv, w)
				}
			} else {
				return fmt.Errorf("cannot `ifyes` not a function or bool @%v", idx)
			}
		case IFNO:
			fun, ef := pop()
			if ef != nil {
				return ef
			}
			logical, el := pop()
			if el != nil {
				return el
			}
			if fun.Tok == FUNCTION && logical.Tok == BOOLEAN {
				if !logical.Value.(bool) {
					Interpret(fun, argv, w)
				}
			} else {
				return fmt.Errorf("cannot `ifno` not a function or bool @%v", idx)
			}
		case CHOOSE:
			b, e := pop()
			if e != nil {
				return e
			}
			if b.Tok == BOOLEAN {
				push(b)
				push(b)
			} else {
				return fmt.Errorf("cannot `choose` not a bool @%v", idx)
			}
		case EVAL:
			fun, e := pop()
			if e != nil {
				return e
			}
			if fun.Tok == FUNCTION {
				Interpret(fun, argv, w)
			} else {
				return fmt.Errorf("cannot `eval` not a function @%v", idx)
			}
		case ESCAPE:
			return fmt.Errorf("escape")
		case REPEAT:
			fun, e := pop()
			if e != nil {
				return e
			}
			count, ec := pop()
			if ec != nil {
				return ec
			}
			if fun.Tok == FUNCTION && count.Tok == NUMBER {
				for n := int64(0); n < int64(count.Value.(float64)); n++ {
					err := Interpret(fun, argv, w)
					if err != nil {
						return err
					}
				}
			} else {
				return fmt.Errorf("cannot `repeat` not a function or int @%v", idx)
			}
		case SPLIT:
			list, e := pop()
			if e != nil {
				return e
			}
			if list.Tok == LIST {
				n := len(list.Exprs) - 1
				push(list.Exprs[n])
				list.Exprs = list.Exprs[:n]
				push(list)
			} else {
				return fmt.Errorf("cannot `split` not a list @%v", idx)
			}
		case CONS:
			list, e := pop()
			if e != nil {
				return e
			}
			o, eo := pop()
			if eo != nil {
				return eo
			}
			if list.Tok == LIST {
				list.Exprs = append(list.Exprs, o)
				push(list)
			} else {
				return fmt.Errorf("cannot `cons` not a list @%v", idx)
			}
		case SHATTER:
			list, e := pop()
			if e != nil {
				return e
			}
			if list.Tok == LIST {
				for n := 0; n < len(list.Exprs); n++ {
					push(list.Exprs[n])
				}
			} else {
				return fmt.Errorf("cannot `shatter` not a list @%v", idx)
			}
		case EMPTY:
			list, e := pop()
			if e != nil {
				return e
			}
			if list.Tok == LIST {
				push(Expr{BOOLEAN, nil, len(list.Exprs) == 0, 0})
			} else {
				return fmt.Errorf("cannot `empty` not a list @%v", idx)
			}
		case COMPOSE:
			v, e := pop()
			if e != nil {
				return e
			}
			var sb strings.Builder
			for {
				if v.Tok == REMEMBER || len(stack) == 0 {
					break
				}
				v, e := pop()
				if e != nil {
					return e
				}
				if v.Tok == STRING {
					sb.WriteString(v.Value.(string))
				} else {
					return fmt.Errorf("cannot `compose` value is not a string @%v", idx)
				}
			}
			push(Expr{STRING, nil, sb.String(), 0})
		case STREQ:
			v1, e := pop()
			if e != nil {
				return e
			}
			v2, e2 := pop()
			if e2 != nil {
				return e2
			}
			if v1.Tok == STRING && v2.Tok == STRING {
				push(Expr{BOOLEAN, nil, v1.Value.(string) == v2.Value.(string), 0})
			} else {
				return fmt.Errorf("cannot `streq?` value is not a string @%v", idx)
			}
		case STRTIE:
			var e error
			v2, e := pop()
			if e != nil {
				return e
			}
			v1, e := pop()
			if e != nil {
				return e
			}

			var v1_s string
			var v2_s string

			if v1.Tok == IDENTIFIER {
				v1_s, e = v1.idToS(idx, argv, w)
				if e != nil {
					return e
				}
			} else if v1.Tok == STRING {
				v1_s = v1.Value.(string)
			} else {
				var d float64
				err := false
				switch v := v1.Value.(type) {
				case float64:
					d = float64(v)
				default:
					err = true
				}

				if err {
					v1_s = fmt.Sprintf("%v", v1.Value)
				} else if d == float64(int64(d)) {
					v1_s = fmt.Sprintf("%d", int64(v1.Value.(float64)))
				} else {
					v1_s = fmt.Sprintf("%f", v1.Value.(float64))
				}
			}

			if v2.Tok == IDENTIFIER {
				v2_s, e = v2.idToS(idx, argv, w)
				if e != nil {
					return e
				}
			} else if v2.Tok == STRING {
				v2_s = v2.Value.(string)
			} else {
				var d float64
				err := false
				switch v := v2.Value.(type) {
				case float64:
					d = float64(v)
				default:
					err = true
				}

				if err {
					v2_s = fmt.Sprintf("%v", v2.Value)
				} else if d == float64(int64(d)) {
					v2_s = fmt.Sprintf("%d", int64(v2.Value.(float64)))
				} else {
					v2_s = fmt.Sprintf("%f", v2.Value.(float64))
				}
			}

			push(Expr{STRING, nil, v1_s + v2_s, 0})

		case STRCUT:
			endval, e := pop()
			if e != nil {
				return e
			}
			startval, e := pop()
			if e != nil {
				return e
			}
			str, e := pop()
			if e != nil {
				return e
			}

			if str.Tok == STRING && startval.Tok == NUMBER && endval.Tok == NUMBER {
				push(Expr{STRING, nil, str.Value.(string)[int64(startval.Value.(float64)):int64(endval.Value.(float64))], 0})
			} else {
				return fmt.Errorf("cannot `strcut` value is not a string or start/end val is not an int @%v", idx)
			}
		case STRMEASURE:
			v, e := pop()
			if e != nil {
				return e
			}
			if v.Tok == STRING {
				push(Expr{NUMBER, nil, float64(len(v.Value.(string))), 0})
			} else {
				return fmt.Errorf("cannot `strmeasure` value is not a string @%v", idx)
			}
		case EXPLODE:
			str, e := pop()
			if e != nil {
				return e
			}
			if str.Tok == STRING {
				words := strings.Fields(str.Value.(string))
				for _, s := range words {
					push(Expr{STRING, nil, s, 0})
				}
			}
		case ADD:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) + (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `add` values are not numbers @%v", idx)
			}
		case SUB:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) - (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `sub` values are not numbers @%v", idx)
			}
		case MUL:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) * (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `mul` values are not numbers @%v", idx)
			}
		case DIV:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) / (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `div` values are not numbers @%v", idx)
			}
		case IDIV:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Round(a.Value.(float64)) / math.Round(b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `idiv` values are not numbers @%v", idx)
			}
		case MOD:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) % int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `mod` values are not numbers @%v", idx)
			}
		case POW:
			a, b, e := popArgs(idx, argv, w)
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Pow(a.Value.(float64), b.Value.(float64)), 0})
			}
		case SQRT:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Sqrt(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `sqrt` value is not number or float @%v", idx)
			}
		case ADD1:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) + 1.0, 0})
			} else {
				return fmt.Errorf("cannot `add1` value is not a number @%v", idx)
			}
		case SUB1:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, a.Value.(float64) - 1.0, 0})
			} else {
				return fmt.Errorf("cannot `sub1` value is not a number  @%v", idx)
			}
		case SIN:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Sin(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `sin` values are not numbers or floats @%v", idx)
			}
		case COS:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Cos(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `cos` values are not numbers or floats @%v", idx)
			}
		case TAN:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Tan(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `tan` values are not numbers or floats @%v", idx)
			}
		case ATAN:
			a, e := popExpr()
			if e != nil {
				return e
			}

			den, e := pop()
			if e != nil {
				return e
			}
			if den.Tok == IDENTIFIER {
				den = get(den.Value.(string))
			}

			if a.Tok == NUMBER && den.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Atan(a.Value.(float64) / den.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `atan` values are not numbers or floats @%v", idx)
			}
		case LN:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Log(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `ln` values are not numbers or floats @%v", idx)
			}
		case LOG:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Log10(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `log` values are not numbers or floats @%v", idx)
			}
		case LOG3:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Log(a.Value.(float64)) / math.Log(3.0), 0})
			} else {
				return fmt.Errorf("cannot `log3` values are not numbers or floats @%v", idx)
			}
		case CLIP:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Floor(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `clip` values are not numbers or floats @%v", idx)
			}
		case SMOOTH:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Round(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `smooth` values are not numbers or floats @%v", idx)
			}
		case HOWMUCH:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, math.Abs(a.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `howmuch` values are not numbers or floats @%v", idx)
			}
		case SETRAND:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				rand.Seed(int64(a.Value.(float64)))
			} else {
				return fmt.Errorf("cannot `setrand` values are not numbers or floats @%v", idx)
			}
		case RAND:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				max := a.Value.(float64)
				r := rand.Intn(int(max))
				push(Expr{NUMBER, nil, float64(r), 0})
			} else {
				return fmt.Errorf("cannot `rand` values are not numbers or floats @%v", idx)
			}
		case PI:
			push(Expr{NUMBER, nil, 3.14159265358979323846, 0})
		case E:
			push(Expr{NUMBER, nil, 2.71828182845904523536, 0})
		case ISINT:
			a, e := popExpr()
			if e != nil {
				return e
			}

			push(Expr{BOOLEAN, nil, a.Value.(float64) == float64(int64(a.Value.(float64))), 0})
		case ISNUMBER:
			a, e := popExpr()
			if e != nil {
				return e
			}

			push(Expr{BOOLEAN, nil, (a.Tok == NUMBER), 0})
		case NUMBERIZE:
			str, e := pop()
			if e != nil {
				return e
			}
			if str.Tok != STRING {
				return fmt.Errorf("cannot `numberize` not a string @%v", idx)
			}

			num, err := strconv.ParseFloat(str.Value.(string), 64)
			if err != nil {
				return err
			}

			push(Expr{NUMBER, nil, num, 0})
		case ISOLATE:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) & int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `isolate` values are not numbers @%v", idx)
			}
		case MIX:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) | int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `mix` values are not numbers @%v", idx)
			}
		case CONTRADICT:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) ^ int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `contradict` values are not numbers @%v", idx)
			}
		case COMPL:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(^int64(a.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `compl` values are not numbers @%v", idx)
			}
		case SHIFTRIGHT:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) >> int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `shiftright` values are not numbers @%v", idx)
			}
		case SHIFTLEFT:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{NUMBER, nil, float64(int64(a.Value.(float64)) << int64(b.Value.(float64))), 0})
			} else {
				return fmt.Errorf("cannot `shiftleft` values are not numbers @%v", idx)
			}
		case GT:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) > (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `gt` values are not numbers @%v", idx)
			}
		case LT:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) < (b.Value.(float64)), 0})

			} else {
				return fmt.Errorf("cannot `lt` values are not numbers @%v", idx)
			}
		case EQ:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) == b.Value.(float64), 0})
			} else {
				return fmt.Errorf("cannot `eq` values are not numbers @%v", idx)
			}
		case GE:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) >= (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `ge` values are not numbers @%v", idx)
			}
		case LE:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) <= (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `le` values are not numbers @%v", idx)
			}
		case NE:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER && b.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) != (b.Value.(float64)), 0})
			} else {
				return fmt.Errorf("cannot `ne` values are not numbers @%v", idx)
			}
		case ISNULL:
			a, e := popExpr()
			if e != nil {
				return e
			}
			push(Expr{BOOLEAN, nil, (a.Tok == NULL || a.Value == nil), 0})
		case NEGATIVE:
			a, e := popExpr()
			if e != nil {
				return e
			}

			if a.Tok == NUMBER {
				push(Expr{BOOLEAN, nil, a.Value.(float64) < 0.0, 0})
			} else {
				return fmt.Errorf("cannot `negative` values are not numbers @%v", idx)
			}
		case AND:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == BOOLEAN && b.Tok == BOOLEAN {
				push(Expr{BOOLEAN, nil, (a.Value.(bool) && b.Value.(bool)), 0})
			} else {
				return fmt.Errorf("cannot `and` values are not numbers @%v", idx)
			}
		case OR:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == BOOLEAN && b.Tok == BOOLEAN {
				push(Expr{BOOLEAN, nil, (a.Value.(bool) || b.Value.(bool)), 0})
			} else {
				return fmt.Errorf("cannot `or` values are not numbers @%v", idx)
			}
		case XOR:
			b, a, e := pop2Expr()
			if e != nil {
				return e
			}

			if a.Tok == BOOLEAN && b.Tok == BOOLEAN {
				push(Expr{BOOLEAN, nil, (a.Value.(bool) != b.Value.(bool)), 0})
			} else {
				return fmt.Errorf("cannot `xor` values are not numbers @%v", idx)
			}
		case DISP:
			a, e := pop()
			if e != nil {
				return e
			}
			if a.Tok == IDENTIFIER {
				fmt.Fprintf(w, "%v", get(a.Value.(string)))
			} else if a.Tok == NUMBER {
				if a.Value.(float64) == float64(int64(a.Value.(float64))) {
					fmt.Fprintf(w, "%d", int64(a.Value.(float64)))
				} else {
					fmt.Fprintf(w, "%f", a.Value.(float64))
				}
			} else {
				fmt.Fprintf(w, "%v", a.Value)
			}
		case LISTEN:
			// FIXME: should there be a way to do this in wasm??
			if runtime.GOARCH == "wasm" {
				return nil
			}

			var str string

			s.Scan()
			str = s.Text()

			if s.Err() != nil {
				return s.Err()
			}
			push(Expr{STRING, nil, str, 0})
		case COMPLAIN:
			a, e := popExpr()
			if e != nil {
				return e
			}
			fmt.Fprintf(os.Stderr, "%v", a.Value)
		case NEWLINE:
			fmt.Fprintf(w, "\n")
		case TAB:
			fmt.Fprintf(w, "\t")
		case WHEREAMI:
			if runtime.GOARCH == "wasm" {
				return nil
			}
			conn, e := net.Dial("udp", "8.8.8.8:80")
			if e != nil {
				return e
			}
			defer conn.Close()

			localAddr := conn.LocalAddr().(*net.UDPAddr)

			fmt.Fprintf(w, "%s\n", localAddr.IP.String())
		case SERVEHTTP:
			if runtime.GOARCH == "wasm" {
				return nil
			}

			str, e := pop()
			if e != nil {
				return e
			}
			if str.Tok != STRING {
				return fmt.Errorf("cannot `servehttp` exptected a string for the port @%v", idx)
			}

			fun, e := pop()
			if e != nil {
				return e
			}
			if fun.Tok != FUNCTION {
				return fmt.Errorf("cannot `servehttp` exptected a function to serve @%v", idx)
			}

			http.ListenAndServe(str.Value.(string), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				req := make([]string, 0)
				b, err := ioutil.ReadAll(r.Body)
				if err != nil {
					fmt.Println(err)
					return
				}
				req = append(req, r.RequestURI)
				req = append(req, string(b))
				req = append(req, r.Method)
				// maybe should add the headers here
				// add the number of arguments for the header

				err = Interpret(fun, req, w)
				if err != nil {
					fmt.Println(err)
				}
			}))
		case READALL:
			str, e := pop()
			if e != nil {
				return e
			}
			if str.Tok != STRING {
				return fmt.Errorf("cannot `readall` @%v", idx)
			}

			filedata, err := ioutil.ReadFile(str.Value.(string)) // the file is inside the local directory
			if err != nil {
				return err
			}
			push(Expr{STRING, nil, string(filedata), 0})
		case VERSION:
			fmt.Fprintf(w, "var'aq -- 0.9.2 Martoq")
		case ARGV:
			arg := Expr{LIST, make([]Expr, 0), nil, 0}
			for _, v := range argv {
				arg.Exprs = append(arg.Exprs, Expr{STRING, nil, v, 0})
			}
			push(arg)
		case TIME:
			push(Expr{NUMBER, nil, float64(time.Now().Unix()), 0})
		case TILDE:
		default:
			return fmt.Errorf("unknown opcode")
		}
	}
	return nil
}