From 5d0b664ccf5410c5ed83b0f4b6bee1a3bad954a4 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 28 May 2017 17:17:00 +1000 Subject: [PATCH] Generate C function bodies. --- cmd/internal/cgen/cgen.go | 230 ++++++++++++++++++++++++++++++++++++-- gen/c/gif.c | 21 ++-- lang/ast/ast.go | 17 ++- lang/check/bounds.go | 2 +- lang/check/type.go | 2 +- test/c/gif/lzw.c | 37 ++++++ 6 files changed, 285 insertions(+), 24 deletions(-) create mode 100644 test/c/gif/lzw.c diff --git a/cmd/internal/cgen/cgen.go b/cmd/internal/cgen/cgen.go index ddcbc7b2..75c8bd79 100644 --- a/cmd/internal/cgen/cgen.go +++ b/cmd/internal/cgen/cgen.go @@ -305,9 +305,14 @@ func writeFuncImpl(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Func) error } b.WriteString("\n") - // TODO: generate the function body. - + // Generate the function body. + for _, o := range n.Body() { + if err := writeStatement(b, pkgName, m, o, 0); err != nil { + return err + } + } b.WriteString("\n") + if cleanup0 { fmt.Fprintf(b, "cleanup0: self->status = status;\n") } @@ -369,11 +374,7 @@ func writeVars(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Node, depth uin x := n.Var().XType() if k := x.Name().Key(); k < t.Key(len(cTypeNames)) { if s := cTypeNames[k]; s != "" { - fmt.Fprintf(b, "%s %s;\n", s, n.Var().Name().String(m)) - // TODO: remove this hack for "unused variable" warning. In the - // long term, we want unused variables to fail noisily. - name := n.Var().Name().String(m) - fmt.Fprintf(b, "%s = 0; if (%s) {}\n", name, name) + fmt.Fprintf(b, "%s v_%s;\n", s, n.Var().Name().String(m)) return nil } } @@ -391,6 +392,175 @@ func writeVars(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Node, depth uin return nil } +func writeStatement(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Node, depth uint32) error { + if depth > a.MaxBodyDepth { + return fmt.Errorf("cgen: body recursion depth too large") + } + depth++ + + switch n.Kind() { + case a.KAssert: + // Assertions only apply at compile-time. + return nil + + case a.KAssign: + n := n.Assign() + if err := writeExpr(b, pkgName, m, n.LHS(), depth); err != nil { + return err + } + // TODO: does KeyAmpHatEq need special consideration? + b.WriteString(cOpNames[0xFF&n.Operator().Key()]) + if err := writeExpr(b, pkgName, m, n.RHS(), depth); err != nil { + return err + } + b.WriteString(";\n") + return nil + + case a.KIf: + // TODO. + + case a.KJump: + // TODO. + + case a.KReturn: + // TODO. + + case a.KVar: + n := n.Var() + fmt.Fprintf(b, "v_%s = ", n.Name().String(m)) + if v := n.Value(); v != nil { + if err := writeExpr(b, pkgName, m, v, 0); err != nil { + return err + } + } else { + b.WriteByte('0') + } + b.WriteString(";\n") + return nil + + case a.KWhile: + n := n.While() + b.WriteString("while (") + if err := writeExpr(b, pkgName, m, n.Condition(), 0); err != nil { + return err + } + b.WriteString(") {\n") + for _, o := range n.Body() { + if err := writeStatement(b, pkgName, m, o, depth); err != nil { + return err + } + } + b.WriteString("}\n") + return nil + // TODO. + + } + return fmt.Errorf("cgen: unrecognized ast.Kind (%s) for writeStatement", n.Kind()) +} + +func writeExpr(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Expr, depth uint32) error { + if depth > a.MaxExprDepth { + return fmt.Errorf("cgen: expression recursion depth too large") + } + depth++ + + if cv := n.ConstValue(); cv != nil { + // TODO: write false/true instead of 0/1 if n.MType() is bool? + b.WriteString(cv.String()) + return nil + } + + switch n.ID0().Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) { + case 0: + if err := writeExprOther(b, pkgName, m, n, depth); err != nil { + return err + } + case t.FlagsUnaryOp: + if err := writeExprUnaryOp(b, pkgName, m, n, depth); err != nil { + return err + } + case t.FlagsBinaryOp: + if err := writeExprBinaryOp(b, pkgName, m, n, depth); err != nil { + return err + } + case t.FlagsAssociativeOp: + if err := writeExprAssociativeOp(b, pkgName, m, n, depth); err != nil { + return err + } + default: + return fmt.Errorf("cgen: unrecognized token.Key (0x%X) for writeExpr", n.ID0().Key()) + } + + return nil +} + +func writeExprOther(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Expr, depth uint32) error { + switch n.ID0().Key() { + case 0: + if id1 := n.ID1(); id1.Key() == t.KeyThis { + b.WriteString("self") + } else { + // TODO: don't assume that the v_ prefix is necessary. + b.WriteString("v_") + b.WriteString(id1.String(m)) + } + return nil + + case t.KeyOpenParen: + // n is a function call. + // TODO. + + case t.KeyOpenBracket: + // n is an index. + // TODO. + + case t.KeyColon: + // n is a slice. + // TODO. + + case t.KeyDot: + if err := writeExpr(b, pkgName, m, n.LHS().Expr(), depth); err != nil { + return err + } + // TODO: choose between . vs -> operators. + // + // TODO: don't assume that the f_ prefix is necessary. + b.WriteString("->f_") + b.WriteString(n.ID1().String(m)) + return nil + } + return fmt.Errorf("cgen: unrecognized token.Key (0x%X) for writeExprOther", n.ID0().Key()) +} + +func writeExprUnaryOp(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Expr, depth uint32) error { + // TODO. + return nil +} + +func writeExprBinaryOp(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Expr, depth uint32) error { + op := n.ID0() + if op.Key() == t.KeyXBinaryAs { + // TODO. + return nil + } + b.WriteByte('(') + if err := writeExpr(b, pkgName, m, n.LHS().Expr(), depth); err != nil { + return err + } + // TODO: does KeyXBinaryAmpHat need special consideration? + b.WriteString(cOpNames[0xFF&op.Key()]) + if err := writeExpr(b, pkgName, m, n.RHS().Expr(), depth); err != nil { + return err + } + b.WriteByte(')') + return nil +} + +func writeExprAssociativeOp(b *bytes.Buffer, pkgName string, m *t.IDMap, n *a.Expr, depth uint32) error { + // TODO. + return nil +} + func format(rawSource *bytes.Buffer) ([]byte, error) { stdout := &bytes.Buffer{} cmd := exec.Command("clang-format", "-style=Chromium") @@ -415,3 +585,49 @@ var cTypeNames = [...]string{ t.KeyUsize: "size_t", t.KeyBool: "bool", } + +var cOpNames = [256]string{ + t.KeyEq: " = ", + t.KeyPlusEq: " += ", + t.KeyMinusEq: " -= ", + t.KeyStarEq: " *= ", + t.KeySlashEq: " /= ", + t.KeyShiftLEq: " <<= ", + t.KeyShiftREq: " >>= ", + t.KeyAmpEq: " &= ", + t.KeyAmpHatEq: " no_such_amp_hat_C_operator ", + t.KeyPipeEq: " |= ", + t.KeyHatEq: " ^= ", + + t.KeyXUnaryPlus: "+", + t.KeyXUnaryMinus: "-", + t.KeyXUnaryNot: "!", + + t.KeyXBinaryPlus: " + ", + t.KeyXBinaryMinus: " - ", + t.KeyXBinaryStar: " * ", + t.KeyXBinarySlash: " / ", + t.KeyXBinaryShiftL: " << ", + t.KeyXBinaryShiftR: " >> ", + t.KeyXBinaryAmp: " & ", + t.KeyXBinaryAmpHat: " no_such_amp_hat_C_operator ", + t.KeyXBinaryPipe: " | ", + t.KeyXBinaryHat: " ^ ", + t.KeyXBinaryNotEq: " != ", + t.KeyXBinaryLessThan: " < ", + t.KeyXBinaryLessEq: " <= ", + t.KeyXBinaryEqEq: " == ", + t.KeyXBinaryGreaterEq: " >= ", + t.KeyXBinaryGreaterThan: " > ", + t.KeyXBinaryAnd: " && ", + t.KeyXBinaryOr: " || ", + t.KeyXBinaryAs: " no_such_as_C_operator ", + + t.KeyXAssociativePlus: " + ", + t.KeyXAssociativeStar: " * ", + t.KeyXAssociativeAmp: " & ", + t.KeyXAssociativePipe: " | ", + t.KeyXAssociativeHat: " ^ ", + t.KeyXAssociativeAnd: " && ", + t.KeyXAssociativeOr: " || ", +} diff --git a/gen/c/gif.c b/gen/c/gif.c index 5e212ea3..70dd3470 100644 --- a/gen/c/gif.c +++ b/gen/c/gif.c @@ -141,17 +141,16 @@ puffs_gif_status puffs_gif_lzw_decoder_decode(puffs_gif_lzw_decoder* self) { goto cleanup0; } - uint32_t bits; - bits = 0; - if (bits) { - } - uint32_t n_bits; - n_bits = 0; - if (n_bits) { - } - uint32_t width; - width = 0; - if (width) { + uint32_t v_bits; + uint32_t v_n_bits; + uint32_t v_width; + + v_bits = 0; + v_n_bits = 0; + v_width = (self->f_literal_width + 1); + while ((v_n_bits < v_width)) { + v_bits |= 0; + v_n_bits += 8; } cleanup0: diff --git a/lang/ast/ast.go b/lang/ast/ast.go index ae84d5a5..65735d2f 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -322,7 +322,7 @@ func NewField(name t.ID, xType *TypeExpr, defaultValue *Expr) *Field { // While is "while LHS, List0 { List1 }": // - LHS: // - List0: asserts -// - List1: <*> loop body +// - List1: loop body type While Node func (n *While) Node() *Node { return (*Node)(n) } @@ -342,8 +342,8 @@ func NewWhile(condition *Expr, asserts []*Node, body []*Node) *While { // If is "if LHS { List0 } else RHS" or "if LHS { List0 } else { List1 }": // - LHS: // - RHS: -// - List0: <*> if-true body -// - List1: <*> if-false body +// - List0: if-true body +// - List1: if-false body type If Node func (n *If) Node() *Node { return (*Node)(n) } @@ -455,7 +455,16 @@ const MaxBodyDepth = 255 // - LHS: in-parameters // - RHS: out-parameters // - List0: asserts -// - List1: <*> function body +// - List1: function body +// +// Statement means one of: +// - Assert +// - Assign +// - If +// - Jump +// - Return +// - Var +// - While type Func Node func (n *Func) Node() *Node { return (*Node)(n) } diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 261d2f7d..6f1bdec9 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -152,7 +152,7 @@ func (q *checker) bcheckStatement(n *a.Node) error { // No-op. default: - return fmt.Errorf("check: unrecognized ast.Kind (%d) for checkStatement", n.Kind()) + return fmt.Errorf("check: unrecognized ast.Kind (%s) for checkStatement", n.Kind()) } return nil diff --git a/lang/check/type.go b/lang/check/type.go index ff86fa80..22619036 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -120,7 +120,7 @@ func (q *checker) tcheckStatement(n *a.Node) error { // TODO: check that we're in a for loop. default: - return fmt.Errorf("check: unrecognized ast.Kind (%d) for checkStatement", n.Kind()) + return fmt.Errorf("check: unrecognized ast.Kind (%s) for checkStatement", n.Kind()) } n.SetTypeChecked() diff --git a/test/c/gif/lzw.c b/test/c/gif/lzw.c new file mode 100644 index 00000000..184c3969 --- /dev/null +++ b/test/c/gif/lzw.c @@ -0,0 +1,37 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +/* +To manually run this test: + +for cc in clang gcc; do + $cc -std=c99 -Wall -Werror lzw.c && ./a.out + rm -f a.out +done + +Each edition should print "PASS", amongst other information, and exit(0). +*/ + +#include "../../../gen/c/gif.c" +#include "../testlib/testlib.c" + +const char* test_filename = "gif/lzw.c"; + +void test_lzw_decode() { + puffs_gif_lzw_decoder dec; + puffs_gif_lzw_decoder_constructor(&dec, PUFFS_VERSION, 0); + puffs_gif_status status = puffs_gif_lzw_decoder_decode(&dec); + if (status != puffs_gif_status_ok) { + FAIL("test_lzw_decode: status: got %d, want %d", status, + puffs_gif_status_ok); + goto cleanup0; + } +cleanup0: + puffs_gif_lzw_decoder_destructor(&dec); +} + +// The empty comments forces clang-format to place one element per line. +test tests[] = { + test_lzw_decode, // + NULL, // +};