func fn_build(argsource types.ArgSource) (types.FuObject, []error) {
	rt := argsource.(RuntimeArgs).runtime
	args := argsource.Args()
	targets := rt.nodify(args[0])
	sources := rt.nodify(args[1])
	actionobj := args[2]

	fmt.Printf(
		"fn_build():\n"+
			"  targets: %T %v\n"+
			"  sources: %T %v\n"+
			"  actions: %T %v\n",
		targets, targets, sources, sources, actionobj, actionobj)

	var errs []error
	var action Action
	if actionstr, ok := actionobj.(types.FuString); ok {
		action = NewCommandAction(actionstr)
	} else {
		errs = append(errs, errors.New("build(): only command strings supported as actions right now, sorry"))
	}

	rule := NewBuildRule(rt, targets, sources)
	rule.action = action

	return rule, errs
}

func meth_FinderNode_prune(args types.ArgSource) (types.FuObject, []error) {
	robj := args.Receiver().(*FinderNode)
	for _, arg := range args.Args() {
		robj.Prune(arg.String())
	}
	return nil, nil
}

func logFunctionCall(callable types.FuCallable, args types.ArgSource) {
	argstrings := make([]string, len(args.Args()))
	for i, arg := range args.Args() {
		argstrings[i] = arg.String()
	}
	log.Info("%s(%s)", callable.Name(), strings.Join(argstrings, ", "))
}

func fn_remove(argsource types.ArgSource) (types.FuObject, []error) {
	errs := make([]error, 0)
	for _, name := range argsource.Args() {
		err := os.RemoveAll(name.ValueString())
		if err != nil {
			errs = append(errs, err)
		}
	}
	return nil, errs
}

func fn_println(argsource types.ArgSource) (types.FuObject, []error) {
	for i, val := range argsource.Args() {
		if i > 0 {
			os.Stdout.WriteString(" ")
		}
		var s string
		if val == nil {
			s = "(nil)"
		} else {
			s = val.ValueString()
		}
		_, err := os.Stdout.WriteString(s)
		if err != nil {
			// this shouldn't happen, so bail immediately
			return nil, []error{err}
		}
	}
	os.Stdout.WriteString("\n")
	return nil, nil
}

func (self PythonCallable) callPython(argsource types.ArgSource) (types.FuObject, []error) {
	args := argsource.Args()

	// build a slice of strings, which will then be converted to
	// Python strings in C (this way we only copy the bytes once, at
	// the cost of C code knowing the internals of Go slices and
	// strings)
	sargs := make([]string, len(args))
	for i, arg := range args {
		switch arg.(type) {
		case types.FuString:
			sargs[i] = arg.ValueString()
		default:
			err := fmt.Errorf(
				"bad argument type: all arguments must be strings, "+
					"but argument %d is %s %s",
				i+1, arg.Typename(), arg.String())
			return nil, []error{err}
		}
	}

	var cerror *C.char
	var cresult *C.char
	var result types.FuObject
	cresult = C.call_python(self.callable, unsafe.Pointer(&sargs), &cerror)

	if cerror != nil {
		err := C.GoString(cerror)
		return nil, []error{errors.New(err)}
	}
	if cresult != nil {
		result = types.MakeFuString(C.GoString(cresult))
	}

	return result, nil
}

func fn_ActionNode(argsource types.ArgSource) (types.FuObject, []error) {
	basename := argsource.Args()[0].ValueString()
	graph := argsource.(RuntimeArgs).Graph()
	return dag.MakeActionNode(graph, basename+":action"), nil
}

func fn_FileNode(argsource types.ArgSource) (types.FuObject, []error) {
	name := argsource.Args()[0].ValueString()
	graph := argsource.(RuntimeArgs).Graph()
	return dag.MakeFileNode(graph, name), nil
}

func Test_evaluateCall_method(t *testing.T) {
	// construct AST for "a.b.c(x)"
	astargs := []dsl.ASTExpression{dsl.NewASTName("x")}
	astcall := dsl.NewASTFunctionCall(
		dsl.NewASTSelection(
			dsl.NewASTSelection(dsl.NewASTName("a"), "b"), "c"),
		astargs)

	// make sure a is an object with attributes, and b is one of them
	// (N.B. having FileNodes be attributes of one another is weird
	// and would never happen in a real Fubsy script, but it's a
	// convenient way to setup this method call)
	aobj := dag.NewFileNode("a.txt")
	bobj := dag.NewFileNode("b.txt")
	aobj.ValueMap = types.NewValueMap()
	aobj.Assign("b", bobj)

	// make sure a.b.c is a method
	calls := make([]string, 0) // list of function names
	var meth_c types.FuCode
	meth_c = func(argsource types.ArgSource) (types.FuObject, []error) {
		args := argsource.Args()
		if len(args) != 1 {
			panic("c() called with wrong number of args")
		}
		calls = append(calls, "c")
		robj := argsource.Receiver()
		return nil, []error{
			fmt.Errorf("c failed: receiver: %s %v, arg: %s %v",
				robj.Typename(), robj, args[0].Typename(), args[0])}
	}
	bobj.ValueMap = types.NewValueMap()
	bobj.Assign("c", types.NewFixedFunction("c", 1, meth_c))

	rt := minimalRuntime()
	ns := rt.Namespace()
	ns.Assign("a", aobj)
	ns.Assign("x", types.MakeFuString("hello"))

	// what the hell, let's test the precall feature too
	var precalledCallable types.FuCallable
	var precalledArgs types.ArgSource
	precall := func(callable types.FuCallable, argsource types.ArgSource) {
		precalledCallable = callable
		precalledArgs = argsource
	}

	callable, args, errs := rt.prepareCall(astcall)
	assert.Equal(t, "c", callable.(*types.FuFunction).Name())
	assert.True(t, args.Receiver() == bobj)
	assert.Equal(t, 0, len(errs))

	result, errs := rt.evaluateCall(callable, args, precall)
	assert.Equal(t, precalledCallable, callable)
	assert.Equal(t, precalledArgs.Args(), types.MakeStringList("hello").List())
	assert.Nil(t, result)
	if len(errs) == 1 {
		assert.Equal(t,
			"c failed: receiver: FileNode \"b.txt\", arg: string \"hello\"",
			errs[0].Error())
	} else {
		t.Errorf("expected exactly 1 error, but got: %v", errs)
	}
}