maps and c++ support.

backends/cpp/init.go

@@ -0,0 +1,34 @@
+package cpp
+
+import (
+	"flag"
+
+	"github.com/eyrie-io/gencode/schema"
+)
+
+type CppBackend struct {
+	Namespace string
+}
+
+func (cb *CppBackend) Generate(s *schema.Schema) (string, error) {
+	w := &Walker{}
+	def, err := w.WalkSchema(s, cb.Namespace)
+	if err != nil {
+		return "", err
+	}
+	return def.String(), nil
+}
+
+func (cb *CppBackend) Flags() *flag.FlagSet {
+	flags := flag.NewFlagSet("Cpp", flag.ExitOnError)
+	flags.StringVar(&cb.Namespace, "namespace", "main", "namespace to build the gencode system for")
+	return flags
+}
+
+func (cb *CppBackend) GeneratedFilename(filename string) string {
+	return filename + ".gen.hpp"
+}
+
+func init() {
+	schema.Register("cpp", &CppBackend{})
+}

backends/cpp/schema.go

@@ -0,0 +1,35 @@
+package cpp
+
+import (
+	"fmt"
+
+	"github.com/eyrie-io/gencode/schema"
+)
+
+type Walker struct {
+}
+
+func (w *Walker) WalkSchema(s *schema.Schema, Namespace string) (parts *StringBuilder, err error) {
+	parts = &StringBuilder{}
+	parts.Append(fmt.Sprintf(`#pragma once
+
+#include <vector>
+#include <string>
+#include <map>
+#include <stdint.h>
+
+namespace %s {
+
+`, Namespace))
+	for _, st := range s.Structs {
+		p, err := w.WalkStruct(st)
+		if err != nil {
+			return nil, err
+		}
+		parts.Join(p)
+	}
+	parts.Append(`
+}
+`)
+	return
+}

backends/cpp/stringbuilder.go

@@ -0,0 +1,31 @@
+package cpp
+
+import (
+	"bytes"
+	"strings"
+	"text/template"
+)
+
+type StringBuilder []string
+
+func (sb *StringBuilder) Append(s string) {
+	*sb = append(*sb, s)
+}
+
+func (sb *StringBuilder) Join(s *StringBuilder) {
+	*sb = append(*sb, *s...)
+}
+
+func (sb *StringBuilder) String() string {
+	return strings.Join(*sb, "")
+}
+
+func (sb *StringBuilder) AddTemplate(t *template.Template, name string, data interface{}) error {
+	buf := &bytes.Buffer{}
+	err := t.ExecuteTemplate(buf, name, data)
+	if err != nil {
+		return err
+	}
+	sb.Append(buf.String())
+	return nil
+}

backends/cpp/struct.go

@@ -0,0 +1,133 @@
+package cpp
+
+import (
+	"fmt"
+
+	"github.com/eyrie-io/gencode/schema"
+)
+
+func (w *Walker) WalkStruct(s *schema.Struct) (parts *StringBuilder, err error) {
+	if s.Framed {
+		err = fmt.Errorf("Framed structs are not supported in cpp")
+		return
+	}
+	parts = &StringBuilder{}
+	parts.Append(fmt.Sprintf(`class C%s {
+public:
+`, s.Name))
+	for _, f := range s.Fields {
+		p, err := w.WalkFieldDef(f)
+		if err != nil {
+			return nil, err
+		}
+		parts.Join(p)
+		parts.Append(`
+`)
+	}
+	parts.Append(fmt.Sprintf(`
+public:
+	~C%s();
+	uint64_t MarshalSize();
+	uint64_t Marshal(uint8_t* buf);
+	uint64_t Unmarshal(uint8_t* buf);
+};
+
+C%s::~C%s() {`, s.Name, s.Name, s.Name))
+	for _, f := range s.Fields {
+		switch t := f.Type.(type) {
+		case *schema.PointerType:
+			parts.Append(fmt.Sprintf(`	delete this->%s;"`, s.Name))
+		case *schema.SliceType:
+			pt, ok := t.SubType.(*schema.PointerType)
+			if ok {
+				dt := pt.SubType.(*schema.DeferType)
+				parts.Append(fmt.Sprintf(`
+	for (std::vector<C%s*>::iterator i = %s.begin(); i != %s.end(); i++) {
+		delete (*i);
+	}`, dt.Defer, f.Name, f.Name))
+			}
+		}
+	}
+	parts.Append(fmt.Sprintf(`
+}
+
+uint64_t C%s::MarshalSize() {
+	uint64_t s = 0;
+`, s.Name))
+	for _, f := range s.Fields {
+		p, err := w.WalkFieldSize(f)
+		if err != nil {
+			return nil, err
+		}
+		parts.Join(p)
+	}
+	parts.Append(fmt.Sprintf(`
+	return s;
+}
+
+uint64_t C%s::Marshal(uint8_t* buf) {`, s.Name))
+	parts.Append(`
+	uint64_t size = this->MarshalSize();`)
+	parts.Append(`
+	uint64_t i = 0;
+	`)
+	for _, f := range s.Fields {
+		p, err := w.WalkFieldMarshal(f)
+		if err != nil {
+			return nil, err
+		}
+		parts.Join(p)
+	}
+	parts.Append(fmt.Sprintf(`
+	return i;
+}
+
+uint64_t C%s::Unmarshal(uint8_t* buf) {
+	uint64_t i = 0;
+	`, s.Name))
+	for _, f := range s.Fields {
+		p, err := w.WalkFieldUnmarshal(f)
+		if err != nil {
+			return nil, err
+		}
+		parts.Join(p)
+	}
+	parts.Append(fmt.Sprintf(`
+	return i;
+}
+
+`))
+	return
+}
+
+func (w *Walker) WalkFieldDef(s *schema.Field) (parts *StringBuilder, err error) {
+	switch t := s.Type.(type) {
+	case *schema.ArrayType:
+		subp, err := w.WalkTypeDef(t.SubType)
+		if err != nil {
+			return nil, err
+		}
+		parts = &StringBuilder{}
+		parts.Append(fmt.Sprintf(`	%s %s[%d];`, subp.String(), s.Name, t.Count))
+	default:
+		subp, err := w.WalkTypeDef(s.Type)
+		if err != nil {
+			return nil, err
+		}
+		parts = &StringBuilder{}
+		parts.Append(fmt.Sprintf(`	%s %s;`, subp.String(), s.Name))
+	}
+	return
+}
+
+func (w *Walker) WalkFieldSize(s *schema.Field) (parts *StringBuilder, err error) {
+	return w.WalkTypeSize(s.Type, "this->"+s.Name)
+}
+
+func (w *Walker) WalkFieldMarshal(s *schema.Field) (parts *StringBuilder, err error) {
+	return w.WalkTypeMarshal(s.Type, "this->"+s.Name)
+}
+
+func (w *Walker) WalkFieldUnmarshal(s *schema.Field) (parts *StringBuilder, err error) {
+	return w.WalkTypeUnmarshal(s.Type, "this->"+s.Name)
+}

backends/cpp/type_array.go

@@ -0,0 +1,106 @@
+package cpp
+
+import (
+	"text/template"
+
+	"github.com/eyrie-io/gencode/schema"
+)
+
+var (
+	ArrayTemps *template.Template
+)
+
+func init() {
+	ArrayTemps = template.New("ArrayTemps")
+	template.Must(ArrayTemps.New("marshal").Parse(`
+	{
+		for (uint64_t k = 0; k < {{.Count}}; k++) {
+			{{.SubTypeCode}}
+		}
+	}`))
+	template.Must(ArrayTemps.New("unmarshal").Parse(`
+	{
+		for (uint64_t k = 0; k < {{.Count}}; k++) {
+			{{.SubTypeCode}}
+		}
+	}`))
+	template.Must(ArrayTemps.New("bytemarshal").Parse(`
+	{
+		memcpy(&buf[i], &{{.Target}}[0], {{.Count}});
+		i += {{.Count}};
+	}`))
+	template.Must(ArrayTemps.New("byteunmarshal").Parse(`
+	{
+		memcpy(&{{.Target}}[0], &buf[i], {{.Count}});
+		i += {{.Count}};
+	}`))
+	template.Must(ArrayTemps.New("size").Parse(`
+	{
+		for (uint64_t k = 0; k < {{.Count}}; k++) {
+			{{.SubTypeCode}}
+		}
+	}`))
+	template.Must(ArrayTemps.New("bytesize").Parse(`
+	{
+		s += {{.Count}};
+	}`))
+	template.Must(ArrayTemps.New("field").Parse(`[{{.Count}}]`))
+}
+
+type ArrayTemp struct {
+	*schema.ArrayType
+	W           *Walker
+	Target      string
+	SubTypeCode string
+	SubField    string
+}
+
+func (w *Walker) WalkArraySize(at *schema.ArrayType, target string) (parts *StringBuilder, err error) {
+	parts = &StringBuilder{}
+	subtypecode, err := w.WalkTypeSize(at.SubType, target+"[k]")
+	if err != nil {
+		return nil, err
+	}
+	if _, ok := at.SubType.(*schema.ByteType); ok {
+		err = parts.AddTemplate(ArrayTemps, "bytesize", ArrayTemp{at, w, target, subtypecode.String(), ""})
+	} else {
+		err = parts.AddTemplate(ArrayTemps, "size", ArrayTemp{at, w, target, subtypecode.String(), ""})
+	}
+	return
+}
+
+func (w *Walker) WalkArrayMarshal(at *schema.ArrayType, target string) (parts *StringBuilder, err error) {
+	parts = &StringBuilder{}
+	subtypecode, err := w.WalkTypeMarshal(at.SubType, target+"[k]")
+	if err != nil {
+		return nil, err
+	}
+	subfield, err := w.WalkTypeDef(at.SubType)
+	if err != nil {
+		return nil, err
+	}
+	if _, ok := at.SubType.(*schema.ByteType); ok {
+		err = parts.AddTemplate(ArrayTemps, "bytemarshal", ArrayTemp{at, w, target, subtypecode.String(), subfield.String()})
+	} else {
+		err = parts.AddTemplate(ArrayTemps, "marshal", ArrayTemp{at, w, target, subtypecode.String(), subfield.String()})
+	}
+	return
+}
+
+func (w *Walker) WalkArrayUnmarshal(at *schema.ArrayType, target string) (parts *StringBuilder, err error) {
+	parts = &StringBuilder{}
+	subtypecode, err := w.WalkTypeUnmarshal(at.SubType, target+"[k]")
+	if err != nil {
+		return nil, err
+	}
+	subfield, err := w.WalkTypeDef(at.SubType)
+	if err != nil {
+		return nil, err
+	}
+	if _, ok := at.SubType.(*schema.ByteType); ok {
+		err = parts.AddTemplate(ArrayTemps, "byteunmarshal", ArrayTemp{at, w, target, subtypecode.String(), subfield.String()})
+	} else {
+		err = parts.AddTemplate(ArrayTemps, "unmarshal", ArrayTemp{at, w, target, subtypecode.String(), subfield.String()})
+	}
+	return
+}