Merge pull request #149 from corywalker/corywalker

Corywalker

expreduce.go

@@ -60,7 +60,7 @@ func main() {
 
 		exp := expreduce.Interp(line, es)
 		res := exp.Eval(es)
-		res = es.ProcessTopLevelResult(res)
+		res = es.ProcessTopLevelResult(exp, res)
 
 		isNull := false
 		asSym, isSym := res.(*expreduce.Symbol)

expreduce/builtin_system.go

@@ -277,14 +277,11 @@ func GetSystemDefinitions() (defs []Definition) {
 				return this
 			}
 
-			toReturn := NewExpression([]Ex{NewSymbol("System`List")})
 			def, isDef := es.defined[sym.Name]
 			if isDef {
-				for _, s := range def.attributes.toStrings() {
-					toReturn.Parts = append(toReturn.Parts, NewSymbol("System`"+s))
-				}
+				return def.attributes.toSymList()
 			}
-			return toReturn
+			return NewExpression([]Ex{NewSymbol("System`List")})
 		},
 	})
 	defs = append(defs, Definition{
@@ -321,7 +318,6 @@ func GetSystemDefinitions() (defs []Definition) {
 	})
 	defs = append(defs, Definition{
 		Name:              "Definition",
-		OmitDocumentation: true,
 		toString: func(this *Expression, params ToStringParams) (bool, string) {
 			if len(this.Parts) != 2 {
 				return false, ""
@@ -334,14 +330,20 @@ func GetSystemDefinitions() (defs []Definition) {
 			if !ok {
 				return false, ""
 			}
+			if params.es == nil {
+				return true, "Definiton[<WITHOUT_CONTEXT>]"
+			}
 			def, isd := params.es.defined[sym.Name]
 			if !isd {
 				return true, "Null"
 			}
 			stringParams := params
 			stringParams.context, stringParams.contextPath =
 				DefinitionComplexityStringFormArgs()
-			return true, def.StringForm(stringParams)
+			stringParams.previousHead = "<TOPLEVEL>"
+			// To prevent things like "Definition[In]" from exploding:
+			stringParams.es = nil
+			return true, def.StringForm(sym, stringParams)
 		},
 	})
 	defs = append(defs, Definition{
@@ -382,7 +384,7 @@ func GetSystemDefinitions() (defs []Definition) {
 			if len(this.Parts) != 3 {
 				return false, ""
 			}
-			return ToStringInfixAdvanced(this.Parts[1:], " = ", "System`Set", false, "(", ")", params)
+			return ToStringInfixAdvanced(this.Parts[1:], " = ", "System`Set", false, "", "", params)
 		},
 		Bootstrap: true,
 		legacyEvalFn: func(this *Expression, es *EvalState) Ex {
@@ -522,8 +524,16 @@ func GetSystemDefinitions() (defs []Definition) {
 				return this
 			}
 
+			context, contextPath := ActualStringFormArgs(es)
+			stringParams := ToStringParams{
+				form: "OutputForm",
+				context: context,
+				contextPath: contextPath,
+				previousHead: "<TOPLEVEL>",
+				es: es,
+			}
 			for i := 1; i < len(this.Parts); i++ {
-				fmt.Printf("%s", this.Parts[i].String())
+				fmt.Printf("%s", this.Parts[i].StringForm(stringParams))
 			}
 			fmt.Printf("\n")
 			return NewSymbol("System`Null")
@@ -787,5 +797,6 @@ func GetSystemDefinitions() (defs []Definition) {
 		Name: "Defer",
 		OmitDocumentation: true,
 	})
+	defs = append(defs, Definition{Name: "Information"})
 	return
 }

expreduce/definition.go

@@ -1,6 +1,6 @@
 package expreduce
 
-import "bytes"
+import "strings"
 
 type DownValue struct {
 	rule        *Expression
@@ -32,28 +32,41 @@ func CopyDefs(in map[string]Def) map[string]Def {
 	return out
 }
 
-func (this *Def) String() string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	for i, dv := range this.downvalues {
-		buffer.WriteString(dv.rule.String())
-		if i != len(this.downvalues)-1 {
-			buffer.WriteString("\n")
-		}
+func (def *Def) StringForm(defSym *Symbol, params ToStringParams) string {
+	var buffer []string
+
+	attrs := def.attributes.toStrings()
+	if len(attrs) > 0 {
+		e := E(
+			S("Set"),
+			E(
+				S("Attributes"),
+				defSym,
+			),
+			def.attributes.toSymList(),
+		)
+		buffer = append(buffer, e.StringForm(params))
 	}
-	buffer.WriteString("}")
-	return buffer.String()
-}
 
-func (def *Def) StringForm(params ToStringParams) string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	for i, dv := range def.downvalues {
-		buffer.WriteString(dv.rule.StringForm(params))
-		if i != len(def.downvalues)-1 {
-			buffer.WriteString("\n")
-		}
+	for _, dv := range def.downvalues {
+		e := E(
+			S("SetDelayed"),
+			dv.rule.Parts[1].(*Expression).Parts[1],
+			dv.rule.Parts[2],
+		)
+		buffer = append(buffer, e.StringForm(params))
+	}
+
+	if def.defaultExpr != nil {
+		e := E(
+			S("Set"),
+			E(
+				S("Default"),
+				defSym,
+			),
+			def.defaultExpr,
+		)
+		buffer = append(buffer, e.StringForm(params))
 	}
-	buffer.WriteString("}")
-	return buffer.String()
+	return strings.Join(buffer[:], "\n\n")
 }

expreduce/evalstate.go

@@ -1,12 +1,10 @@
 package expreduce
 
 import (
-	"bytes"
 	"fmt"
 	"log"
 	"os"
 	"os/signal"
-	"sort"
 	"strings"
 	"time"
 )
@@ -92,6 +90,8 @@ func (es *EvalState) Init(loadAllDefs bool) {
 		es.MarkSeen("System`InputForm")
 		es.MarkSeen("System`OutputForm")
 		es.MarkSeen("System`FullForm")
+		es.MarkSeen("System`TraditionalForm")
+		es.MarkSeen("System`StandardForm")
 
 		es.MarkSeen("System`ESimpleExamples")
 		es.MarkSeen("System`EFurtherExamples")
@@ -131,11 +131,15 @@ func (es *EvalState) Init(loadAllDefs bool) {
 		es.MarkSeen("System`Temporary")
 		es.MarkSeen("System`Stub")
 		es.MarkSeen("System`$Failed")
+		es.MarkSeen("System`$Line")
 		es.MarkSeen("System`Null")
 		es.MarkSeen("System`C")
 		es.MarkSeen("System`Complex")
 		es.MarkSeen("System`Integers")
 		es.MarkSeen("System`Break")
+		es.MarkSeen("System`LongForm")
+		es.MarkSeen("System`In")
+		es.MarkSeen("System`Out")
 
 		es.MarkSeen("System`Exp")
 		es.MarkSeen("System`AppellF1")
@@ -540,30 +544,6 @@ func (this *EvalState) GetDefinedSnapshot() map[string]Def {
 	return CopyDefs(this.defined)
 }
 
-func (this *EvalState) String() string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	// We sort the keys here such that converting identical EvalStates always
-	// produces the same string.
-	keys := []string{}
-	for k := range this.defined {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		v := this.defined[k]
-		buffer.WriteString(k)
-		buffer.WriteString(": ")
-		buffer.WriteString(v.String())
-		buffer.WriteString(", ")
-	}
-	if strings.HasSuffix(buffer.String(), ", ") {
-		buffer.Truncate(buffer.Len() - 2)
-	}
-	buffer.WriteString("}")
-	return buffer.String()
-}
-
 func (this *EvalState) IsFrozen() bool {
 	return this.freeze
 }
@@ -606,19 +586,24 @@ func (es *EvalState) HasThrown() bool {
 	return es.thrown != nil
 }
 
-func (es *EvalState) ProcessTopLevelResult(e Ex) Ex {
+func (es *EvalState) ProcessTopLevelResult(in Ex, out Ex) Ex {
+	theRes := out
 	if es.HasThrown() {
 		fmt.Printf("Throw::nocatch: %v returned to top level but uncaught.\n\n", es.thrown)
-		toReturn := NewExpression([]Ex{
+		theRes = NewExpression([]Ex{
 			NewSymbol("System`Hold"),
 			es.thrown,
 		})
 		// Clear exception
 		es.Throw(nil)
-		return toReturn
-	}
-	es.interrupted = false
-	return e
+	} else {
+		es.interrupted = false
+	}
+	thisLine, _ := es.GetSymDef("System`$Line")
+	E(S("SetDelayed"), E(S("In"), thisLine), in).Eval(es)
+	E(S("Set"), E(S("Out"), thisLine), theRes).Eval(es)
+	E(S("Increment"), S("$Line")).Eval(es)
+	return theRes
 }
 
 func maskNonConditional(e Ex) Ex {

expreduce/ex_expression.go

@@ -435,6 +435,17 @@ func (this *Expression) StringForm(params ToStringParams) string {
 		}
 	}
 
+	if len(this.Parts) == 2 && isHeadSym && (
+		headAsSym.Name == "System`InputForm" ||
+		headAsSym.Name == "System`FullForm" ||
+		headAsSym.Name == "System`TraditionalForm" ||
+		headAsSym.Name == "System`StandardForm" ||
+		headAsSym.Name == "System`OutputForm") {
+		mutatedParams := params
+		mutatedParams.form = headAsSym.Name[7:]
+		return this.Parts[1].StringForm(mutatedParams)
+	}
+
 	// Default printing format
 	var buffer bytes.Buffer
 	buffer.WriteString(this.Parts[0].StringForm(params))

expreduce/ex_string.go

@@ -12,7 +12,9 @@ func (this *String) Eval(es *EvalState) Ex {
 }
 
 func (this *String) StringForm(params ToStringParams) string {
-	if params.form == "OutputForm" {
+	if (params.form == "OutputForm" ||
+		params.form == "TraditionalForm" ||
+		params.form == "StandardForm") {
 		return fmt.Sprintf("%v", this.Val)
 	}
 	return fmt.Sprintf("\"%v\"", this.Val)

expreduce/ex_symbol.go

@@ -248,6 +248,14 @@ func (this *Attributes) toStrings() []string {
 	return strings
 }
 
+func (this *Attributes) toSymList() *Expression {
+	toReturn := E(S("List"))
+	for _, s := range this.toStrings() {
+		toReturn.appendEx(S(s))
+	}
+	return toReturn
+}
+
 func (this *Symbol) NeedsEval() bool {
 	return false
 }

expreduce/interp.go

@@ -337,7 +337,7 @@ func ParserExprConv(expr *wl.Expression) Ex {
 			e,
 			ParserExprConv(expr.Expression2),
 		})
-	case 140:
+	case wl.ExpressionMessageName:
 		return NewExpression([]Ex{
 			NewSymbol("System`MessageName"),
 			ParserTokenConv(expr.Token),
@@ -452,6 +452,29 @@ func ParserExprConv(expr *wl.Expression) Ex {
 			NewSymbol("System`Sqrt"),
 			ParserExprConv(expr.Expression),
 		})
+	case wl.ExpressionInfo:
+		return E(
+			S("Information"),
+			ParserTagConv(expr.Tag),
+		)
+	case wl.ExpressionInfoShort:
+		return E(
+			S("Information"),
+			ParserTagConv(expr.Tag),
+			E(S("Rule"), S("LongForm"), S("False")),
+		)
+	case 145:
+		if expr.Token.Val == "%" {
+			return E(
+				S("Out"),
+				E(S("Plus"), S("$Line"), NewInt(-1)),
+			)
+		} else if expr.Token.Val == "%%" {
+			return E(
+				S("Out"),
+				E(S("Plus"), S("$Line"), NewInt(-2)),
+			)
+		}
 	}
 	log.Fatalf("System`UnParsed: %+v %+v %+v", expr.Token, expr.Case, expr)
 	return nil

expreduce/interp_test.go

@@ -67,6 +67,6 @@ func TestInterp(t *testing.T) {
 	// Test newline handling
 	assert.Equal(t, "CompoundExpression[a, b]", Interp("a;b\n", es).String())
 	//assert.Equal(t, "Sequence[a, b]", Interp("a\nb\n", es).String())
-	assert.Equal(t, "((c = a*b))", Interp("c = (a\nb)\n", es).String())
-	assert.Equal(t, "((c = a*b))", Interp("c = (a\n\nb)\n", es).String())
+	assert.Equal(t, "(c = a*b)", Interp("c = (a\nb)\n", es).String())
+	assert.Equal(t, "(c = a*b)", Interp("c = (a\n\nb)\n", es).String())
 }