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 test: gen
go test ./... go test ./...
fmt: gen
go fmt ./...
gen: gen:
(cd core && make 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) return seq.Reduce(reduceFn, zero, s)
} }
func plusInt(a, b types.Elem) types.Elem { func plusInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) + Int(b)} 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)} return types.GoType{Complex128(a) + Complex128(b)}
} }
func plusString(a, b types.Elem) types.Elem { func plusString(a, b types.Elem) types.Elem {
return types.GoType{String(a) + String(b)} return types.GoType{String(a) + String(b)}
} }
@ -88,95 +84,65 @@ func Plus(s seq.Seq) types.Elem {
} }
first, _, _ = s.FirstRest() first, _, _ = s.FirstRest()
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
case int: case int:
fn = plusInt fn = plusInt
zero = types.GoType{int(0)} zero = types.GoType{int(0)}
case int8: case int8:
fn = plusInt8 fn = plusInt8
zero = types.GoType{int8(0)} zero = types.GoType{int8(0)}
case int16: case int16:
fn = plusInt16 fn = plusInt16
zero = types.GoType{int16(0)} zero = types.GoType{int16(0)}
case int32: case int32:
fn = plusInt32 fn = plusInt32
zero = types.GoType{int32(0)} zero = types.GoType{int32(0)}
case int64: case int64:
fn = plusInt64 fn = plusInt64
zero = types.GoType{int64(0)} zero = types.GoType{int64(0)}
case uint: case uint:
fn = plusUint fn = plusUint
zero = types.GoType{uint(0)} zero = types.GoType{uint(0)}
case uint8: case uint8:
fn = plusUint8 fn = plusUint8
zero = types.GoType{uint8(0)} zero = types.GoType{uint8(0)}
case uint16: case uint16:
fn = plusUint16 fn = plusUint16
zero = types.GoType{uint16(0)} zero = types.GoType{uint16(0)}
case uint32: case uint32:
fn = plusUint32 fn = plusUint32
zero = types.GoType{uint32(0)} zero = types.GoType{uint32(0)}
case uint64: case uint64:
fn = plusUint64 fn = plusUint64
zero = types.GoType{uint64(0)} zero = types.GoType{uint64(0)}
case float32: case float32:
fn = plusFloat32 fn = plusFloat32
zero = types.GoType{float32(0)} zero = types.GoType{float32(0)}
case float64: case float64:
fn = plusFloat64 fn = plusFloat64
zero = types.GoType{float64(0)} zero = types.GoType{float64(0)}
case complex64: case complex64:
fn = plusComplex64 fn = plusComplex64
zero = types.GoType{complex64(0)} zero = types.GoType{complex64(0)}
case complex128: case complex128:
fn = plusComplex128 fn = plusComplex128
zero = types.GoType{complex128(0)} zero = types.GoType{complex128(0)}
case string: case string:
fn = plusString fn = plusString
zero = types.GoType{string("")} zero = types.GoType{string("")}
@ -187,9 +153,6 @@ func Plus(s seq.Seq) types.Elem {
return mathReduce(fn, zero, s) return mathReduce(fn, zero, s)
} }
func minusInt(a, b types.Elem) types.Elem { func minusInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) - Int(b)} 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)} return types.GoType{Complex128(a) - Complex128(b)}
} }
func Minus(s seq.Seq) types.Elem { func Minus(s seq.Seq) types.Elem {
var first, zero types.Elem var first, zero types.Elem
@ -256,76 +218,57 @@ func Minus(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest() zero, s, _ = s.FirstRest()
first = zero first = zero
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
case int: case int:
fn = minusInt fn = minusInt
case int8: case int8:
fn = minusInt8 fn = minusInt8
case int16: case int16:
fn = minusInt16 fn = minusInt16
case int32: case int32:
fn = minusInt32 fn = minusInt32
case int64: case int64:
fn = minusInt64 fn = minusInt64
case uint: case uint:
fn = minusUint fn = minusUint
case uint8: case uint8:
fn = minusUint8 fn = minusUint8
case uint16: case uint16:
fn = minusUint16 fn = minusUint16
case uint32: case uint32:
fn = minusUint32 fn = minusUint32
case uint64: case uint64:
fn = minusUint64 fn = minusUint64
case float32: case float32:
fn = minusFloat32 fn = minusFloat32
case float64: case float64:
fn = minusFloat64 fn = minusFloat64
case complex64: case complex64:
fn = minusComplex64 fn = minusComplex64
case complex128: case complex128:
fn = minusComplex128 fn = minusComplex128
default: default:
panic(fmt.Sprintf("$#v cannot have Minus called on it", first)) panic(fmt.Sprintf("$#v cannot have Minus called on it", first))
} }
return mathReduce(fn, zero, s) return mathReduce(fn, zero, s)
} }
func multInt(a, b types.Elem) types.Elem { func multInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) * Int(b)} 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)} return types.GoType{Complex128(a) * Complex128(b)}
} }
func Mult(s seq.Seq) types.Elem { func Mult(s seq.Seq) types.Elem {
var first, zero types.Elem var first, zero types.Elem
@ -391,104 +333,71 @@ func Mult(s seq.Seq) types.Elem {
} }
first, _, _ = s.FirstRest() first, _, _ = s.FirstRest()
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
case int: case int:
fn = multInt fn = multInt
zero = types.GoType{int(1)} zero = types.GoType{int(1)}
case int8: case int8:
fn = multInt8 fn = multInt8
zero = types.GoType{int8(1)} zero = types.GoType{int8(1)}
case int16: case int16:
fn = multInt16 fn = multInt16
zero = types.GoType{int16(1)} zero = types.GoType{int16(1)}
case int32: case int32:
fn = multInt32 fn = multInt32
zero = types.GoType{int32(1)} zero = types.GoType{int32(1)}
case int64: case int64:
fn = multInt64 fn = multInt64
zero = types.GoType{int64(1)} zero = types.GoType{int64(1)}
case uint: case uint:
fn = multUint fn = multUint
zero = types.GoType{uint(1)} zero = types.GoType{uint(1)}
case uint8: case uint8:
fn = multUint8 fn = multUint8
zero = types.GoType{uint8(1)} zero = types.GoType{uint8(1)}
case uint16: case uint16:
fn = multUint16 fn = multUint16
zero = types.GoType{uint16(1)} zero = types.GoType{uint16(1)}
case uint32: case uint32:
fn = multUint32 fn = multUint32
zero = types.GoType{uint32(1)} zero = types.GoType{uint32(1)}
case uint64: case uint64:
fn = multUint64 fn = multUint64
zero = types.GoType{uint64(1)} zero = types.GoType{uint64(1)}
case float32: case float32:
fn = multFloat32 fn = multFloat32
zero = types.GoType{float32(1)} zero = types.GoType{float32(1)}
case float64: case float64:
fn = multFloat64 fn = multFloat64
zero = types.GoType{float64(1)} zero = types.GoType{float64(1)}
case complex64: case complex64:
fn = multComplex64 fn = multComplex64
zero = types.GoType{complex64(1)} zero = types.GoType{complex64(1)}
case complex128: case complex128:
fn = multComplex128 fn = multComplex128
zero = types.GoType{complex128(1)} zero = types.GoType{complex128(1)}
default: default:
panic(fmt.Sprintf("$#v cannot have Mult called on it", first)) panic(fmt.Sprintf("$#v cannot have Mult called on it", first))
} }
return mathReduce(fn, zero, s) return mathReduce(fn, zero, s)
} }
func divInt(a, b types.Elem) types.Elem { func divInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) / Int(b)} 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)} return types.GoType{Complex128(a) / Complex128(b)}
} }
func Div(s seq.Seq) types.Elem { func Div(s seq.Seq) types.Elem {
var first, zero types.Elem var first, zero types.Elem
@ -555,76 +463,57 @@ func Div(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest() zero, s, _ = s.FirstRest()
first = zero first = zero
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
case int: case int:
fn = divInt fn = divInt
case int8: case int8:
fn = divInt8 fn = divInt8
case int16: case int16:
fn = divInt16 fn = divInt16
case int32: case int32:
fn = divInt32 fn = divInt32
case int64: case int64:
fn = divInt64 fn = divInt64
case uint: case uint:
fn = divUint fn = divUint
case uint8: case uint8:
fn = divUint8 fn = divUint8
case uint16: case uint16:
fn = divUint16 fn = divUint16
case uint32: case uint32:
fn = divUint32 fn = divUint32
case uint64: case uint64:
fn = divUint64 fn = divUint64
case float32: case float32:
fn = divFloat32 fn = divFloat32
case float64: case float64:
fn = divFloat64 fn = divFloat64
case complex64: case complex64:
fn = divComplex64 fn = divComplex64
case complex128: case complex128:
fn = divComplex128 fn = divComplex128
default: default:
panic(fmt.Sprintf("$#v cannot have Div called on it", first)) panic(fmt.Sprintf("$#v cannot have Div called on it", first))
} }
return mathReduce(fn, zero, s) return mathReduce(fn, zero, s)
} }
func modInt(a, b types.Elem) types.Elem { func modInt(a, b types.Elem) types.Elem {
return types.GoType{Int(a) % Int(b)} 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)} return types.GoType{Uint64(a) % Uint64(b)}
} }
func Mod(s seq.Seq) types.Elem { func Mod(s seq.Seq) types.Elem {
var first, zero types.Elem var first, zero types.Elem
@ -675,55 +563,42 @@ func Mod(s seq.Seq) types.Elem {
zero, s, _ = s.FirstRest() zero, s, _ = s.FirstRest()
first = zero first = zero
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
case int: case int:
fn = modInt fn = modInt
case int8: case int8:
fn = modInt8 fn = modInt8
case int16: case int16:
fn = modInt16 fn = modInt16
case int32: case int32:
fn = modInt32 fn = modInt32
case int64: case int64:
fn = modInt64 fn = modInt64
case uint: case uint:
fn = modUint fn = modUint
case uint8: case uint8:
fn = modUint8 fn = modUint8
case uint16: case uint16:
fn = modUint16 fn = modUint16
case uint32: case uint32:
fn = modUint32 fn = modUint32
case uint64: case uint64:
fn = modUint64 fn = modUint64
default: default:
panic(fmt.Sprintf("$#v cannot have Mod called on it", first)) panic(fmt.Sprintf("$#v cannot have Mod called on it", first))
} }
return mathReduce(fn, zero, s) 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) return seq.Reduce(reduceFn, zero, s)
} }
{{range .}}{{$mathOp := .}}{{range .OpTypes}}
{{range .}}
{{$mathOp := .}}
{{range .OpTypes}}
func {{$mathOp.Private}}{{.CastFn}}(a, b types.Elem) types.Elem { 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}} {{end}}{{if $mathOp.IncludeString}}
{{if $mathOp.IncludeString}}
func {{$mathOp.Private}}String(a, b types.Elem) types.Elem { func {{$mathOp.Private}}String(a, b types.Elem) types.Elem {
return types.GoType{String(a) {{$mathOp.Op}} String(b)} return types.GoType{String(a) {{$mathOp.Op}} String(b)}
} }
@ -38,21 +34,17 @@ func {{$mathOp.Public}}(s seq.Seq) types.Elem {
first = zero first = zero
{{else}} {{else}}
if seq.Empty(s) { if seq.Empty(s) {
return types.GoType{ {{$mathOp.Unit}} } return types.GoType{{`{`}}{{$mathOp.Unit}}}
} }
first, _, _ = s.FirstRest() first, _, _ = s.FirstRest()
{{end}} {{end}}
var fn mathReduceFn var fn mathReduceFn
switch first.(types.GoType).V.(type) { switch first.(types.GoType).V.(type) {
{{range .OpTypes}} {{range .OpTypes}}
case {{.Type}}: case {{.Type}}:
fn = {{$mathOp.Private}}{{.CastFn}} fn = {{$mathOp.Private}}{{.CastFn}}{{if (ne $mathOp.Unit "")}}
{{if (ne $mathOp.Unit "")}} zero = types.GoType{{`{`}}{{.Type}}({{$mathOp.Unit}})}{{end}}
zero = types.GoType{ {{.Type}}({{$mathOp.Unit}}) } {{end}}{{if $mathOp.IncludeString}}
{{end}}
{{end}}
{{if $mathOp.IncludeString}}
case string: case string:
fn = {{$mathOp.Private}}String fn = {{$mathOp.Private}}String
zero = types.GoType{string("")} zero = types.GoType{string("")}
@ -62,5 +54,4 @@ func {{$mathOp.Public}}(s seq.Seq) types.Elem {
} }
return mathReduce(fn, zero, s) 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") Bail(el, "Empty list after colon, no function given")
} }
var fnName string var fnName string
if gt, ok := fnEl.(types.GoType); ok { if gt, ok := fnEl.(types.GoType); ok {
fnName, _ = gt.V.(string) fnName, _ = gt.V.(string)