func calculateExprs(ctx *Context, bin *ast.BinaryExpr, doOp bool) (string, error) {
lit, err := calc.Resolve(bin, doOp)
if err != nil {
return "", err
}
return lit.Value, nil
}
func callBuiltin(name string, fn call, expr *ast.CallExpr) (ast.Expr, error) {
// Walk through the function
// These should be processed at registration time
callargs := make([]ast.Expr, len(fn.params))
for i := range fn.params {
expr := fn.params[i].Value
// if expr != nil {
// callargs[i] = expr.(*ast.BasicLit)
// }
callargs[i] = expr
}
var argpos int
incoming := expr.Args
// Verify args and convert to BasicLit before passing along
if len(callargs) < len(incoming) {
for i, p := range incoming {
lit, ok := p.(*ast.BasicLit)
if !ok {
log.Fatalf("failed to convert to lit % #v\n", p)
}
log.Printf("inc %d %s:% #v\n", i, lit.Kind, p)
}
return nil, fmt.Errorf("mismatched arg count %s got: %d wanted: %d",
name, len(incoming), len(callargs))
}
for i, arg := range incoming {
if argpos < i {
argpos = i
}
switch v := arg.(type) {
case *ast.KeyValueExpr:
pos := fn.Pos(v.Key.(*ast.Ident))
callargs[pos] = v.Value.(*ast.BasicLit)
case *ast.ListLit:
callargs[argpos] = v
case *ast.Ident:
if v.Obj != nil {
ass := v.Obj.Decl.(*ast.AssignStmt)
callargs[argpos] = ass.Rhs[0]
} else {
callargs[argpos] = v
}
default:
lit, err := calc.Resolve(v, true)
if err == nil {
callargs[argpos] = lit
} else {
return nil, err
}
}
}
if fn.ch != nil {
lits := make([]*ast.BasicLit, len(callargs))
var err error
for i, x := range callargs {
lits[i], err = calc.Resolve(x, true)
// lits[i], ok = exprToLit(x)
if err != nil {
return nil, fmt.Errorf("failed to parse arg(%d) in %s: %s", i, fn.name, err)
}
}
return fn.ch(expr, lits...)
}
return fn.handle(expr, callargs...)
}