Subversion Repositories openrisc

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file contains printing suppport for ASTs.

package ast

import (
        "fmt"
        "go/token"
        "io"
        "os"
        "reflect"
)

// A FieldFilter may be provided to Fprint to control the output.
type FieldFilter func(name string, value reflect.Value) bool

// NotNilFilter returns true for field values that are not nil;
// it returns false otherwise.
func NotNilFilter(_ string, v reflect.Value) bool {
        switch v.Kind() {
        case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
                return !v.IsNil()
        }
        return true
}

// Fprint prints the (sub-)tree starting at AST node x to w.
// If fset != nil, position information is interpreted relative
// to that file set. Otherwise positions are printed as integer
// values (file set specific offsets).
//
// A non-nil FieldFilter f may be provided to control the output:
// struct fields for which f(fieldname, fieldvalue) is true are
// are printed; all others are filtered from the output.
//
func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) (err error) {
        // setup printer
        p := printer{
                output: w,
                fset:   fset,
                filter: f,
                ptrmap: make(map[interface{}]int),
                last:   '\n', // force printing of line number on first line
        }

        // install error handler
        defer func() {
                if e := recover(); e != nil {
                        err = e.(localError).err // re-panics if it's not a localError
                }
        }()

        // print x
        if x == nil {
                p.printf("nil\n")
                return
        }
        p.print(reflect.ValueOf(x))
        p.printf("\n")

        return
}

// Print prints x to standard output, skipping nil fields.
// Print(fset, x) is the same as Fprint(os.Stdout, fset, x, NotNilFilter).
func Print(fset *token.FileSet, x interface{}) error {
        return Fprint(os.Stdout, fset, x, NotNilFilter)
}

type printer struct {
        output io.Writer
        fset   *token.FileSet
        filter FieldFilter
        ptrmap map[interface{}]int // *T -> line number
        indent int                 // current indentation level
        last   byte                // the last byte processed by Write
        line   int                 // current line number
}

var indent = []byte(".  ")

func (p *printer) Write(data []byte) (n int, err error) {
        var m int
        for i, b := range data {
                // invariant: data[0:n] has been written
                if b == '\n' {
                        m, err = p.output.Write(data[n : i+1])
                        n += m
                        if err != nil {
                                return
                        }
                        p.line++
                } else if p.last == '\n' {
                        _, err = fmt.Fprintf(p.output, "%6d  ", p.line)
                        if err != nil {
                                return
                        }
                        for j := p.indent; j > 0; j-- {
                                _, err = p.output.Write(indent)
                                if err != nil {
                                        return
                                }
                        }
                }
                p.last = b
        }
        m, err = p.output.Write(data[n:])
        n += m
        return
}

// localError wraps locally caught errors so we can distinguish
// them from genuine panics which we don't want to return as errors.
type localError struct {
        err error
}

// printf is a convenience wrapper that takes care of print errors.
func (p *printer) printf(format string, args ...interface{}) {
        if _, err := fmt.Fprintf(p, format, args...); err != nil {
                panic(localError{err})
        }
}

// Implementation note: Print is written for AST nodes but could be
// used to print arbitrary data structures; such a version should
// probably be in a different package.
//
// Note: This code detects (some) cycles created via pointers but
// not cycles that are created via slices or maps containing the
// same slice or map. Code for general data structures probably
// should catch those as well.

func (p *printer) print(x reflect.Value) {
        if !NotNilFilter("", x) {
                p.printf("nil")
                return
        }

        switch x.Kind() {
        case reflect.Interface:
                p.print(x.Elem())

        case reflect.Map:
                p.printf("%s (len = %d) {\n", x.Type(), x.Len())
                p.indent++
                for _, key := range x.MapKeys() {
                        p.print(key)
                        p.printf(": ")
                        p.print(x.MapIndex(key))
                        p.printf("\n")
                }
                p.indent--
                p.printf("}")

        case reflect.Ptr:
                p.printf("*")
                // type-checked ASTs may contain cycles - use ptrmap
                // to keep track of objects that have been printed
                // already and print the respective line number instead
                ptr := x.Interface()
                if line, exists := p.ptrmap[ptr]; exists {
                        p.printf("(obj @ %d)", line)
                } else {
                        p.ptrmap[ptr] = p.line
                        p.print(x.Elem())
                }

        case reflect.Slice:
                if s, ok := x.Interface().([]byte); ok {
                        p.printf("%#q", s)
                        return
                }
                p.printf("%s (len = %d) {\n", x.Type(), x.Len())
                p.indent++
                for i, n := 0, x.Len(); i < n; i++ {
                        p.printf("%d: ", i)
                        p.print(x.Index(i))
                        p.printf("\n")
                }
                p.indent--
                p.printf("}")

        case reflect.Struct:
                p.printf("%s {\n", x.Type())
                p.indent++
                t := x.Type()
                for i, n := 0, t.NumField(); i < n; i++ {
                        name := t.Field(i).Name
                        value := x.Field(i)
                        if p.filter == nil || p.filter(name, value) {
                                p.printf("%s: ", name)
                                p.print(value)
                                p.printf("\n")
                        }
                }
                p.indent--
                p.printf("}")

        default:
                v := x.Interface()
                switch v := v.(type) {
                case string:
                        // print strings in quotes
                        p.printf("%q", v)
                        return
                case token.Pos:
                        // position values can be printed nicely if we have a file set
                        if p.fset != nil {
                                p.printf("%s", p.fset.Position(v))
                                return
                        }
                }
                // default
                p.printf("%v", v)
        }
}