110 lines
2.7 KiB
Go
110 lines
2.7 KiB
Go
/* SHS: Syntactically Homogeneous Shell
|
|
* Copyright (C) 2019 Aidan Hahn
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package log
|
|
|
|
import (
|
|
"strings"
|
|
"fmt"
|
|
"git.callpipe.com/aidan/shs/ast"
|
|
"git.callpipe.com/aidan/shs/datatypes"
|
|
)
|
|
|
|
/* Print function which is better suited for repl.
|
|
* This one prints the SEXPRs as one would write them.
|
|
*/
|
|
func (t *ast.Token) String() string {
|
|
switch tag {
|
|
case ast.STRING
|
|
return "\"" + t.Inner.(string) + "\""
|
|
|
|
case ast.NUMBER:
|
|
return t.Inner.(string)
|
|
|
|
case ast.LIST:
|
|
repr := "("
|
|
for i := t.Inner.(*ast.Token); i != nil; i = i.Next {
|
|
repr = repr + i.String() + " "
|
|
}
|
|
return repr + ")"
|
|
|
|
case ast.SYMBOL:
|
|
return "<" + t.Inner.(string) + ">"
|
|
}
|
|
}
|
|
|
|
/* Print function which breaks each embedded list out on individual lines.
|
|
* Used in the print_ast debug tool. not too useful for repl applications.
|
|
* Very useful for debugging syntax though.
|
|
* TODO: Add numbers to denote embedded scope?
|
|
*/
|
|
func PrintSExprsIndividually(arg *ast.Token) {
|
|
if arg == nil {
|
|
return //TODO: Handle error here?
|
|
}
|
|
|
|
var lists datatypes.TokenStack;
|
|
lists.Push(arg)
|
|
|
|
loop:
|
|
var constructor strings.Builder
|
|
i := lists.Pop()
|
|
if i == nil {
|
|
return
|
|
}
|
|
|
|
for iter := i; iter != nil; iter = iter.Next {
|
|
if iter.Tag == ast.LIST {
|
|
lists.Push(iter.Inner.(*ast.Token))
|
|
}
|
|
|
|
constructor.WriteString(FmtToken(iter))
|
|
}
|
|
|
|
println(constructor.String())
|
|
goto loop
|
|
}
|
|
|
|
func FmtToken(arg *ast.Token) string {
|
|
suffix := "->"
|
|
if arg.Next == nil {
|
|
suffix = ""
|
|
}
|
|
|
|
switch arg.Tag {
|
|
case ast.LIST:
|
|
return fmt.Sprintf("(%s, [List])%s", "LIST", suffix)
|
|
|
|
default:
|
|
return fmt.Sprintf("(%s, %s)%s", GetTagAsStr(arg.Tag), arg.Inner, suffix)
|
|
}
|
|
}
|
|
|
|
func GetTagAsStr(tag ast.Token_t) string {
|
|
switch tag {
|
|
case ast.LIST:
|
|
return "LIST"
|
|
case ast.STRING:
|
|
return "STRING"
|
|
case ast.NUMBER:
|
|
return "NUMBER"
|
|
case ast.SYMBOL:
|
|
return "SYMBOL"
|
|
}
|
|
return "UNKNOWN"
|
|
}
|
|
|