mediocregopher/ginger
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

make sure mathgen outputs code which passes go fmt

Browse Source
This commit is contained in:
Brian Picciano 2014-10-23 21:00:07 -04:00
parent f8c841fa99
commit 583e381ecb
5 changed files with 213 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@ -3,5 +3,8 @@ all: gen
test: gen
go test ./...
fmt: gen
go fmt ./...
gen:
(cd core && make gen)

125
core/math.go
View File

@ -16,9 +16,6 @@ func mathReduce(fn mathReduceFn, zero types.Elem, s seq.Seq) types.Elem {
return seq.Reduce(reduceFn, zero, s)
}
func plusInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) + Int(b)}
}
@ -75,7 +72,6 @@ func plusComplex128(a, b types.Elem) types.Elem {
return types.GoType{Complex128(a) + Complex128(b)}
}
func plusString(a, b types.Elem) types.Elem {
return types.GoType{String(a) + String(b)}
}
@ -88,95 +84,65 @@ func Plus(s seq.Seq) types.Elem {
}
first, _, _ = s.FirstRest()
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
case int:
fn = plusInt
zero = types.GoType{int(0)}
case int8:
fn = plusInt8
zero = types.GoType{int8(0)}
case int16:
fn = plusInt16
zero = types.GoType{int16(0)}
case int32:
fn = plusInt32
zero = types.GoType{int32(0)}
case int64:
fn = plusInt64
zero = types.GoType{int64(0)}
case uint:
fn = plusUint
zero = types.GoType{uint(0)}
case uint8:
fn = plusUint8
zero = types.GoType{uint8(0)}
case uint16:
fn = plusUint16
zero = types.GoType{uint16(0)}
case uint32:
fn = plusUint32
zero = types.GoType{uint32(0)}
case uint64:
fn = plusUint64
zero = types.GoType{uint64(0)}
case float32:
fn = plusFloat32
zero = types.GoType{float32(0)}
case float64:
fn = plusFloat64
zero = types.GoType{float64(0)}
case complex64:
fn = plusComplex64
zero = types.GoType{complex64(0)}
case complex128:
fn = plusComplex128
zero = types.GoType{complex128(0)}
case string:
fn = plusString
zero = types.GoType{string("")}
@ -187,9 +153,6 @@ func Plus(s seq.Seq) types.Elem {
return mathReduce(fn, zero, s)
}
func minusInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) - Int(b)}
}
@ -246,7 +209,6 @@ func minusComplex128(a, b types.Elem) types.Elem {
return types.GoType{Complex128(a) - Complex128(b)}
}
func Minus(s seq.Seq) types.Elem {
var first, zero types.Elem
@ -256,76 +218,57 @@ func Minus(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest()
first = zero
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
case int:
fn = minusInt
case int8:
fn = minusInt8
case int16:
fn = minusInt16
case int32:
fn = minusInt32
case int64:
fn = minusInt64
case uint:
fn = minusUint
case uint8:
fn = minusUint8
case uint16:
fn = minusUint16
case uint32:
fn = minusUint32
case uint64:
fn = minusUint64
case float32:
fn = minusFloat32
case float64:
fn = minusFloat64
case complex64:
fn = minusComplex64
case complex128:
fn = minusComplex128
default:
panic(fmt.Sprintf("$#v cannot have Minus called on it", first))
}
return mathReduce(fn, zero, s)
}
func multInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) * Int(b)}
}
@ -382,7 +325,6 @@ func multComplex128(a, b types.Elem) types.Elem {
return types.GoType{Complex128(a) * Complex128(b)}
}
func Mult(s seq.Seq) types.Elem {
var first, zero types.Elem
@ -391,104 +333,71 @@ func Mult(s seq.Seq) types.Elem {
}
first, _, _ = s.FirstRest()
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
case int:
fn = multInt
zero = types.GoType{int(1)}
case int8:
fn = multInt8
zero = types.GoType{int8(1)}
case int16:
fn = multInt16
zero = types.GoType{int16(1)}
case int32:
fn = multInt32
zero = types.GoType{int32(1)}
case int64:
fn = multInt64
zero = types.GoType{int64(1)}
case uint:
fn = multUint
zero = types.GoType{uint(1)}
case uint8:
fn = multUint8
zero = types.GoType{uint8(1)}
case uint16:
fn = multUint16
zero = types.GoType{uint16(1)}
case uint32:
fn = multUint32
zero = types.GoType{uint32(1)}
case uint64:
fn = multUint64
zero = types.GoType{uint64(1)}
case float32:
fn = multFloat32
zero = types.GoType{float32(1)}
case float64:
fn = multFloat64
zero = types.GoType{float64(1)}
case complex64:
fn = multComplex64
zero = types.GoType{complex64(1)}
case complex128:
fn = multComplex128
zero = types.GoType{complex128(1)}
default:
panic(fmt.Sprintf("$#v cannot have Mult called on it", first))
}
return mathReduce(fn, zero, s)
}
func divInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) / Int(b)}
}
@ -545,7 +454,6 @@ func divComplex128(a, b types.Elem) types.Elem {
return types.GoType{Complex128(a) / Complex128(b)}
}
func Div(s seq.Seq) types.Elem {
var first, zero types.Elem
@ -555,76 +463,57 @@ func Div(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest()
first = zero
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
case int:
fn = divInt
case int8:
fn = divInt8
case int16:
fn = divInt16
case int32:
fn = divInt32
case int64:
fn = divInt64
case uint:
fn = divUint
case uint8:
fn = divUint8
case uint16:
fn = divUint16
case uint32:
fn = divUint32
case uint64:
fn = divUint64
case float32:
fn = divFloat32
case float64:
fn = divFloat64
case complex64:
fn = divComplex64
case complex128:
fn = divComplex128
default:
panic(fmt.Sprintf("$#v cannot have Div called on it", first))
}
return mathReduce(fn, zero, s)
}
func modInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) % Int(b)}
}
@ -665,7 +554,6 @@ func modUint64(a, b types.Elem) types.Elem {
return types.GoType{Uint64(a) % Uint64(b)}
}
func Mod(s seq.Seq) types.Elem {
var first, zero types.Elem
@ -675,55 +563,42 @@ func Mod(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest()
first = zero
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
case int:
fn = modInt
case int8:
fn = modInt8
case int16:
fn = modInt16
case int32:
fn = modInt32
case int64:
fn = modInt64
case uint:
fn = modUint
case uint8:
fn = modUint8
case uint16:
fn = modUint16
case uint32:
fn = modUint32
case uint64:
fn = modUint64
default:
panic(fmt.Sprintf("$#v cannot have Mod called on it", first))
}
return mathReduce(fn, zero, s)
}

25
core/mathgen/mathgen.tpl
View File

@ -15,15 +15,11 @@ func mathReduce(fn mathReduceFn, zero types.Elem, s seq.Seq) types.Elem {
}
return seq.Reduce(reduceFn, zero, s)
}
{{range .}}
{{$mathOp := .}}
{{range .OpTypes}}
{{range .}}{{$mathOp := .}}{{range .OpTypes}}
func {{$mathOp.Private}}{{.CastFn}}(a, b types.Elem) types.Elem {
return types.GoType{ {{.CastFn}}(a) {{$mathOp.Op}} {{.CastFn}}(b) }
return types.GoType{{`{`}}{{.CastFn}}(a) {{$mathOp.Op}} {{.CastFn}}(b)}
}
{{end}}
{{if $mathOp.IncludeString}}
{{end}}{{if $mathOp.IncludeString}}
func {{$mathOp.Private}}String(a, b types.Elem) types.Elem {
return types.GoType{String(a) {{$mathOp.Op}} String(b)}
}
@ -38,21 +34,17 @@ func {{$mathOp.Public}}(s seq.Seq) types.Elem {
first = zero
{{else}}
if seq.Empty(s) {
return types.GoType{ {{$mathOp.Unit}} }
return types.GoType{{`{`}}{{$mathOp.Unit}}}
}
first, _, _ = s.FirstRest()
{{end}}
var fn mathReduceFn
switch first.(types.GoType).V.(type) {
{{range .OpTypes}}
case {{.Type}}:
fn = {{$mathOp.Private}}{{.CastFn}}
{{if (ne $mathOp.Unit "")}}
zero = types.GoType{ {{.Type}}({{$mathOp.Unit}}) }
{{end}}
{{end}}
{{if $mathOp.IncludeString}}
fn = {{$mathOp.Private}}{{.CastFn}}{{if (ne $mathOp.Unit "")}}
zero = types.GoType{{`{`}}{{.Type}}({{$mathOp.Unit}})}{{end}}
{{end}}{{if $mathOp.IncludeString}}
case string:
fn = {{$mathOp.Private}}String
zero = types.GoType{string("")}
@ -62,5 +54,4 @@ func {{$mathOp.Public}}(s seq.Seq) types.Elem {
}
return mathReduce(fn, zero, s)
}
{{end}}
}{{end}}

1
eval/eval.go
View File

@ -51,7 +51,6 @@ func Eval(p *pkgctx.PkgCtx, el types.Elem) types.Elem {
Bail(el, "Empty list after colon, no function given")
}
var fnName string
if gt, ok := fnEl.(types.GoType); ok {
fnName, _ = gt.V.(string)