//NameToFunc compiles a parsed name expression into a function.
func NameToFunc(n *ast.NameExpr) funcs.Bool {
typ := n.GetValue()
switch v := typ.(type) {
case *ast.Name:
if v.DoubleValue != nil {
return funcs.DoubleEq(funcs.DoubleVar(), funcs.DoubleConst(v.GetDoubleValue()))
} else if v.IntValue != nil {
return funcs.IntEq(funcs.IntVar(), funcs.IntConst(v.GetIntValue()))
} else if v.UintValue != nil {
return funcs.UintEq(funcs.UintVar(), funcs.UintConst(v.GetUintValue()))
} else if v.BoolValue != nil {
return funcs.BoolEq(funcs.BoolVar(), funcs.BoolConst(v.GetBoolValue()))
} else if v.StringValue != nil {
return funcs.StringEq(funcs.StringVar(), funcs.StringConst(v.GetStringValue()))
} else if v.BytesValue != nil {
return funcs.BytesEq(funcs.BytesVar(), funcs.BytesConst(v.GetBytesValue()))
}
panic(fmt.Sprintf("unknown name expr name %#v", v))
case *ast.AnyName:
return funcs.BoolConst(true)
case *ast.AnyNameExcept:
return funcs.Not(NameToFunc(v.GetExcept()))
case *ast.NameChoice:
return funcs.Or(NameToFunc(v.GetLeft()), NameToFunc(v.GetRight()))
}
panic(fmt.Sprintf("unknown name expr typ %T", typ))
}
func composeVariable(v *ast.Variable) funcs.Variable {
switch v.Type {
case types.SINGLE_DOUBLE:
return funcs.DoubleVar()
case types.SINGLE_INT:
return funcs.IntVar()
case types.SINGLE_UINT:
return funcs.UintVar()
case types.SINGLE_BOOL:
return funcs.BoolVar()
case types.SINGLE_STRING:
return funcs.StringVar()
case types.SINGLE_BYTES:
return funcs.BytesVar()
}
panic("unreachable")
}
func composeDouble(expr *ast.Expr) (funcs.Double, error) {
uniq, err := prep(expr, types.SINGLE_DOUBLE)
if err != nil {
return nil, err
}
if expr.Terminal != nil {
if expr.GetTerminal().Variable != nil {
return funcs.DoubleVar(), nil
} else {
return funcs.DoubleConst(expr.GetTerminal().GetDoubleValue()), nil
}
}
values, err := newValues(expr.GetFunction().GetParams())
if err != nil {
return nil, err
}
return funcs.NewDoubleFunc(uniq, values...)
}