| // Copyright 2020 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package golang |
| |
| import ( |
| "bytes" |
| "fmt" |
| "go/format" |
| "io" |
| "os" |
| "strconv" |
| "strings" |
| "text/template" |
| |
| "go.fuchsia.dev/fuchsia/tools/fidl/gidl/lib/ir" |
| "go.fuchsia.dev/fuchsia/tools/fidl/gidl/lib/mixer" |
| "go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen" |
| ) |
| |
| // withGoFmt wraps a template that produces Go source code, and formats the |
| // execution result using go/format. |
| type withGoFmt struct { |
| template *template.Template |
| } |
| |
| func (w withGoFmt) Execute(wr io.Writer, data interface{}) error { |
| var b bytes.Buffer |
| if err := w.template.Execute(&b, data); err != nil { |
| return err |
| } |
| formatted, err := format.Source(b.Bytes()) |
| if err != nil { |
| fmt.Fprintf(os.Stderr, "gofmt failed: %s\n", err) |
| _, err = wr.Write(b.Bytes()) |
| return err |
| } |
| _, err = wr.Write(formatted) |
| return err |
| } |
| |
| func buildBytes(bytes []byte) string { |
| var builder strings.Builder |
| builder.WriteString("[]byte{\n") |
| for i, b := range bytes { |
| builder.WriteString(fmt.Sprintf("0x%02x,", b)) |
| if i%8 == 7 { |
| builder.WriteString("\n") |
| } |
| } |
| builder.WriteString("}") |
| return builder.String() |
| } |
| |
| func buildHandleDefs(defs []ir.HandleDef) string { |
| if len(defs) == 0 { |
| return "" |
| } |
| var builder strings.Builder |
| builder.WriteString("[]handleDef{\n") |
| for i, d := range defs { |
| var subtype string |
| rights := d.Rights |
| switch d.Subtype { |
| case fidlgen.HandleSubtypeChannel: |
| subtype = "zx.ObjTypeChannel" |
| // Always use real rights instead of a "same rights" placeholder. |
| if rights == fidlgen.HandleRightsSameRights { |
| r, ok := ir.HandleRightsByName("channel_default") |
| if !ok { |
| panic("channel_default should be a supported rights name") |
| } |
| rights = r |
| } |
| case fidlgen.HandleSubtypeEvent: |
| subtype = "zx.ObjTypeEvent" |
| // Always use real rights instead of a "same rights" placeholder. |
| if rights == fidlgen.HandleRightsSameRights { |
| r, ok := ir.HandleRightsByName("event_default") |
| if !ok { |
| panic("event_default should be a supported rights name") |
| } |
| rights = r |
| } |
| default: |
| panic(fmt.Sprintf("unsupported handle subtype: %s", d.Subtype)) |
| } |
| // Write indices corresponding to the .gidl file handle_defs block. |
| builder.WriteString(fmt.Sprintf(` |
| // #%d: |
| { |
| subtype: %s, |
| rights: %d, |
| }, |
| `, i, subtype, rights)) |
| } |
| builder.WriteString("}") |
| return builder.String() |
| } |
| |
| func buildHandleInfos(handles []ir.Handle) string { |
| if len(handles) == 0 { |
| return "nil" |
| } |
| var builder strings.Builder |
| builder.WriteString("[]zx.HandleInfo{") |
| for _, handle := range handles { |
| builder.WriteString(fmt.Sprintf(` |
| {Handle: handles[%d], Type: handleDefs[%d].subtype, Rights: handleDefs[%d].rights},`, handle, handle, handle)) |
| } |
| builder.WriteString("\n}") |
| return builder.String() |
| } |
| |
| func buildHandleDispositions(handleDispositions []ir.HandleDisposition) string { |
| if len(handleDispositions) == 0 { |
| return "nil" |
| } |
| var builder strings.Builder |
| builder.WriteString("[]zx.HandleDisposition{") |
| for _, handleDisposition := range handleDispositions { |
| builder.WriteString(fmt.Sprintf(` |
| { |
| Operation: zx.HandleOpMove, |
| Handle: handles[%d], |
| Type: %d, |
| Rights: %d, |
| Result: zx.ErrOk, |
| },`, |
| handleDisposition.Handle, handleDisposition.Type, handleDisposition.Rights)) |
| } |
| builder.WriteString("\n}") |
| return builder.String() |
| } |
| |
| func buildUnknownData(data ir.UnknownData) string { |
| return fmt.Sprintf( |
| "fidl.UnknownData{\nBytes: %s, \nHandles: %s,\n}", |
| buildBytes(data.Bytes), |
| buildHandleInfos(data.Handles)) |
| } |
| |
| func buildUnknownDataMap(fields []ir.Field) string { |
| if len(fields) == 0 { |
| return "nil" |
| } |
| var builder strings.Builder |
| builder.WriteString("map[uint64]fidl.UnknownData{\n") |
| for _, field := range fields { |
| builder.WriteString(fmt.Sprintf( |
| "%d: %s,", |
| field.Key.UnknownOrdinal, |
| buildUnknownData(field.Value.(ir.UnknownData)))) |
| } |
| builder.WriteString("}") |
| return builder.String() |
| } |
| |
| func visit(value ir.Value, decl mixer.Declaration) string { |
| switch value := value.(type) { |
| case bool, int64, uint64, float64: |
| switch decl := decl.(type) { |
| case mixer.PrimitiveDeclaration: |
| return fmt.Sprintf("%#v", value) |
| case *mixer.BitsDecl, *mixer.EnumDecl: |
| return fmt.Sprintf("%s(%d)", typeLiteral(decl), value) |
| } |
| case ir.RawFloat: |
| switch decl.(*mixer.FloatDecl).Subtype() { |
| case fidlgen.Float32: |
| return fmt.Sprintf("math.Float32frombits(%#b)", value) |
| case fidlgen.Float64: |
| return fmt.Sprintf("math.Float64frombits(%#b)", value) |
| } |
| case string: |
| if decl.IsNullable() { |
| // Taking an address of a string literal is not allowed, so instead |
| // we create a slice and get the address of its first element. |
| return fmt.Sprintf("&[]string{%q}[0]", value) |
| } |
| return strconv.Quote(value) |
| case ir.Handle: |
| rawHandle := fmt.Sprintf("handles[%d]", value) |
| switch decl := decl.(type) { |
| case *mixer.ClientEndDecl: |
| return fmt.Sprintf("%s{Channel: zx.Channel(%s)}", endpointDeclName(decl), rawHandle) |
| case *mixer.ServerEndDecl: |
| return fmt.Sprintf("%s{Channel: zx.Channel(%s)}", endpointDeclName(decl), rawHandle) |
| case *mixer.HandleDecl: |
| switch decl.Subtype() { |
| case fidlgen.HandleSubtypeNone: |
| return rawHandle |
| case fidlgen.HandleSubtypeChannel: |
| return fmt.Sprintf("zx.Channel(%s)", rawHandle) |
| case fidlgen.HandleSubtypeEvent: |
| return fmt.Sprintf("zx.Event(%s)", rawHandle) |
| default: |
| panic(fmt.Sprintf("Handle subtype not supported %s", decl.Subtype())) |
| } |
| } |
| case ir.Record: |
| if decl, ok := decl.(mixer.RecordDeclaration); ok { |
| return onRecord(value, decl) |
| } |
| case []ir.Value: |
| if decl, ok := decl.(mixer.ListDeclaration); ok { |
| return onList(value, decl) |
| } |
| case nil: |
| if _, ok := decl.(*mixer.HandleDecl); ok { |
| return "zx.HandleInvalid" |
| } |
| if !decl.IsNullable() { |
| panic(fmt.Sprintf("got nil for non-nullable type: %T", decl)) |
| } |
| return "nil" |
| } |
| panic(fmt.Sprintf("not implemented: %T", value)) |
| } |
| |
| func onRecord(value ir.Record, decl mixer.RecordDeclaration) string { |
| var fields []string |
| if decl, ok := decl.(*mixer.UnionDecl); ok && len(value.Fields) >= 1 { |
| field := value.Fields[0] |
| fullName := declName(decl) |
| var tagValue string |
| if field.Key.IsUnknown() { |
| tagValue = fmt.Sprintf("%d", field.Key.UnknownOrdinal) |
| } else { |
| fieldName := fidlgen.ToUpperCamelCase(field.Key.Name) |
| tagValue = fmt.Sprintf("%s%s", fullName, fieldName) |
| } |
| parts := strings.Split(string(decl.Name()), "/") |
| unqualifiedName := fidlgen.ToLowerCamelCase(parts[len(parts)-1]) |
| fields = append(fields, |
| fmt.Sprintf("I_%sTag: %s", unqualifiedName, tagValue)) |
| } |
| _, isTable := decl.(*mixer.TableDecl) |
| var unknownTableFields []ir.Field |
| for _, field := range value.Fields { |
| if field.Key.IsUnknown() { |
| if isTable { |
| unknownTableFields = append(unknownTableFields, field) |
| } else { |
| fields = append(fields, |
| fmt.Sprintf("I_unknownData: %s", buildUnknownData(field.Value.(ir.UnknownData)))) |
| } |
| continue |
| } |
| fieldName := fidlgen.ToUpperCamelCase(field.Key.Name) |
| fieldRhs := visit(field.Value, decl.Field(field.Key.Name)) |
| fields = append(fields, fmt.Sprintf("%s: %s", fieldName, fieldRhs)) |
| if isTable && field.Value != nil { |
| fields = append(fields, fmt.Sprintf("%sPresent: true", fieldName)) |
| } |
| } |
| if len(unknownTableFields) > 0 { |
| fields = append(fields, |
| fmt.Sprintf("I_unknownData: %s", buildUnknownDataMap(unknownTableFields))) |
| } |
| |
| if len(fields) == 0 { |
| return fmt.Sprintf("%s{}", typeLiteral(decl)) |
| } |
| // Insert newlines so that gofmt can produce good results. |
| return fmt.Sprintf("%s{\n%s,\n}", typeLiteral(decl), strings.Join(fields, ",\n")) |
| } |
| |
| func onList(value []ir.Value, decl mixer.ListDeclaration) string { |
| elemDecl := decl.Elem() |
| var elements []string |
| for _, item := range value { |
| elements = append(elements, visit(item, elemDecl)) |
| } |
| if len(elements) == 0 { |
| return fmt.Sprintf("%s{}", typeLiteral(decl)) |
| } |
| // Insert newlines so that gofmt can produce good results. |
| return fmt.Sprintf("%s{\n%s,\n}", typeLiteral(decl), strings.Join(elements, ",\n")) |
| } |
| |
| func typeName(decl mixer.Declaration) string { |
| return typeNameHelper(decl, "*") |
| } |
| |
| func typeLiteral(decl mixer.Declaration) string { |
| return typeNameHelper(decl, "&") |
| } |
| |
| func typeNameHelper(decl mixer.Declaration, pointerPrefix string) string { |
| if !decl.IsNullable() { |
| pointerPrefix = "" |
| } |
| |
| switch decl := decl.(type) { |
| case mixer.PrimitiveDeclaration: |
| return string(decl.Subtype()) |
| case mixer.NamedDeclaration: |
| return pointerPrefix + declName(decl) |
| case *mixer.StringDecl: |
| return pointerPrefix + "string" |
| case *mixer.ArrayDecl: |
| return fmt.Sprintf("[%d]%s", decl.Size(), typeName(decl.Elem())) |
| case *mixer.VectorDecl: |
| return fmt.Sprintf("%s[]%s", pointerPrefix, typeName(decl.Elem())) |
| case *mixer.HandleDecl: |
| switch decl.Subtype() { |
| case fidlgen.HandleSubtypeNone: |
| return "zx.Handle" |
| case fidlgen.HandleSubtypeChannel: |
| return "zx.Channel" |
| case fidlgen.HandleSubtypeEvent: |
| return "zx.Event" |
| default: |
| panic(fmt.Sprintf("Handle subtype not supported %s", decl.Subtype())) |
| } |
| default: |
| panic(fmt.Sprintf("unhandled case %T", decl)) |
| } |
| } |
| |
| func declName(decl mixer.NamedDeclaration) string { |
| return identifierName(decl.Name()) |
| } |
| |
| func endpointDeclName(decl mixer.EndpointDeclaration) string { |
| switch decl.(type) { |
| case *mixer.ClientEndDecl: |
| return fmt.Sprintf("%sWithCtxInterface", identifierName(decl.ProtocolName())) |
| case *mixer.ServerEndDecl: |
| return fmt.Sprintf("%sWithCtxInterfaceRequest", identifierName(decl.ProtocolName())) |
| default: |
| panic(fmt.Sprintf("unhandled case %T", decl)) |
| } |
| } |
| |
| // TODO(https://fxbug.dev/42115264): Move into a common library outside GIDL. |
| func identifierName(qualifiedName string) string { |
| parts := strings.Split(qualifiedName, "/") |
| library_parts := strings.Split(strings.ToLower(parts[0]), ".") |
| return strings.Join([]string{library_parts[len(library_parts)-1], |
| fidlgen.ToUpperCamelCase(parts[1])}, ".") |
| } |
| |
| // Go errors are defined in third_party/go/src/syscall/zx/fidl/errors.go. |
| var goErrorCodeNames = map[ir.ErrorCode]string{ |
| ir.EnvelopeBytesExceedMessageLength: "ErrPayloadTooSmall", |
| ir.EnvelopeHandlesExceedMessageLength: "ErrTooManyHandles", |
| ir.ExceededMaxOutOfLineDepth: "ErrExceededMaxOutOfLineDepth", |
| ir.IncorrectHandleType: "ErrIncorrectHandleType", |
| ir.InvalidBoolean: "ErrInvalidBoolValue", |
| ir.InvalidEmptyStruct: "ErrInvalidEmptyStruct", |
| ir.InvalidInlineBitInEnvelope: "ErrInvalidInlineBitValueInEnvelope", |
| ir.InvalidInlineMarkerInEnvelope: "ErrBadInlineIndicatorEncoding", |
| ir.InvalidNumBytesInEnvelope: "ErrInvalidNumBytesInEnvelope", |
| ir.InvalidNumHandlesInEnvelope: "ErrInvalidNumHandlesInEnvelope", |
| ir.InvalidPaddingByte: "ErrNonZeroPadding", |
| ir.InvalidPresenceIndicator: "ErrBadRefEncoding", |
| ir.InvalidHandlePresenceIndicator: "ErrBadHandleEncoding", |
| ir.MissingRequiredHandleRights: "ErrMissingRequiredHandleRights", |
| ir.NonEmptyStringWithNullBody: "ErrUnexpectedNullRef", |
| ir.NonEmptyVectorWithNullBody: "ErrUnexpectedNullRef", |
| ir.NonNullableTypeWithNullValue: "ErrUnexpectedNullRef", |
| ir.NonResourceUnknownHandles: "ErrValueTypeHandles", |
| ir.StrictBitsUnknownBit: "ErrInvalidBitsValue", |
| ir.StrictEnumUnknownValue: "ErrInvalidEnumValue", |
| ir.StrictUnionUnknownField: "ErrInvalidXUnionTag", |
| ir.StringCountExceeds32BitLimit: "ErrStringTooLong", |
| ir.StringNotUtf8: "ErrStringNotUTF8", |
| ir.StringTooLong: "ErrStringTooLong", |
| ir.TableCountExceeds32BitLimit: "ErrUnexpectedOrdinal", |
| ir.TooFewBytes: "ErrPayloadTooSmall", |
| ir.TooFewBytesInPrimaryObject: "ErrPayloadTooSmall", |
| ir.TooFewHandles: "ErrNotEnoughHandles", |
| ir.TooManyBytesInMessage: "ErrTooManyBytesInMessage", |
| ir.TooManyHandlesInMessage: "ErrTooManyHandles", |
| ir.UnionFieldNotSet: "ErrInvalidXUnionTag", |
| ir.CountExceedsLimit: "ErrVectorTooLong", |
| ir.UnexpectedOrdinal: "ErrUnexpectedOrdinal", |
| ir.VectorCountExceeds32BitLimit: "ErrVectorTooLong", |
| } |
| |
| func goErrorCode(code ir.ErrorCode) (string, error) { |
| if str, ok := goErrorCodeNames[code]; ok { |
| return fmt.Sprintf("fidl.%s", str), nil |
| } |
| return "", fmt.Errorf("no go error string defined for error code %s", code) |
| } |
