package shsh

import (
    "strings"
    "unicode"
)

/*
 * LIST: a list of elements
 * OPERAND: a string or number
 * OPERATOR: an entry in a symtable
 * OPERATION: a list starting with an operator
 */
type parse_tag int
const (
    LIST_T      parse_tag = iota
    SYMBOL_T    parse_tag = iota
    OPERAND_T   parse_tag = iota
    OPERATION_T parse_tag = iota
)

func Parse(arg *Token) {
    switch arg.tag {
    case LIST_T:
        for i := arg; i; i = i.next {
            Parse(i)
        }

        if list_is_operation(arg) {
            arg.tag = OPERATION_T
        }

    case OPERAND_T:
        if string_is_symbol(arg._inner) {
            arg.tag = SYMBOL_T
        }

    default:
        ;// TODO: Tag a parse error?
    }
}

func string_delimiters_valid(arg string) bool {
    delim := arg[0]
    iter := 0

    if delim != arg[len(arg) - 1] {
        return false
    }

    for _, r := range arg {
        if delim == r {
            iter += 1
        }
    }

    return iter == 2
}

func list_is_operation(arg *Token) bool {
    // TODO: Rewrite after implementing a symbol table
    //return ((*Token) arg._inner).tag == OPERATOR_T
}

// theres probly a way better way to do it.
func string_is_symbol(arg string) bool {
    for _, r := range arg {
        if !unicode.IsLetter(r) && r != '_' {
            return false
        }
    }

    return true
}