Exemple #1
0
func primConcat(e Env, head ast.Node, args []ast.Node) ast.Node {
	var sum ast.Node

	for _, arg := range args {
		if sum == nil {
			sum = arg
		} else {
			switch sumVal := sum.(type) {
			case ast.Coll:
				switch argVal := arg.(type) {
				case ast.Coll:
					var err error
					sum, err = sumVal.Append(argVal)
					if err != nil {
						panicEvalError(arg, err.Error())
					}
				default:
					panicEvalError(arg, "Cannot concat a collection with a non-collection: "+arg.String())
				}
			default:
				panicEvalError(arg, "Cannot concat a non-collection type: "+sum.String())
			}
		}
	}

	if sum == nil {
		return &ast.Nil{}
	} else {
		return sum
	}
}
Exemple #2
0
func ensureList(n ast.Node) *ast.List {
	if v, ok := n.(*ast.List); ok {
		return v
	}

	panic("Expected list: " + n.String())
}
Exemple #3
0
func ensureSymbol(n ast.Node) *ast.Symbol {
	if v, ok := n.(*ast.Symbol); ok {
		return v
	}

	panic("Expected symbol: " + n.String())
}
Exemple #4
0
func toSymbolName(n ast.Node) string {
	switch value := n.(type) {
	case *ast.Symbol:
		return value.Name
	}

	panic("Not a symbol: " + n.String())
}
Exemple #5
0
func testInputFile(sourceFilePath string, t *testing.T) {
	sourceDirPart, sourceFileNamePart := filepath.Split(sourceFilePath)
	parts := strings.Split(sourceFileNamePart, ".")
	testName := parts[0]

	outputFilePath := sourceDirPart + testName + ".out"

	input, errIn := util.ReadFile(sourceFilePath)
	if errIn != nil {
		t.Errorf("Error reading file <" + sourceFilePath + ">: " + errIn.Error())
		return
	}

	expectedRaw, errOut := util.ReadFile(outputFilePath)
	if errOut != nil {
		t.Errorf("Error reading file <" + outputFilePath + ">: " + errOut.Error())
		return
	}

	// Remove any carriage return line endings from .out file
	expectedWithUntrimmed := strings.Replace(expectedRaw, "\r", "", -1)
	expected := strings.TrimSpace(expectedWithUntrimmed)

	nodes, errors := parser.Parse(input, sourceFilePath)
	if errors.Len() != 0 {
		verify(t, sourceFilePath, input, expected, errors.String())
	} else {
		e := interpreter.NewTopLevelMapEnv()

		var outputBuffer bytes.Buffer

		dummyReadLine := func() string {
			return "text from dummy read line"
		}

		var result ast.Node
		var evalError error
		for _, n := range nodes {
			result, evalError = interpreter.Eval(e, n, &outputBuffer, dummyReadLine)
			if evalError != nil {
				break
			}
		}

		actual := (&outputBuffer).String()

		if evalError == nil {
			//DEBUG fmt.Printf("RESULT(%v): %v\n", sourceFilePath, result)
			if result != nil {
				actual = actual + result.String()
			}
		} else {
			actual = actual + evalError.Error()
		}
		verify(t, sourceFilePath, input, expected, actual)
	}
}
Exemple #6
0
func toListValue(n ast.Node) *ast.List {
	switch value := n.(type) {
	case *ast.List:
		return value
	}

	panicEvalError(n, "Expression is not a list: "+n.String())
	return nil
}
Exemple #7
0
func toSymbolValue(n ast.Node) string {
	switch value := n.(type) {
	case *ast.Symbol:
		return value.Name
	}

	panicEvalError(n, "Expression is not a symbol: "+n.String())
	return ""
}
Exemple #8
0
func toNumberValue(n ast.Node) float64 {
	switch value := n.(type) {
	case *ast.Number:
		return value.Value
	}

	panicEvalError(n, "Expression is not a number: "+n.String())
	return 0.0
}
Exemple #9
0
func specialCond(e Env, head ast.Node, args []ast.Node) packet {
	for i := 0; i < len(args); i += 2 {
		predicate := toBooleanValue(trampoline(func() packet {
			return evalNode(e, args[i])
		}))

		if predicate {
			return bounce(func() packet {
				return evalNode(e, args[i+1])
			})
		}
	}

	panicEvalError(head, "No matching cond clause: "+head.String())
	return respond(&ast.Nil{})
}