// Copyright 2011 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.

package gc

import (
	"cmd/internal/obj"
	"fmt"
	"strings"
	"unicode/utf8"
)

//
// Format conversions
//	%L int		Line numbers
//
//	%E int		etype values (aka 'Kind')
//
//	%O int		Node Opcodes
//		Flags: "%#O": print go syntax. (automatic unless fmtmode == FDbg)
//
//	%J Node*	Node details
//		Flags: "%hJ" suppresses things not relevant until walk.
//
//	%V Val*		Constant values
//
//	%S Sym*		Symbols
//		Flags: +,- #: mode (see below)
//			"%hS"	unqualified identifier in any mode
//			"%hhS"  in export mode: unqualified identifier if exported, qualified if not
//
//	%T Type*	Types
//		Flags: +,- #: mode (see below)
//			'l' definition instead of name.
//			'h' omit "func" and receiver in function types
//			'u' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
//
//	%N Node*	Nodes
//		Flags: +,- #: mode (see below)
//			'h' (only in +/debug mode) suppress recursion
//			'l' (only in Error mode) print "foo (type Bar)"
//
//	%H NodeList*	NodeLists
//		Flags: those of %N
//			','  separate items with ',' instead of ';'
//
//	%Z Strlit*	String literals
//
//   In mparith1.c:
//      %B Mpint*	Big integers
//	%F Mpflt*	Big floats
//
//   %S, %T and %N obey use the following flags to set the format mode:
const (
	FErr = iota
	FDbg
	FExp
	FTypeId
)

var fmtmode int = FErr

var fmtpkgpfx int // %uT stickyness

//
// E.g. for %S:	%+S %#S %-S	print an identifier properly qualified for debug/export/internal mode.
//
// The mode flags  +, - and # are sticky, meaning they persist through
// recursions of %N, %T and %S, but not the h and l flags.  The u flag is
// sticky only on %T recursions and only used in %-/Sym mode.

//
// Useful format combinations:
//
//	%+N   %+H	multiline recursive debug dump of node/nodelist
//	%+hN  %+hH	non recursive debug dump
//
//	%#N   %#T	export format
//	%#lT		type definition instead of name
//	%#hT		omit"func" and receiver in function signature
//
//	%lN		"foo (type Bar)" for error messages
//
//	%-T		type identifiers
//	%-hT		type identifiers without "func" and arg names in type signatures (methodsym)
//	%-uT		type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
//

func setfmode(flags *int) int {
	var fm int

	fm = fmtmode
	if *flags&obj.FmtSign != 0 {
		fmtmode = FDbg
	} else if *flags&obj.FmtSharp != 0 {
		fmtmode = FExp
	} else if *flags&obj.FmtLeft != 0 {
		fmtmode = FTypeId
	}

	*flags &^= (obj.FmtSharp | obj.FmtLeft | obj.FmtSign)
	return fm
}

// Fmt "%L": Linenumbers

var goopnames = []string{
	OADDR:     "&",
	OADD:      "+",
	OADDSTR:   "+",
	OANDAND:   "&&",
	OANDNOT:   "&^",
	OAND:      "&",
	OAPPEND:   "append",
	OAS:       "=",
	OAS2:      "=",
	OBREAK:    "break",
	OCALL:     "function call", // not actual syntax
	OCAP:      "cap",
	OCASE:     "case",
	OCLOSE:    "close",
	OCOMPLEX:  "complex",
	OCOM:      "^",
	OCONTINUE: "continue",
	OCOPY:     "copy",
	ODEC:      "--",
	ODELETE:   "delete",
	ODEFER:    "defer",
	ODIV:      "/",
	OEQ:       "==",
	OFALL:     "fallthrough",
	OFOR:      "for",
	OGE:       ">=",
	OGOTO:     "goto",
	OGT:       ">",
	OIF:       "if",
	OIMAG:     "imag",
	OINC:      "++",
	OIND:      "*",
	OLEN:      "len",
	OLE:       "<=",
	OLSH:      "<<",
	OLT:       "<",
	OMAKE:     "make",
	OMINUS:    "-",
	OMOD:      "%",
	OMUL:      "*",
	ONEW:      "new",
	ONE:       "!=",
	ONOT:      "!",
	OOROR:     "||",
	OOR:       "|",
	OPANIC:    "panic",
	OPLUS:     "+",
	OPRINTN:   "println",
	OPRINT:    "print",
	ORANGE:    "range",
	OREAL:     "real",
	ORECV:     "<-",
	ORECOVER:  "recover",
	ORETURN:   "return",
	ORSH:      ">>",
	OSELECT:   "select",
	OSEND:     "<-",
	OSUB:      "-",
	OSWITCH:   "switch",
	OXOR:      "^",
}

// Fmt "%O":  Node opcodes
func Oconv(o int, flag int) string {
	var fp string

	if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode != FDbg {
		if o >= 0 && o < len(goopnames) && goopnames[o] != "" {
			fp += goopnames[o]
			return fp
		}
	}

	if o >= 0 && o < len(opnames) && opnames[o] != "" {
		fp += opnames[o]
		return fp
	}

	fp += fmt.Sprintf("O-%d", o)
	return fp
}

var classnames = []string{
	"Pxxx",
	"PEXTERN",
	"PAUTO",
	"PPARAM",
	"PPARAMOUT",
	"PPARAMREF",
	"PFUNC",
}

// Fmt "%J": Node details.
func Jconv(n *Node, flag int) string {
	var fp string

	var s string
	var c int

	c = flag & obj.FmtShort

	if c == 0 && n.Ullman != 0 {
		fp += fmt.Sprintf(" u(%d)", n.Ullman)
	}

	if c == 0 && n.Addable != 0 {
		fp += fmt.Sprintf(" a(%d)", n.Addable)
	}

	if c == 0 && n.Vargen != 0 {
		fp += fmt.Sprintf(" g(%d)", n.Vargen)
	}

	if n.Lineno != 0 {
		fp += fmt.Sprintf(" l(%d)", n.Lineno)
	}

	if c == 0 && n.Xoffset != BADWIDTH {
		fp += fmt.Sprintf(" x(%d%+d)", n.Xoffset, n.Stkdelta)
	}

	if n.Class != 0 {
		s = ""
		if n.Class&PHEAP != 0 {
			s = ",heap"
		}
		if int(n.Class&^PHEAP) < len(classnames) {
			fp += fmt.Sprintf(" class(%s%s)", classnames[n.Class&^PHEAP], s)
		} else {
			fp += fmt.Sprintf(" class(%d?%s)", n.Class&^PHEAP, s)
		}
	}

	if n.Colas != 0 {
		fp += fmt.Sprintf(" colas(%d)", n.Colas)
	}

	if n.Funcdepth != 0 {
		fp += fmt.Sprintf(" f(%d)", n.Funcdepth)
	}

	switch n.Esc {
	case EscUnknown:
		break

	case EscHeap:
		fp += fmt.Sprintf(" esc(h)")

	case EscScope:
		fp += fmt.Sprintf(" esc(s)")

	case EscNone:
		fp += fmt.Sprintf(" esc(no)")

	case EscNever:
		if c == 0 {
			fp += fmt.Sprintf(" esc(N)")
		}

	default:
		fp += fmt.Sprintf(" esc(%d)", n.Esc)
	}

	if n.Escloopdepth != 0 {
		fp += fmt.Sprintf(" ld(%d)", n.Escloopdepth)
	}

	if c == 0 && n.Typecheck != 0 {
		fp += fmt.Sprintf(" tc(%d)", n.Typecheck)
	}

	if c == 0 && n.Dodata != 0 {
		fp += fmt.Sprintf(" dd(%d)", n.Dodata)
	}

	if n.Isddd != 0 {
		fp += fmt.Sprintf(" isddd(%d)", n.Isddd)
	}

	if n.Implicit != 0 {
		fp += fmt.Sprintf(" implicit(%d)", n.Implicit)
	}

	if n.Embedded != 0 {
		fp += fmt.Sprintf(" embedded(%d)", n.Embedded)
	}

	if n.Addrtaken != 0 {
		fp += fmt.Sprintf(" addrtaken")
	}

	if n.Assigned != 0 {
		fp += fmt.Sprintf(" assigned")
	}

	if c == 0 && n.Used != 0 {
		fp += fmt.Sprintf(" used(%d)", n.Used)
	}
	return fp
}

// Fmt "%V": Values
func Vconv(v *Val, flag int) string {
	var fp string

	var x int64

	switch v.Ctype {
	case CTINT:
		if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
			fp += fmt.Sprintf("%v", Bconv(v.U.Xval, obj.FmtSharp))
			return fp
		}
		fp += fmt.Sprintf("%v", Bconv(v.U.Xval, 0))
		return fp

	case CTRUNE:
		x = Mpgetfix(v.U.Xval)
		if ' ' <= x && x < 0x80 && x != '\\' && x != '\'' {
			fp += fmt.Sprintf("'%c'", int(x))
			return fp
		}
		if 0 <= x && x < 1<<16 {
			fp += fmt.Sprintf("'\\u%04x'", uint(int(x)))
			return fp
		}
		if 0 <= x && x <= utf8.MaxRune {
			fp += fmt.Sprintf("'\\U%08x'", uint64(x))
			return fp
		}
		fp += fmt.Sprintf("('\\x00' + %v)", Bconv(v.U.Xval, 0))
		return fp

	case CTFLT:
		if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
			fp += fmt.Sprintf("%v", Fconv(v.U.Fval, 0))
			return fp
		}
		fp += fmt.Sprintf("%v", Fconv(v.U.Fval, obj.FmtSharp))
		return fp

	case CTCPLX:
		if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
			fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, 0), Fconv(&v.U.Cval.Imag, 0))
			return fp
		}
		if mpcmpfltc(&v.U.Cval.Real, 0) == 0 {
			fp += fmt.Sprintf("%vi", Fconv(&v.U.Cval.Imag, obj.FmtSharp))
			return fp
		}
		if mpcmpfltc(&v.U.Cval.Imag, 0) == 0 {
			fp += fmt.Sprintf("%v", Fconv(&v.U.Cval.Real, obj.FmtSharp))
			return fp
		}
		if mpcmpfltc(&v.U.Cval.Imag, 0) < 0 {
			fp += fmt.Sprintf("(%v%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp))
			return fp
		}
		fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp))
		return fp

	case CTSTR:
		fp += fmt.Sprintf("\"%v\"", Zconv(v.U.Sval, 0))
		return fp

	case CTBOOL:
		if v.U.Bval != 0 {
			fp += "true"
			return fp
		}
		fp += "false"
		return fp

	case CTNIL:
		fp += "nil"
		return fp
	}

	fp += fmt.Sprintf("<ctype=%d>", v.Ctype)
	return fp
}

// Fmt "%Z": escaped string literals
func Zconv(sp *Strlit, flag int) string {
	var fp string
	var s string
	var n int

	if sp == nil {
		fp += "<nil>"
		return fp
	}

	// NOTE: Keep in sync with ../ld/go.c:/^Zconv.
	s = sp.S
	for i := 0; i < len(s); i += n {
		var r rune
		r, n = utf8.DecodeRuneInString(s[i:])
		switch r {
		case utf8.RuneError:
			if n == 1 {
				fp += fmt.Sprintf("\\x%02x", s[i])
				break
			}
			fallthrough

			// fall through
		default:
			if r < ' ' {
				fp += fmt.Sprintf("\\x%02x", r)
				break
			}

			fp += string(r)

		case '\t':
			fp += "\\t"

		case '\n':
			fp += "\\n"

		case '"',
			'\\':
			fp += `\` + string(r)

		case 0xFEFF: // BOM, basically disallowed in source code
			fp += "\\uFEFF"
		}
	}

	return fp
}

/*
s%,%,\n%g
s%\n+%\n%g
s%^[	]*T%%g
s%,.*%%g
s%.+%	[T&]		= "&",%g
s%^	........*\]%&~%g
s%~	%%g
*/
var etnames = []string{
	TINT:        "INT",
	TUINT:       "UINT",
	TINT8:       "INT8",
	TUINT8:      "UINT8",
	TINT16:      "INT16",
	TUINT16:     "UINT16",
	TINT32:      "INT32",
	TUINT32:     "UINT32",
	TINT64:      "INT64",
	TUINT64:     "UINT64",
	TUINTPTR:    "UINTPTR",
	TFLOAT32:    "FLOAT32",
	TFLOAT64:    "FLOAT64",
	TCOMPLEX64:  "COMPLEX64",
	TCOMPLEX128: "COMPLEX128",
	TBOOL:       "BOOL",
	TPTR32:      "PTR32",
	TPTR64:      "PTR64",
	TFUNC:       "FUNC",
	TARRAY:      "ARRAY",
	TSTRUCT:     "STRUCT",
	TCHAN:       "CHAN",
	TMAP:        "MAP",
	TINTER:      "INTER",
	TFORW:       "FORW",
	TFIELD:      "FIELD",
	TSTRING:     "STRING",
	TANY:        "ANY",
}

// Fmt "%E": etype
func Econv(et int, flag int) string {
	var fp string

	if et >= 0 && et < len(etnames) && etnames[et] != "" {
		fp += etnames[et]
		return fp
	}
	fp += fmt.Sprintf("E-%d", et)
	return fp
}

// Fmt "%S": syms
func symfmt(s *Sym, flag int) string {
	var fp string

	var p string

	if s.Pkg != nil && flag&obj.FmtShort == 0 /*untyped*/ {
		switch fmtmode {
		case FErr: // This is for the user
			if s.Pkg == localpkg {
				fp += s.Name
				return fp
			}

			// If the name was used by multiple packages, display the full path,
			if s.Pkg.Name != "" && Pkglookup(s.Pkg.Name, nil).Npkg > 1 {
				fp += fmt.Sprintf("\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name)
				return fp
			}
			fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
			return fp

		case FDbg:
			fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
			return fp

		case FTypeId:
			if flag&obj.FmtUnsigned != 0 /*untyped*/ {
				fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
				return fp // dcommontype, typehash
			}
			fp += fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name)
			return fp // (methodsym), typesym, weaksym

		case FExp:
			if s.Name != "" && s.Name[0] == '.' {
				Fatal("exporting synthetic symbol %s", s.Name)
			}
			if s.Pkg != builtinpkg {
				fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name)
				return fp
			}
		}
	}

	if flag&obj.FmtByte != 0 /*untyped*/ { // FmtByte (hh) implies FmtShort (h)

		// skip leading "type." in method name
		p = s.Name
		if i := strings.LastIndex(s.Name, "."); i >= 0 {
			p = s.Name[i+1:]
		}

		// exportname needs to see the name without the prefix too.
		if (fmtmode == FExp && !exportname(p)) || fmtmode == FDbg {
			fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), p)
			return fp
		}

		fp += p
		return fp
	}

	fp += s.Name
	return fp
}

var basicnames = []string{
	TINT:        "int",
	TUINT:       "uint",
	TINT8:       "int8",
	TUINT8:      "uint8",
	TINT16:      "int16",
	TUINT16:     "uint16",
	TINT32:      "int32",
	TUINT32:     "uint32",
	TINT64:      "int64",
	TUINT64:     "uint64",
	TUINTPTR:    "uintptr",
	TFLOAT32:    "float32",
	TFLOAT64:    "float64",
	TCOMPLEX64:  "complex64",
	TCOMPLEX128: "complex128",
	TBOOL:       "bool",
	TANY:        "any",
	TSTRING:     "string",
	TNIL:        "nil",
	TIDEAL:      "untyped number",
	TBLANK:      "blank",
}

func typefmt(t *Type, flag int) string {
	var fp string

	var t1 *Type
	var s *Sym

	if t == nil {
		fp += "<T>"
		return fp
	}

	if t == bytetype || t == runetype {
		// in %-T mode collapse rune and byte with their originals.
		if fmtmode != FTypeId {
			fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort))
			return fp
		}
		t = Types[t.Etype]
	}

	if t == errortype {
		fp += "error"
		return fp
	}

	// Unless the 'l' flag was specified, if the type has a name, just print that name.
	if flag&obj.FmtLong == 0 /*untyped*/ && t.Sym != nil && t.Etype != TFIELD && t != Types[t.Etype] {
		switch fmtmode {
		case FTypeId:
			if flag&obj.FmtShort != 0 /*untyped*/ {
				if t.Vargen != 0 {
					fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, obj.FmtShort), t.Vargen)
					return fp
				}
				fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort))
				return fp
			}

			if flag&obj.FmtUnsigned != 0 /*untyped*/ {
				fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtUnsigned))
				return fp
			}
			fallthrough

			// fallthrough
		case FExp:
			if t.Sym.Pkg == localpkg && t.Vargen != 0 {
				fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, 0), t.Vargen)
				return fp
			}
		}

		fp += fmt.Sprintf("%v", Sconv(t.Sym, 0))
		return fp
	}

	if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" {
		if fmtmode == FErr && (t == idealbool || t == idealstring) {
			fp += "untyped "
		}
		fp += basicnames[t.Etype]
		return fp
	}

	if fmtmode == FDbg {
		fp += fmt.Sprintf("%v-", Econv(int(t.Etype), 0))
	}

	switch t.Etype {
	case TPTR32,
		TPTR64:
		if fmtmode == FTypeId && (flag&obj.FmtShort != 0 /*untyped*/) {
			fp += fmt.Sprintf("*%v", Tconv(t.Type, obj.FmtShort))
			return fp
		}
		fp += fmt.Sprintf("*%v", Tconv(t.Type, 0))
		return fp

	case TARRAY:
		if t.Bound >= 0 {
			fp += fmt.Sprintf("[%d]%v", t.Bound, Tconv(t.Type, 0))
			return fp
		}
		if t.Bound == -100 {
			fp += fmt.Sprintf("[...]%v", Tconv(t.Type, 0))
			return fp
		}
		fp += fmt.Sprintf("[]%v", Tconv(t.Type, 0))
		return fp

	case TCHAN:
		switch t.Chan {
		case Crecv:
			fp += fmt.Sprintf("<-chan %v", Tconv(t.Type, 0))
			return fp

		case Csend:
			fp += fmt.Sprintf("chan<- %v", Tconv(t.Type, 0))
			return fp
		}

		if t.Type != nil && t.Type.Etype == TCHAN && t.Type.Sym == nil && t.Type.Chan == Crecv {
			fp += fmt.Sprintf("chan (%v)", Tconv(t.Type, 0))
			return fp
		}
		fp += fmt.Sprintf("chan %v", Tconv(t.Type, 0))
		return fp

	case TMAP:
		fp += fmt.Sprintf("map[%v]%v", Tconv(t.Down, 0), Tconv(t.Type, 0))
		return fp

	case TINTER:
		fp += "interface {"
		for t1 = t.Type; t1 != nil; t1 = t1.Down {
			if exportname(t1.Sym.Name) {
				if t1.Down != nil {
					fp += fmt.Sprintf(" %v%v;", Sconv(t1.Sym, obj.FmtShort), Tconv(t1.Type, obj.FmtShort))
				} else {
					fp += fmt.Sprintf(" %v%v ", Sconv(t1.Sym, obj.FmtShort), Tconv(t1.Type, obj.FmtShort))
				}
			} else {
				// non-exported method names must be qualified
				if t1.Down != nil {
					fp += fmt.Sprintf(" %v%v;", Sconv(t1.Sym, obj.FmtUnsigned), Tconv(t1.Type, obj.FmtShort))
				} else {
					fp += fmt.Sprintf(" %v%v ", Sconv(t1.Sym, obj.FmtUnsigned), Tconv(t1.Type, obj.FmtShort))
				}
			}
		}

		fp += "}"
		return fp

	case TFUNC:
		if flag&obj.FmtShort != 0 /*untyped*/ {
			fp += fmt.Sprintf("%v", Tconv(getinargx(t), 0))
		} else {
			if t.Thistuple != 0 {
				fp += fmt.Sprintf("method%v func%v", Tconv(getthisx(t), 0), Tconv(getinargx(t), 0))
			} else {
				fp += fmt.Sprintf("func%v", Tconv(getinargx(t), 0))
			}
		}

		switch t.Outtuple {
		case 0:
			break

		case 1:
			if fmtmode != FExp {
				fp += fmt.Sprintf(" %v", Tconv(getoutargx(t).Type.Type, 0)) // struct->field->field's type
				break
			}
			fallthrough

		default:
			fp += fmt.Sprintf(" %v", Tconv(getoutargx(t), 0))
		}

		return fp

		// Format the bucket struct for map[x]y as map.bucket[x]y.
	// This avoids a recursive print that generates very long names.
	case TSTRUCT:
		if t.Map != nil {
			if t.Map.Bucket == t {
				fp += fmt.Sprintf("map.bucket[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
				return fp
			}

			if t.Map.Hmap == t {
				fp += fmt.Sprintf("map.hdr[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
				return fp
			}

			if t.Map.Hiter == t {
				fp += fmt.Sprintf("map.iter[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
				return fp
			}

			Yyerror("unknown internal map type")
		}

		if t.Funarg != 0 {
			fp += "("
			if fmtmode == FTypeId || fmtmode == FErr { // no argument names on function signature, and no "noescape"/"nosplit" tags
				for t1 = t.Type; t1 != nil; t1 = t1.Down {
					if t1.Down != nil {
						fp += fmt.Sprintf("%v, ", Tconv(t1, obj.FmtShort))
					} else {
						fp += fmt.Sprintf("%v", Tconv(t1, obj.FmtShort))
					}
				}
			} else {
				for t1 = t.Type; t1 != nil; t1 = t1.Down {
					if t1.Down != nil {
						fp += fmt.Sprintf("%v, ", Tconv(t1, 0))
					} else {
						fp += fmt.Sprintf("%v", Tconv(t1, 0))
					}
				}
			}

			fp += ")"
		} else {
			fp += "struct {"
			for t1 = t.Type; t1 != nil; t1 = t1.Down {
				if t1.Down != nil {
					fp += fmt.Sprintf(" %v;", Tconv(t1, obj.FmtLong))
				} else {
					fp += fmt.Sprintf(" %v ", Tconv(t1, obj.FmtLong))
				}
			}
			fp += "}"
		}

		return fp

	case TFIELD:
		if flag&obj.FmtShort == 0 /*untyped*/ {
			s = t.Sym

			// Take the name from the original, lest we substituted it with ~r%d or ~b%d.
			// ~r%d is a (formerly) unnamed result.
			if (fmtmode == FErr || fmtmode == FExp) && t.Nname != nil {
				if t.Nname.Orig != nil {
					s = t.Nname.Orig.Sym
					if s != nil && s.Name[0] == '~' {
						if s.Name[1] == 'r' { // originally an unnamed result
							s = nil
						} else if s.Name[1] == 'b' { // originally the blank identifier _
							s = Lookup("_")
						}
					}
				} else {
					s = nil
				}
			}

			if s != nil && t.Embedded == 0 {
				if t.Funarg != 0 {
					fp += fmt.Sprintf("%v ", Nconv(t.Nname, 0))
				} else if flag&obj.FmtLong != 0 /*untyped*/ {
					fp += fmt.Sprintf("%v ", Sconv(s, obj.FmtShort|obj.FmtByte)) // qualify non-exported names (used on structs, not on funarg)
				} else {
					fp += fmt.Sprintf("%v ", Sconv(s, 0))
				}
			} else if fmtmode == FExp {
				// TODO(rsc) this breaks on the eliding of unused arguments in the backend
				// when this is fixed, the special case in dcl.c checkarglist can go.
				//if(t->funarg)
				//	fmtstrcpy(fp, "_ ");
				//else
				if t.Embedded != 0 && s.Pkg != nil && len(s.Pkg.Path.S) > 0 {
					fp += fmt.Sprintf("@\"%v\".? ", Zconv(s.Pkg.Path, 0))
				} else {
					fp += "? "
				}
			}
		}

		if t.Isddd != 0 {
			fp += fmt.Sprintf("...%v", Tconv(t.Type.Type, 0))
		} else {
			fp += fmt.Sprintf("%v", Tconv(t.Type, 0))
		}

		if flag&obj.FmtShort == 0 /*untyped*/ && t.Note != nil {
			fp += fmt.Sprintf(" \"%v\"", Zconv(t.Note, 0))
		}
		return fp

	case TFORW:
		if t.Sym != nil {
			fp += fmt.Sprintf("undefined %v", Sconv(t.Sym, 0))
			return fp
		}
		fp += "undefined"
		return fp

	case TUNSAFEPTR:
		if fmtmode == FExp {
			fp += fmt.Sprintf("@\"unsafe\".Pointer")
			return fp
		}
		fp += fmt.Sprintf("unsafe.Pointer")
		return fp
	}

	if fmtmode == FExp {
		Fatal("missing %v case during export", Econv(int(t.Etype), 0))
	}

	// Don't know how to handle - fall back to detailed prints.
	fp += fmt.Sprintf("%v <%v> %v", Econv(int(t.Etype), 0), Sconv(t.Sym, 0), Tconv(t.Type, 0))
	return fp
}

// Statements which may be rendered with a simplestmt as init.
func stmtwithinit(op int) bool {
	switch op {
	case OIF,
		OFOR,
		OSWITCH:
		return true
	}

	return false
}

func stmtfmt(n *Node) string {
	var f string

	var complexinit bool
	var simpleinit bool
	var extrablock bool

	// some statements allow for an init, but at most one,
	// but we may have an arbitrary number added, eg by typecheck
	// and inlining.  If it doesn't fit the syntax, emit an enclosing
	// block starting with the init statements.

	// if we can just say "for" n->ninit; ... then do so
	simpleinit = n.Ninit != nil && n.Ninit.Next == nil && n.Ninit.N.Ninit == nil && stmtwithinit(int(n.Op))

	// otherwise, print the inits as separate statements
	complexinit = n.Ninit != nil && !simpleinit && (fmtmode != FErr)

	// but if it was for if/for/switch, put in an extra surrounding block to limit the scope
	extrablock = complexinit && stmtwithinit(int(n.Op))

	if extrablock {
		f += "{"
	}

	if complexinit {
		f += fmt.Sprintf(" %v; ", Hconv(n.Ninit, 0))
	}

	switch n.Op {
	case ODCL:
		if fmtmode == FExp {
			switch n.Left.Class &^ PHEAP {
			case PPARAM,
				PPARAMOUT,
				PAUTO:
				f += fmt.Sprintf("var %v %v", Nconv(n.Left, 0), Tconv(n.Left.Type, 0))
				goto ret
			}
		}

		f += fmt.Sprintf("var %v %v", Sconv(n.Left.Sym, 0), Tconv(n.Left.Type, 0))

	case ODCLFIELD:
		if n.Left != nil {
			f += fmt.Sprintf("%v %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
		} else {
			f += fmt.Sprintf("%v", Nconv(n.Right, 0))
		}

		// Don't export "v = <N>" initializing statements, hope they're always
	// preceded by the DCL which will be re-parsed and typecheck to reproduce
	// the "v = <N>" again.
	case OAS:
		if fmtmode == FExp && n.Right == nil {
			break
		}

		if n.Colas != 0 && !complexinit {
			f += fmt.Sprintf("%v := %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
		} else {
			f += fmt.Sprintf("%v = %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
		}

	case OASOP:
		if n.Implicit != 0 {
			if n.Etype == OADD {
				f += fmt.Sprintf("%v++", Nconv(n.Left, 0))
			} else {
				f += fmt.Sprintf("%v--", Nconv(n.Left, 0))
			}
			break
		}

		f += fmt.Sprintf("%v %v= %v", Nconv(n.Left, 0), Oconv(int(n.Etype), obj.FmtSharp), Nconv(n.Right, 0))

	case OAS2:
		if n.Colas != 0 && !complexinit {
			f += fmt.Sprintf("%v := %v", Hconv(n.List, obj.FmtComma), Hconv(n.Rlist, obj.FmtComma))
			break
		}
		fallthrough

		// fallthrough
	case OAS2DOTTYPE,
		OAS2FUNC,
		OAS2MAPR,
		OAS2RECV:
		f += fmt.Sprintf("%v = %v", Hconv(n.List, obj.FmtComma), Hconv(n.Rlist, obj.FmtComma))

	case ORETURN:
		f += fmt.Sprintf("return %v", Hconv(n.List, obj.FmtComma))

	case ORETJMP:
		f += fmt.Sprintf("retjmp %v", Sconv(n.Sym, 0))

	case OPROC:
		f += fmt.Sprintf("go %v", Nconv(n.Left, 0))

	case ODEFER:
		f += fmt.Sprintf("defer %v", Nconv(n.Left, 0))

	case OIF:
		if simpleinit {
			f += fmt.Sprintf("if %v; %v { %v }", Nconv(n.Ninit.N, 0), Nconv(n.Ntest, 0), Hconv(n.Nbody, 0))
		} else {
			f += fmt.Sprintf("if %v { %v }", Nconv(n.Ntest, 0), Hconv(n.Nbody, 0))
		}
		if n.Nelse != nil {
			f += fmt.Sprintf(" else { %v }", Hconv(n.Nelse, 0))
		}

	case OFOR:
		if fmtmode == FErr { // TODO maybe only if FmtShort, same below
			f += "for loop"
			break
		}

		f += "for"
		if simpleinit {
			f += fmt.Sprintf(" %v;", Nconv(n.Ninit.N, 0))
		} else if n.Nincr != nil {
			f += " ;"
		}

		if n.Ntest != nil {
			f += fmt.Sprintf(" %v", Nconv(n.Ntest, 0))
		}

		if n.Nincr != nil {
			f += fmt.Sprintf("; %v", Nconv(n.Nincr, 0))
		} else if simpleinit {
			f += ";"
		}

		f += fmt.Sprintf(" { %v }", Hconv(n.Nbody, 0))

	case ORANGE:
		if fmtmode == FErr {
			f += "for loop"
			break
		}

		if n.List == nil {
			f += fmt.Sprintf("for range %v { %v }", Nconv(n.Right, 0), Hconv(n.Nbody, 0))
			break
		}

		f += fmt.Sprintf("for %v = range %v { %v }", Hconv(n.List, obj.FmtComma), Nconv(n.Right, 0), Hconv(n.Nbody, 0))

	case OSELECT,
		OSWITCH:
		if fmtmode == FErr {
			f += fmt.Sprintf("%v statement", Oconv(int(n.Op), 0))
			break
		}

		f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
		if simpleinit {
			f += fmt.Sprintf(" %v;", Nconv(n.Ninit.N, 0))
		}
		if n.Ntest != nil {
			f += fmt.Sprintf("%v", Nconv(n.Ntest, 0))
		}

		f += fmt.Sprintf(" { %v }", Hconv(n.List, 0))

	case OCASE,
		OXCASE:
		if n.List != nil {
			f += fmt.Sprintf("case %v: %v", Hconv(n.List, obj.FmtComma), Hconv(n.Nbody, 0))
		} else {
			f += fmt.Sprintf("default: %v", Hconv(n.Nbody, 0))
		}

	case OBREAK,
		OCONTINUE,
		OGOTO,
		OFALL,
		OXFALL:
		if n.Left != nil {
			f += fmt.Sprintf("%v %v", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0))
		} else {
			f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
		}

	case OEMPTY:
		break

	case OLABEL:
		f += fmt.Sprintf("%v: ", Nconv(n.Left, 0))
	}

ret:
	if extrablock {
		f += "}"
	}

	return f
}

var opprec = []int{
	OAPPEND:       8,
	OARRAYBYTESTR: 8,
	OARRAYLIT:     8,
	OARRAYRUNESTR: 8,
	OCALLFUNC:     8,
	OCALLINTER:    8,
	OCALLMETH:     8,
	OCALL:         8,
	OCAP:          8,
	OCLOSE:        8,
	OCONVIFACE:    8,
	OCONVNOP:      8,
	OCONV:         8,
	OCOPY:         8,
	ODELETE:       8,
	OLEN:          8,
	OLITERAL:      8,
	OMAKESLICE:    8,
	OMAKE:         8,
	OMAPLIT:       8,
	ONAME:         8,
	ONEW:          8,
	ONONAME:       8,
	OPACK:         8,
	OPANIC:        8,
	OPAREN:        8,
	OPRINTN:       8,
	OPRINT:        8,
	ORUNESTR:      8,
	OSTRARRAYBYTE: 8,
	OSTRARRAYRUNE: 8,
	OSTRUCTLIT:    8,
	OTARRAY:       8,
	OTCHAN:        8,
	OTFUNC:        8,
	OTINTER:       8,
	OTMAP:         8,
	OTSTRUCT:      8,
	OINDEXMAP:     8,
	OINDEX:        8,
	OSLICE:        8,
	OSLICESTR:     8,
	OSLICEARR:     8,
	OSLICE3:       8,
	OSLICE3ARR:    8,
	ODOTINTER:     8,
	ODOTMETH:      8,
	ODOTPTR:       8,
	ODOTTYPE2:     8,
	ODOTTYPE:      8,
	ODOT:          8,
	OXDOT:         8,
	OCALLPART:     8,
	OPLUS:         7,
	ONOT:          7,
	OCOM:          7,
	OMINUS:        7,
	OADDR:         7,
	OIND:          7,
	ORECV:         7,
	OMUL:          6,
	ODIV:          6,
	OMOD:          6,
	OLSH:          6,
	ORSH:          6,
	OAND:          6,
	OANDNOT:       6,
	OADD:          5,
	OSUB:          5,
	OOR:           5,
	OXOR:          5,
	OEQ:           4,
	OLT:           4,
	OLE:           4,
	OGE:           4,
	OGT:           4,
	ONE:           4,
	OCMPSTR:       4,
	OCMPIFACE:     4,
	OSEND:         3,
	OANDAND:       2,
	OOROR:         1,
	// Statements handled by stmtfmt
	OAS:         -1,
	OAS2:        -1,
	OAS2DOTTYPE: -1,
	OAS2FUNC:    -1,
	OAS2MAPR:    -1,
	OAS2RECV:    -1,
	OASOP:       -1,
	OBREAK:      -1,
	OCASE:       -1,
	OCONTINUE:   -1,
	ODCL:        -1,
	ODCLFIELD:   -1,
	ODEFER:      -1,
	OEMPTY:      -1,
	OFALL:       -1,
	OFOR:        -1,
	OGOTO:       -1,
	OIF:         -1,
	OLABEL:      -1,
	OPROC:       -1,
	ORANGE:      -1,
	ORETURN:     -1,
	OSELECT:     -1,
	OSWITCH:     -1,
	OXCASE:      -1,
	OXFALL:      -1,
	OEND:        0,
}

func exprfmt(n *Node, prec int) string {
	var f string

	var nprec int
	var ptrlit bool
	var l *NodeList

	for n != nil && n.Implicit != 0 && (n.Op == OIND || n.Op == OADDR) {
		n = n.Left
	}

	if n == nil {
		f += "<N>"
		return f
	}

	nprec = opprec[n.Op]
	if n.Op == OTYPE && n.Sym != nil {
		nprec = 8
	}

	if prec > nprec {
		f += fmt.Sprintf("(%v)", Nconv(n, 0))
		return f
	}

	switch n.Op {
	case OPAREN:
		f += fmt.Sprintf("(%v)", Nconv(n.Left, 0))
		return f

	case ODDDARG:
		f += fmt.Sprintf("... argument")
		return f

	case OREGISTER:
		f += fmt.Sprintf("%v", Ctxt.Rconv(int(n.Val.U.Reg)))
		return f

	case OLITERAL: // this is a bit of a mess
		if fmtmode == FErr && n.Sym != nil {
			f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
			return f
		}
		if n.Val.Ctype == CTNIL && n.Orig != nil && n.Orig != n {
			f += exprfmt(n.Orig, prec)
			return f
		}
		if n.Type != nil && n.Type != Types[n.Type.Etype] && n.Type != idealbool && n.Type != idealstring {
			// Need parens when type begins with what might
			// be misinterpreted as a unary operator: * or <-.
			if Isptr[n.Type.Etype] != 0 || (n.Type.Etype == TCHAN && n.Type.Chan == Crecv) {
				f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
				return f
			} else {
				f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
				return f
			}
		}

		f += fmt.Sprintf("%v", Vconv(&n.Val, 0))
		return f

		// Special case: name used as local variable in export.
	// _ becomes ~b%d internally; print as _ for export
	case ONAME:
		if fmtmode == FExp && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' {
			f += fmt.Sprintf("_")
			return f
		}
		if fmtmode == FExp && n.Sym != nil && !isblank(n) && n.Vargen > 0 {
			f += fmt.Sprintf("%v·%d", Sconv(n.Sym, 0), n.Vargen)
			return f
		}

		// Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
		// but for export, this should be rendered as (*pkg.T).meth.
		// These nodes have the special property that they are names with a left OTYPE and a right ONAME.
		if fmtmode == FExp && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME {
			if Isptr[n.Left.Type.Etype] != 0 {
				f += fmt.Sprintf("(%v).%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
				return f
			} else {
				f += fmt.Sprintf("%v.%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
				return f
			}
		}
		fallthrough

		//fallthrough
	case OPACK,
		ONONAME:
		f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
		return f

	case OTYPE:
		if n.Type == nil && n.Sym != nil {
			f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
			return f
		}
		f += fmt.Sprintf("%v", Tconv(n.Type, 0))
		return f

	case OTARRAY:
		if n.Left != nil {
			f += fmt.Sprintf("[]%v", Nconv(n.Left, 0))
			return f
		}
		f += fmt.Sprintf("[]%v", Nconv(n.Right, 0))
		return f // happens before typecheck

	case OTMAP:
		f += fmt.Sprintf("map[%v]%v", Nconv(n.Left, 0), Nconv(n.Right, 0))
		return f

	case OTCHAN:
		switch n.Etype {
		case Crecv:
			f += fmt.Sprintf("<-chan %v", Nconv(n.Left, 0))
			return f

		case Csend:
			f += fmt.Sprintf("chan<- %v", Nconv(n.Left, 0))
			return f

		default:
			if n.Left != nil && n.Left.Op == OTCHAN && n.Left.Sym == nil && n.Left.Etype == Crecv {
				f += fmt.Sprintf("chan (%v)", Nconv(n.Left, 0))
				return f
			} else {
				f += fmt.Sprintf("chan %v", Nconv(n.Left, 0))
				return f
			}
		}
		fallthrough

	case OTSTRUCT:
		f += fmt.Sprintf("<struct>")
		return f

	case OTINTER:
		f += fmt.Sprintf("<inter>")
		return f

	case OTFUNC:
		f += fmt.Sprintf("<func>")
		return f

	case OCLOSURE:
		if fmtmode == FErr {
			f += "func literal"
			return f
		}
		if n.Nbody != nil {
			f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Nbody, 0))
			return f
		}
		f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Closure.Nbody, 0))
		return f

	case OCOMPLIT:
		ptrlit = n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype] != 0
		if fmtmode == FErr {
			if n.Right != nil && n.Right.Type != nil && n.Implicit == 0 {
				if ptrlit {
					f += fmt.Sprintf("&%v literal", Tconv(n.Right.Type.Type, 0))
					return f
				} else {
					f += fmt.Sprintf("%v literal", Tconv(n.Right.Type, 0))
					return f
				}
			}

			f += "composite literal"
			return f
		}

		if fmtmode == FExp && ptrlit {
			// typecheck has overwritten OIND by OTYPE with pointer type.
			f += fmt.Sprintf("(&%v{ %v })", Tconv(n.Right.Type.Type, 0), Hconv(n.List, obj.FmtComma))
			return f
		}

		f += fmt.Sprintf("(%v{ %v })", Nconv(n.Right, 0), Hconv(n.List, obj.FmtComma))
		return f

	case OPTRLIT:
		if fmtmode == FExp && n.Left.Implicit != 0 {
			f += fmt.Sprintf("%v", Nconv(n.Left, 0))
			return f
		}
		f += fmt.Sprintf("&%v", Nconv(n.Left, 0))
		return f

	case OSTRUCTLIT:
		if fmtmode == FExp { // requires special handling of field names
			if n.Implicit != 0 {
				f += "{"
			} else {
				f += fmt.Sprintf("(%v{", Tconv(n.Type, 0))
			}
			for l = n.List; l != nil; l = l.Next {
				f += fmt.Sprintf(" %v:%v", Sconv(l.N.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(l.N.Right, 0))

				if l.Next != nil {
					f += ","
				} else {
					f += " "
				}
			}

			if n.Implicit == 0 {
				f += "})"
				return f
			}
			f += "}"
			return f
		}
		fallthrough

		// fallthrough

	case OARRAYLIT,
		OMAPLIT:
		if fmtmode == FErr {
			f += fmt.Sprintf("%v literal", Tconv(n.Type, 0))
			return f
		}
		if fmtmode == FExp && n.Implicit != 0 {
			f += fmt.Sprintf("{ %v }", Hconv(n.List, obj.FmtComma))
			return f
		}
		f += fmt.Sprintf("(%v{ %v })", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
		return f

	case OKEY:
		if n.Left != nil && n.Right != nil {
			if fmtmode == FExp && n.Left.Type != nil && n.Left.Type.Etype == TFIELD {
				// requires special handling of field names
				f += fmt.Sprintf("%v:%v", Sconv(n.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(n.Right, 0))
				return f
			} else {
				f += fmt.Sprintf("%v:%v", Nconv(n.Left, 0), Nconv(n.Right, 0))
				return f
			}
		}

		if n.Left == nil && n.Right != nil {
			f += fmt.Sprintf(":%v", Nconv(n.Right, 0))
			return f
		}
		if n.Left != nil && n.Right == nil {
			f += fmt.Sprintf("%v:", Nconv(n.Left, 0))
			return f
		}
		f += ":"
		return f

	case OXDOT,
		ODOT,
		ODOTPTR,
		ODOTINTER,
		ODOTMETH,
		OCALLPART:
		f += exprfmt(n.Left, nprec)
		if n.Right == nil || n.Right.Sym == nil {
			f += ".<nil>"
			return f
		}
		f += fmt.Sprintf(".%v", Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
		return f

	case ODOTTYPE,
		ODOTTYPE2:
		f += exprfmt(n.Left, nprec)
		if n.Right != nil {
			f += fmt.Sprintf(".(%v)", Nconv(n.Right, 0))
			return f
		}
		f += fmt.Sprintf(".(%v)", Tconv(n.Type, 0))
		return f

	case OINDEX,
		OINDEXMAP,
		OSLICE,
		OSLICESTR,
		OSLICEARR,
		OSLICE3,
		OSLICE3ARR:
		f += exprfmt(n.Left, nprec)
		f += fmt.Sprintf("[%v]", Nconv(n.Right, 0))
		return f

	case OCOPY,
		OCOMPLEX:
		f += fmt.Sprintf("%v(%v, %v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0), Nconv(n.Right, 0))
		return f

	case OCONV,
		OCONVIFACE,
		OCONVNOP,
		OARRAYBYTESTR,
		OARRAYRUNESTR,
		OSTRARRAYBYTE,
		OSTRARRAYRUNE,
		ORUNESTR:
		if n.Type == nil || n.Type.Sym == nil {
			f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
			return f
		}
		if n.Left != nil {
			f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
			return f
		}
		f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
		return f

	case OREAL,
		OIMAG,
		OAPPEND,
		OCAP,
		OCLOSE,
		ODELETE,
		OLEN,
		OMAKE,
		ONEW,
		OPANIC,
		ORECOVER,
		OPRINT,
		OPRINTN:
		if n.Left != nil {
			f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0))
			return f
		}
		if n.Isddd != 0 {
			f += fmt.Sprintf("%v(%v...)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
			return f
		}
		f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
		return f

	case OCALL,
		OCALLFUNC,
		OCALLINTER,
		OCALLMETH:
		f += exprfmt(n.Left, nprec)
		if n.Isddd != 0 {
			f += fmt.Sprintf("(%v...)", Hconv(n.List, obj.FmtComma))
			return f
		}
		f += fmt.Sprintf("(%v)", Hconv(n.List, obj.FmtComma))
		return f

	case OMAKEMAP,
		OMAKECHAN,
		OMAKESLICE:
		if n.List != nil { // pre-typecheck
			f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
			return f
		}
		if n.Right != nil {
			f += fmt.Sprintf("make(%v, %v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0), Nconv(n.Right, 0))
			return f
		}
		if n.Left != nil {
			f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
			return f
		}
		f += fmt.Sprintf("make(%v)", Tconv(n.Type, 0))
		return f

		// Unary
	case OPLUS,
		OMINUS,
		OADDR,
		OCOM,
		OIND,
		ONOT,
		ORECV:
		if n.Left.Op == n.Op {
			f += fmt.Sprintf("%v ", Oconv(int(n.Op), obj.FmtSharp))
		} else {
			f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
		}
		f += exprfmt(n.Left, nprec+1)
		return f

		// Binary
	case OADD,
		OAND,
		OANDAND,
		OANDNOT,
		ODIV,
		OEQ,
		OGE,
		OGT,
		OLE,
		OLT,
		OLSH,
		OMOD,
		OMUL,
		ONE,
		OOR,
		OOROR,
		ORSH,
		OSEND,
		OSUB,
		OXOR:
		f += exprfmt(n.Left, nprec)

		f += fmt.Sprintf(" %v ", Oconv(int(n.Op), obj.FmtSharp))
		f += exprfmt(n.Right, nprec+1)
		return f

	case OADDSTR:
		for l = n.List; l != nil; l = l.Next {
			if l != n.List {
				f += fmt.Sprintf(" + ")
			}
			f += exprfmt(l.N, nprec)
		}

		return f

	case OCMPSTR,
		OCMPIFACE:
		f += exprfmt(n.Left, nprec)
		f += fmt.Sprintf(" %v ", Oconv(int(n.Etype), obj.FmtSharp))
		f += exprfmt(n.Right, nprec+1)
		return f
	}

	f += fmt.Sprintf("<node %v>", Oconv(int(n.Op), 0))
	return f
}

func nodefmt(n *Node, flag int) string {
	var f string

	var t *Type

	t = n.Type

	// we almost always want the original, except in export mode for literals
	// this saves the importer some work, and avoids us having to redo some
	// special casing for package unsafe
	if (fmtmode != FExp || n.Op != OLITERAL) && n.Orig != nil {
		n = n.Orig
	}

	if flag&obj.FmtLong != 0 /*untyped*/ && t != nil {
		if t.Etype == TNIL {
			f += fmt.Sprintf("nil")
			return f
		} else {
			f += fmt.Sprintf("%v (type %v)", Nconv(n, 0), Tconv(t, 0))
			return f
		}
	}

	// TODO inlining produces expressions with ninits. we can't print these yet.

	if opprec[n.Op] < 0 {
		return stmtfmt(n)
	}

	f += exprfmt(n, 0)
	return f
}

var dumpdepth int

func indent(s string) string {
	return s + "\n" + strings.Repeat(".   ", dumpdepth)
}

func nodedump(n *Node, flag int) string {
	var fp string

	var recur bool

	if n == nil {
		return fp
	}

	recur = flag&obj.FmtShort == 0 /*untyped*/

	if recur {
		fp = indent(fp)
		if dumpdepth > 10 {
			fp += "..."
			return fp
		}

		if n.Ninit != nil {
			fp += fmt.Sprintf("%v-init%v", Oconv(int(n.Op), 0), Hconv(n.Ninit, 0))
			fp = indent(fp)
		}
	}

	//	fmtprint(fp, "[%p]", n);

	switch n.Op {
	default:
		fp += fmt.Sprintf("%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))

	case OREGISTER,
		OINDREG:
		fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Ctxt.Rconv(int(n.Val.U.Reg)), Jconv(n, 0))

	case OLITERAL:
		fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Vconv(&n.Val, 0), Jconv(n, 0))

	case ONAME,
		ONONAME:
		if n.Sym != nil {
			fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Sconv(n.Sym, 0), Jconv(n, 0))
		} else {
			fp += fmt.Sprintf("%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))
		}
		if recur && n.Type == nil && n.Ntype != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-ntype%v", Oconv(int(n.Op), 0), Nconv(n.Ntype, 0))
		}

	case OASOP:
		fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Oconv(int(n.Etype), 0), Jconv(n, 0))

	case OTYPE:
		fp += fmt.Sprintf("%v %v%v type=%v", Oconv(int(n.Op), 0), Sconv(n.Sym, 0), Jconv(n, 0), Tconv(n.Type, 0))
		if recur && n.Type == nil && n.Ntype != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-ntype%v", Oconv(int(n.Op), 0), Nconv(n.Ntype, 0))
		}
	}

	if n.Sym != nil && n.Op != ONAME {
		fp += fmt.Sprintf(" %v G%d", Sconv(n.Sym, 0), n.Vargen)
	}

	if n.Type != nil {
		fp += fmt.Sprintf(" %v", Tconv(n.Type, 0))
	}

	if recur {
		if n.Left != nil {
			fp += fmt.Sprintf("%v", Nconv(n.Left, 0))
		}
		if n.Right != nil {
			fp += fmt.Sprintf("%v", Nconv(n.Right, 0))
		}
		if n.List != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-list%v", Oconv(int(n.Op), 0), Hconv(n.List, 0))
		}

		if n.Rlist != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-rlist%v", Oconv(int(n.Op), 0), Hconv(n.Rlist, 0))
		}

		if n.Ntest != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-test%v", Oconv(int(n.Op), 0), Nconv(n.Ntest, 0))
		}

		if n.Nbody != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-body%v", Oconv(int(n.Op), 0), Hconv(n.Nbody, 0))
		}

		if n.Nelse != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-else%v", Oconv(int(n.Op), 0), Hconv(n.Nelse, 0))
		}

		if n.Nincr != nil {
			fp = indent(fp)
			fp += fmt.Sprintf("%v-incr%v", Oconv(int(n.Op), 0), Nconv(n.Nincr, 0))
		}
	}

	return fp
}

// Fmt "%S": syms
// Flags:  "%hS" suppresses qualifying with package
func Sconv(s *Sym, flag int) string {
	var fp string

	var r int
	var sm int
	var sf int

	if flag&obj.FmtLong != 0 /*untyped*/ {
		panic("linksymfmt")
	}

	if s == nil {
		fp += "<S>"
		return fp
	}

	if s.Name == "_" {
		fp += "_"
		return fp
	}

	sf = flag
	sm = setfmode(&flag)
	_ = r
	str := symfmt(s, flag)
	flag = sf
	fmtmode = sm
	return str
}

// Fmt "%T": types.
// Flags: 'l' print definition, not name
//	  'h' omit 'func' and receiver from function types, short type names
//	  'u' package name, not prefix (FTypeId mode, sticky)
func Tconv(t *Type, flag int) string {
	var fp string

	var r int
	var sm int
	var sf int

	if t == nil {
		fp += "<T>"
		return fp
	}

	if t.Trecur > 4 {
		fp += "<...>"
		return fp
	}

	t.Trecur++
	sf = flag
	sm = setfmode(&flag)

	if fmtmode == FTypeId && (sf&obj.FmtUnsigned != 0) {
		fmtpkgpfx++
	}
	if fmtpkgpfx != 0 {
		flag |= obj.FmtUnsigned
	}

	_ = r
	str := typefmt(t, flag)

	if fmtmode == FTypeId && (sf&obj.FmtUnsigned != 0) {
		fmtpkgpfx--
	}

	flag = sf
	fmtmode = sm
	t.Trecur--
	return str
}

// Fmt '%N': Nodes.
// Flags: 'l' suffix with "(type %T)" where possible
//	  '+h' in debug mode, don't recurse, no multiline output
func Nconv(n *Node, flag int) string {
	var fp string

	var r int
	var sm int
	var sf int

	if n == nil {
		fp += "<N>"
		return fp
	}
	sf = flag
	sm = setfmode(&flag)

	_ = r
	var str string
	switch fmtmode {
	case FErr,
		FExp:
		str = nodefmt(n, flag)

	case FDbg:
		dumpdepth++
		str = nodedump(n, flag)
		dumpdepth--

	default:
		Fatal("unhandled %%N mode")
	}

	flag = sf
	fmtmode = sm
	return str
}

// Fmt '%H': NodeList.
// Flags: all those of %N plus ',': separate with comma's instead of semicolons.
func Hconv(l *NodeList, flag int) string {
	var fp string

	var r int
	var sm int
	var sf int
	var sep string

	if l == nil && fmtmode == FDbg {
		fp += "<nil>"
		return fp
	}

	sf = flag
	sm = setfmode(&flag)
	_ = r
	sep = "; "
	if fmtmode == FDbg {
		sep = "\n"
	} else if flag&obj.FmtComma != 0 /*untyped*/ {
		sep = ", "
	}

	for ; l != nil; l = l.Next {
		fp += fmt.Sprintf("%v", Nconv(l.N, 0))
		if l.Next != nil {
			fp += sep
		}
	}

	flag = sf
	fmtmode = sm
	return fp
}

func dumplist(s string, l *NodeList) {
	fmt.Printf("%s%v\n", s, Hconv(l, obj.FmtSign))
}

func Dump(s string, n *Node) {
	fmt.Printf("%s [%p]%v\n", s, n, Nconv(n, obj.FmtSign))
}