prosper/builtins.go

package main

import "fmt"

// Builtins is a handy holder for our various default words
type Builtins struct{}

// ErrExit is a special sentinel value to cease computation and quit
var ErrExit = fmt.Errorf("exit requested")

// Eq compares TOS and NOS and puts -1 on the stack if they're equal, 0 otherwise.
func (b *Builtins) Eq(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos == nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// NEq compares TOS and NOS and puts -1 on the stack if they're not equal, 0 otherwise.
func (b *Builtins) NEq(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos != nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// Lt compares TOS and NOS and puts -1 on the stack if TOS is less than NOS, 0 otherwise.
func (b *Builtins) Lt(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos < nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// Gt compares TOS and NOS and puts -1 on the stack if TOS is greater than NOS, 0 otherwise.
func (b *Builtins) Gt(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos > nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// LtEq compares TOS and NOS and puts -1 on the stack if TOS is less than or equal to NOS, 0 otherwise.
func (b *Builtins) LtEq(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos <= nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// GtEq compares TOS and NOS and puts -1 on the stack if TOS is greater than or equal to NOS, 0 otherwise.
func (b *Builtins) GtEq(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		if tos >= nos {
			s.Push(-1)
			return nil
		}
		s.Push(0)
		return nil
	}
}

// Add sums the top two numbers on the stack and pushes the result
func (b *Builtins) Add(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(tos + nos)
		return nil
	}
}

// Sub performs NOS - TOS and pushes the result
func (b *Builtins) Sub(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(nos - tos)
		return nil
	}
}

// Mul multiplies the two numbers on the top of the stack and pushes the result
func (b *Builtins) Mul(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(nos * tos)
		return nil
	}
}

// Div performs NOS/TOS and pushes the (integer!) result
func (b *Builtins) Div(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(nos / tos)
		return nil
	}
}

// Print pops the stack and outputs it to stdout
func (b *Builtins) Print(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		fmt.Print(tos, " ")
		return nil
	}
}

// Dup pops the stack, then pushes two copies onto the stack
func (b *Builtins) Dup(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(tos)
		s.Push(tos)
		return nil
	}
}

// Swap inverts the order of TOS and NOS
func (b *Builtins) Swap(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(tos)
		s.Push(nos)
		return nil
	}
}

// Over duplicates NOS to TOS, resulting in NOS TOS NOS
func (b *Builtins) Over(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(nos)
		s.Push(tos)
		s.Push(nos)
		return nil
	}
}

// Drop simply discards TOS
func (b *Builtins) Drop(s *Stack) func() error {
	return func() error {
		_, err := s.Pop()
		return err
	}
}

// Rot cycles the first three items on the stack: TOS 1 2 3 -> TOS 3 1 2
func (b *Builtins) Rot(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		nos, err := s.Pop()
		if err != nil {
			return err
		}
		p3, err := s.Pop()
		if err != nil {
			return err
		}
		s.Push(nos)
		s.Push(tos)
		s.Push(p3)
		return err
	}
}

// Words outputs a list of all known words in the dictionary
func (b *Builtins) Words(d Dictionary) func() error {
	return func() error {
		for n := range d {
			fmt.Printf("%s %s\n", n, d[n].Source)
		}
		return nil
	}
}

// Emit outputs the UTF-8 rune for the int on the top of the stack
func (b *Builtins) Emit(s *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		fmt.Print(string(rune(tos)) + " ")
		return nil
	}
}

// ToR pops from the stack to the return stack
func (b *Builtins) ToR(s *Stack, r *Stack) func() error {
	return func() error {
		tos, err := s.Pop()
		if err != nil {
			return err
		}
		r.Push(tos)
		return nil
	}
}

// RFrom pops from the return stack to the stack
func (b *Builtins) RFrom(s *Stack, r *Stack) func() error {
	return func() error {
		tors, err := r.Pop()
		if err != nil {
			return err
		}
		s.Push(tors)
		return nil
	}
}

// RFetch copies from the return stack to the stack
func (b *Builtins) RFetch(s *Stack, r *Stack) func() error {
	return func() error {
		tors, err := r.Pop()
		if err != nil {
			return err
		}
		r.Push(tors)
		s.Push(tors)
		return nil
	}
}

// If checks if NOS != 0 and conditionally executes any following statements if so
func (b *Builtins) If(s *Stack, r *Stack) func() error {
	return func() error {
		return nil
	}
}

// Else executes a separate piece of code if NOS == 0 after an if check
func (b *Builtins) Else(s *Stack, r *Stack) func() error {
	return func() error {
		return nil
	}
}

// Then ends an If/Else block
func (b *Builtins) Then(s *Stack, r *Stack) func() error {
	return func() error {
		return nil
	}
}

// Do sets up a loop
func (b *Builtins) Do(s *Stack, r *Stack) func() error {
	return func() error {
		return nil
	}
}

// Loop closes a loop
func (b *Builtins) Loop(s *Stack, r *Stack) func() error {
	return func() error {
		return nil
	}
}

// CR prints a newline to standard out
func (b *Builtins) CR() func() error {
	return func() error {
		fmt.Print("\n")
		return nil
	}
}

// Quit exits the repl
func (b *Builtins) Quit() func() error {
	return func() error {
		return ErrExit
	}
}

// Debug prints the stack without modifying it
func (b *Builtins) Debug(s *Stack) func() error {
	return func() error {
		fmt.Print(s.values, " ")
		return nil
	}
}