ginger/expr/expr.go

611 lines
14 KiB
Go
Raw Normal View History

package expr
import (
"fmt"
"io"
"strconv"
"strings"
"llvm.org/llvm/bindings/go/llvm"
"github.com/mediocregopher/ginger/lexer"
)
2016-07-23 16:59:11 +00:00
// TODO empty blocks
// TODO empty parenthesis
// TODO having Equal as part of the Actual interface is going to be annoying.
// The built in macros which return their own expressions don't really care
// about it, and it's really only needed for tests I think.
// Actual represents the actual expression in question, and has certain
// properties. It is wrapped by Expr which also holds onto contextual
// information, like the token to which Actual was originally parsed from
type Actual interface {
// Equal should return true if the type and value of the other expression
// are equal.
Equal(Actual) bool
// Initializes an llvm.Value and returns it
LLVMVal(llvm.Builder) llvm.Value
}
// Expr contains the actual expression as well as some contextual information
// wrapping it. Most interactions will be with this and not with the Actual
// directly.
type Expr struct {
Actual Actual
// Token is a nice-to-have, nothing will break if it's not there
Token lexer.Token
val *llvm.Value
}
func (e Expr) LLVMVal(builder llvm.Builder) llvm.Value {
if e.val == nil {
v := e.Actual.LLVMVal(builder)
e.val = &v
}
return *e.val
}
////////////////////////////////////////////////////////////////////////////////
// Bool represents a true or false value
type Bool bool
// Equal implements the Actual method
func (b Bool) Equal(e Actual) bool {
bb, ok := e.(Bool)
if !ok {
return false
}
return bb == b
}
func (b Bool) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
////////////////////////////////////////////////////////////////////////////////
// Int represents an integer value
type Int int64
// Equal implements the Actual method
func (i Int) Equal(e Actual) bool {
ii, ok := e.(Int)
if !ok {
return false
}
return ii == i
}
// LLVMVal creates a new llvm value using the builder and returns it
func (i Int) LLVMVal(builder llvm.Builder) llvm.Value {
v := builder.CreateAlloca(llvm.Int64Type(), "")
builder.CreateStore(llvm.ConstInt(llvm.Int64Type(), uint64(i), false), v)
return v
}
////////////////////////////////////////////////////////////////////////////////
// String represents a string value
type String string
// Equal implements the Actual method
func (s String) Equal(e Actual) bool {
ss, ok := e.(String)
if !ok {
return false
}
return ss == s
}
func (s String) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
////////////////////////////////////////////////////////////////////////////////
// Identifier represents a binding to some other value which has been given a
// name
type Identifier string
// Equal implements the Actual method
func (id Identifier) Equal(e Actual) bool {
idid, ok := e.(Identifier)
if !ok {
return false
}
return idid == id
}
func (id Identifier) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
////////////////////////////////////////////////////////////////////////////////
2016-07-24 21:04:06 +00:00
// Macro is an identifier for a macro which can be used to transform
// expressions. The tokens for macros start with a '%', but the Macro identifier
// itself has that stripped off
type Macro string
// String returns the Macro with a '%' prepended to it
func (m Macro) String() string {
return "%" + string(m)
}
// Equal implements the Actual method
func (m Macro) Equal(e Actual) bool {
mm, ok := e.(Macro)
if !ok {
return false
}
return m == mm
}
func (m Macro) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
2016-07-24 21:04:06 +00:00
////////////////////////////////////////////////////////////////////////////////
// Tuple represents a fixed set of expressions which are interacted with as if
// they were a single value
type Tuple []Expr
func (tup Tuple) String() string {
strs := make([]string, len(tup))
for i := range tup {
strs[i] = fmt.Sprint(tup[i].Actual)
}
return "(" + strings.Join(strs, ", ") + ")"
}
// Equal implements the Actual method
func (tup Tuple) Equal(e Actual) bool {
tuptup, ok := e.(Tuple)
if !ok || len(tuptup) != len(tup) {
return false
}
for i := range tup {
if !tup[i].Actual.Equal(tuptup[i].Actual) {
return false
}
}
return true
}
func (tup Tuple) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
////////////////////////////////////////////////////////////////////////////////
// Pipe represents a set of expressions which operate on values and return new
// values. The inputs of one expression in the pipe is the output of the
// previous expression
type Pipe []Expr
2016-07-22 20:53:04 +00:00
func (p Pipe) String() string {
strs := make([]string, len(p))
for i := range p {
strs[i] = fmt.Sprint(p[i].Actual)
2016-07-22 20:53:04 +00:00
}
return "(" + strings.Join(strs, "|") + ")"
}
// Equal implements the Actual method
func (p Pipe) Equal(e Actual) bool {
2016-07-22 20:53:04 +00:00
pp, ok := e.(Pipe)
if !ok || len(pp) != len(p) {
2016-07-22 20:53:04 +00:00
return false
}
for i := range p {
if !p[i].Actual.Equal(pp[i].Actual) {
2016-07-22 20:53:04 +00:00
return false
}
}
return true
}
func (p Pipe) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
2016-07-22 20:53:04 +00:00
////////////////////////////////////////////////////////////////////////////////
// Statement represents an actual action which will be taken. The input value is
// used as the input to the pipe, and the output of the pipe is the output of
// the statement
2016-07-22 21:53:27 +00:00
type Statement struct {
in Expr
pipe Pipe
}
func (s Statement) String() string {
return fmt.Sprintf("(%v > %s)", s.in.Actual, s.pipe.String())
2016-07-22 21:53:27 +00:00
}
// Equal implements the Actual method
func (s Statement) Equal(e Actual) bool {
2016-07-22 21:53:27 +00:00
ss, ok := e.(Statement)
return ok && s.in.Actual.Equal(ss.in.Actual) && s.pipe.Equal(ss.pipe)
2016-07-22 21:53:27 +00:00
}
func (s Statement) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
2016-07-22 21:53:27 +00:00
////////////////////////////////////////////////////////////////////////////////
// Block represents a set of statements which share a scope, i.e. If one
// statement binds a variable the rest of the statements in the block can use
// that variable, including sub-blocks within this one.
type Block []Statement
2016-07-22 21:53:27 +00:00
func (b Block) String() string {
strs := make([]string, len(b))
for i := range b {
strs[i] = b[i].String()
2016-07-22 21:53:27 +00:00
}
return fmt.Sprintf("{ %s }", strings.Join(strs, " "))
}
// Equal implements the Actual method
func (b Block) Equal(e Actual) bool {
2016-07-22 21:53:27 +00:00
bb, ok := e.(Block)
if !ok {
return false
}
for i := range b {
if !b[i].Equal(bb[i]) {
2016-07-22 21:53:27 +00:00
return false
}
}
return true
}
func (b Block) LLVMVal(builder llvm.Builder) llvm.Value {
return llvm.Value{}
}
2016-07-22 21:53:27 +00:00
////////////////////////////////////////////////////////////////////////////////
2016-07-23 16:59:11 +00:00
type exprErr struct {
reason string
2016-07-24 02:26:26 +00:00
err error
2016-07-23 16:59:11 +00:00
tok lexer.Token
tokCtx string // e.g. "block starting at" or "open paren at"
}
func (e exprErr) Error() string {
2016-07-24 02:26:26 +00:00
var msg string
if e.err != nil {
msg = e.err.Error()
} else {
msg = e.reason
}
2016-07-23 16:59:11 +00:00
if err := e.tok.Err(); err != nil {
msg += " - token error: " + err.Error()
} else if (e.tok != lexer.Token{}) {
msg += " - "
if e.tokCtx != "" {
msg += e.tokCtx + ": "
}
msg = fmt.Sprintf("%s [line:%d col:%d]", msg, e.tok.Row, e.tok.Col)
}
return msg
}
////////////////////////////////////////////////////////////////////////////////
// toks[0] must be start
func sliceEnclosedToks(toks []lexer.Token, start, end lexer.Token) ([]lexer.Token, []lexer.Token, error) {
c := 1
ret := []lexer.Token{}
2016-07-23 16:59:11 +00:00
first := toks[0]
for i, tok := range toks[1:] {
2016-07-23 16:59:11 +00:00
if tok.Err() != nil {
return nil, nil, exprErr{
reason: fmt.Sprintf("missing closing %v", end),
tok: tok,
}
}
if tok.Equal(start) {
c++
} else if tok.Equal(end) {
c--
}
if c == 0 {
return ret, toks[2+i:], nil
}
ret = append(ret, tok)
}
2016-07-23 16:59:11 +00:00
return nil, nil, exprErr{
reason: fmt.Sprintf("missing closing %v", end),
tok: first,
tokCtx: "starting at",
}
}
2016-07-24 18:53:15 +00:00
// Parse reads in all expressions it can from the given io.Reader and returns
// them
func Parse(r io.Reader) ([]Expr, error) {
toks := readAllToks(r)
var ret []Expr
var expr Expr
var err error
for len(toks) > 0 {
if toks[0].TokenType == lexer.EOF {
return ret, nil
}
expr, toks, err = parse(toks)
if err != nil {
return nil, err
}
ret = append(ret, expr)
}
return ret, nil
}
2016-07-24 18:53:15 +00:00
// ParseAsBlock reads the given io.Reader as if it was implicitly surrounded by
// curly braces, making it into a Block. This means all expressions from the
// io.Reader *must* be statements. The returned Expr's Actual will always be a
// Block.
func ParseAsBlock(r io.Reader) (Expr, error) {
2016-07-24 18:53:15 +00:00
return parseBlock(readAllToks(r))
}
func readAllToks(r io.Reader) []lexer.Token {
l := lexer.New(r)
var toks []lexer.Token
for l.HasNext() {
toks = append(toks, l.Next())
}
return toks
}
// For all parse methods it is assumed that toks is not empty
var (
openParen = lexer.Token{TokenType: lexer.Wrapper, Val: "("}
closeParen = lexer.Token{TokenType: lexer.Wrapper, Val: ")"}
openCurly = lexer.Token{TokenType: lexer.Wrapper, Val: "{"}
closeCurly = lexer.Token{TokenType: lexer.Wrapper, Val: "}"}
comma = lexer.Token{TokenType: lexer.Punctuation, Val: ","}
2016-07-22 20:53:04 +00:00
pipe = lexer.Token{TokenType: lexer.Punctuation, Val: "|"}
2016-07-22 21:53:27 +00:00
arrow = lexer.Token{TokenType: lexer.Punctuation, Val: ">"}
)
func parse(toks []lexer.Token) (Expr, []lexer.Token, error) {
expr, toks, err := parseSingle(toks)
if err != nil {
return Expr{}, nil, err
}
if len(toks) > 0 && toks[0].TokenType == lexer.Punctuation {
return parseConnectingPunct(toks, expr)
}
return expr, toks, nil
}
func parseSingle(toks []lexer.Token) (Expr, []lexer.Token, error) {
var expr Expr
var err error
2016-07-23 16:59:11 +00:00
if toks[0].Err() != nil {
return Expr{}, nil, exprErr{
2016-07-23 16:59:11 +00:00
reason: "could not parse token",
tok: toks[0],
}
}
if toks[0].Equal(openParen) {
starter := toks[0]
var ptoks []lexer.Token
ptoks, toks, err = sliceEnclosedToks(toks, openParen, closeParen)
if err != nil {
return Expr{}, nil, err
}
if expr, ptoks, err = parse(ptoks); err != nil {
return Expr{}, nil, err
} else if len(ptoks) > 0 {
return Expr{}, nil, exprErr{
2016-07-23 16:59:11 +00:00
reason: "multiple expressions inside parenthesis",
tok: starter,
tokCtx: "starting at",
}
}
return expr, toks, nil
2016-07-22 21:53:27 +00:00
} else if toks[0].Equal(openCurly) {
var btoks []lexer.Token
btoks, toks, err = sliceEnclosedToks(toks, openCurly, closeCurly)
if err != nil {
return Expr{}, nil, err
2016-07-22 21:53:27 +00:00
}
if expr, err = parseBlock(btoks); err != nil {
return Expr{}, nil, err
2016-07-22 21:53:27 +00:00
}
return expr, toks, nil
}
if expr, err = parseNonPunct(toks[0]); err != nil {
return Expr{}, nil, err
}
return expr, toks[1:], nil
}
func parseNonPunct(tok lexer.Token) (Expr, error) {
if tok.TokenType == lexer.Identifier {
return parseIdentifier(tok)
} else if tok.TokenType == lexer.String {
return parseString(tok)
}
return Expr{}, exprErr{
2016-07-23 16:59:11 +00:00
reason: "unexpected non-punctuation token",
tok: tok,
}
}
func parseIdentifier(t lexer.Token) (Expr, error) {
e := Expr{Token: t}
if t.Val[0] == '-' || (t.Val[0] >= '0' && t.Val[0] <= '9') {
n, err := strconv.ParseInt(t.Val, 10, 64)
2016-07-23 16:59:11 +00:00
if err != nil {
return Expr{}, exprErr{
2016-07-24 02:26:26 +00:00
err: err,
2016-07-23 16:59:11 +00:00
tok: t,
}
}
e.Actual = Int(n)
2016-07-24 21:04:06 +00:00
} else if t.Val == "%true" {
e.Actual = Bool(true)
2016-07-24 21:04:06 +00:00
} else if t.Val == "%false" {
e.Actual = Bool(false)
2016-07-24 21:04:06 +00:00
} else if t.Val[0] == '%' {
e.Actual = Macro(t.Val[1:])
} else {
e.Actual = Identifier(t.Val)
}
return e, nil
}
func parseString(t lexer.Token) (Expr, error) {
str, err := strconv.Unquote(t.Val)
2016-07-23 16:59:11 +00:00
if err != nil {
return Expr{}, exprErr{
2016-07-24 02:26:26 +00:00
err: err,
2016-07-23 16:59:11 +00:00
tok: t,
}
}
return Expr{Token: t, Actual: String(str)}, nil
}
func parseConnectingPunct(toks []lexer.Token, root Expr) (Expr, []lexer.Token, error) {
if toks[0].Equal(comma) {
return parseTuple(toks, root)
2016-07-22 21:53:27 +00:00
2016-07-22 20:53:04 +00:00
} else if toks[0].Equal(pipe) {
return parsePipe(toks, root)
2016-07-22 21:53:27 +00:00
} else if toks[0].Equal(arrow) {
expr, toks, err := parse(toks[1:])
if err != nil {
return Expr{}, nil, err
2016-07-22 21:53:27 +00:00
}
pipe, ok := expr.Actual.(Pipe)
2016-07-22 21:53:27 +00:00
if !ok {
pipe = Pipe{expr}
2016-07-22 21:53:27 +00:00
}
return Expr{Token: root.Token, Actual: Statement{in: root, pipe: pipe}}, toks, nil
}
2016-07-22 21:53:27 +00:00
return root, toks, nil
}
func parseTuple(toks []lexer.Token, root Expr) (Expr, []lexer.Token, error) {
rootTup, ok := root.Actual.(Tuple)
if !ok {
rootTup = Tuple{root}
}
// rootTup is modified throughout, be we need to make it into an Expr for
// every return, which is annoying. so make a function to do it on the fly
mkRoot := func() Expr {
return Expr{Token: rootTup[0].Token, Actual: rootTup}
}
if len(toks) < 2 {
return mkRoot(), toks, nil
} else if !toks[0].Equal(comma) {
if toks[0].TokenType == lexer.Punctuation {
return parseConnectingPunct(toks, mkRoot())
}
return mkRoot(), toks, nil
}
var expr Expr
var err error
if expr, toks, err = parseSingle(toks[1:]); err != nil {
return Expr{}, nil, err
}
rootTup = append(rootTup, expr)
return parseTuple(toks, mkRoot())
}
2016-07-22 20:53:04 +00:00
func parsePipe(toks []lexer.Token, root Expr) (Expr, []lexer.Token, error) {
rootPipe, ok := root.Actual.(Pipe)
2016-07-22 20:53:04 +00:00
if !ok {
rootPipe = Pipe{root}
}
// rootPipe is modified throughout, be we need to make it into an Expr for
// every return, which is annoying. so make a function to do it on the fly
mkRoot := func() Expr {
return Expr{Token: rootPipe[0].Token, Actual: rootPipe}
2016-07-22 20:53:04 +00:00
}
if len(toks) < 2 {
return mkRoot(), toks, nil
2016-07-22 20:53:04 +00:00
} else if !toks[0].Equal(pipe) {
if toks[0].TokenType == lexer.Punctuation {
return parseConnectingPunct(toks, mkRoot())
}
return mkRoot(), toks, nil
2016-07-22 20:53:04 +00:00
}
var expr Expr
var err error
if expr, toks, err = parseSingle(toks[1:]); err != nil {
return Expr{}, nil, err
2016-07-22 20:53:04 +00:00
}
rootPipe = append(rootPipe, expr)
return parsePipe(toks, mkRoot())
2016-07-22 20:53:04 +00:00
}
2016-07-22 21:53:27 +00:00
// parseBlock assumes that the given token list is the entire block, already
// pulled from outer curly braces by sliceEnclosedToks, or determined to be the
// entire block in some other way.
func parseBlock(toks []lexer.Token) (Expr, error) {
2016-07-22 21:53:27 +00:00
b := Block{}
first := toks[0]
2016-07-22 21:53:27 +00:00
var expr Expr
var err error
for {
if len(toks) == 0 {
return Expr{Token: first, Actual: b}, nil
2016-07-22 21:53:27 +00:00
}
if expr, toks, err = parse(toks); err != nil {
return Expr{}, err
2016-07-22 21:53:27 +00:00
}
stmt, ok := expr.Actual.(Statement)
2016-07-22 21:53:27 +00:00
if !ok {
return Expr{}, exprErr{
2016-07-23 16:59:11 +00:00
reason: "blocks may only contain full statements",
tok: expr.Token,
2016-07-23 16:59:11 +00:00
tokCtx: "non-statement here",
}
2016-07-22 21:53:27 +00:00
}
b = append(b, stmt)
2016-07-22 21:53:27 +00:00
}
}