Change to go1.6.1 and vendoring

vendor/github.com/yudai/hcl/json/lex.go

@@ -0,0 +1,256 @@
+package json
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"unicode"
+	"unicode/utf8"
+)
+
+//go:generate go tool yacc -p "json" parse.y
+
+// This marks the end of the lexer
+const lexEOF = 0
+
+// The parser uses the type <prefix>Lex as a lexer.  It must provide
+// the methods Lex(*<prefix>SymType) int and Error(string).
+type jsonLex struct {
+	Input string
+
+	pos       int
+	width     int
+	col, line int
+	err       error
+}
+
+// The parser calls this method to get each new token.
+func (x *jsonLex) Lex(yylval *jsonSymType) int {
+	for {
+		c := x.next()
+		if c == lexEOF {
+			return lexEOF
+		}
+
+		// Ignore all whitespace except a newline which we handle
+		// specially later.
+		if unicode.IsSpace(c) {
+			continue
+		}
+
+		// If it is a number, lex the number
+		if c >= '0' && c <= '9' {
+			x.backup()
+			return x.lexNumber(yylval)
+		}
+
+		switch c {
+		case 'e':
+			fallthrough
+		case 'E':
+			switch x.next() {
+			case '+':
+				return EPLUS
+			case '-':
+				return EMINUS
+			default:
+				x.backup()
+				return EPLUS
+			}
+		case '.':
+			return PERIOD
+		case '-':
+			return MINUS
+		case ':':
+			return COLON
+		case ',':
+			return COMMA
+		case '[':
+			return LEFTBRACKET
+		case ']':
+			return RIGHTBRACKET
+		case '{':
+			return LEFTBRACE
+		case '}':
+			return RIGHTBRACE
+		case '"':
+			return x.lexString(yylval)
+		default:
+			x.backup()
+			return x.lexId(yylval)
+		}
+	}
+}
+
+// lexId lexes an identifier
+func (x *jsonLex) lexId(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	first := true
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if !unicode.IsDigit(c) && !unicode.IsLetter(c) && c != '_' && c != '-' {
+			x.backup()
+
+			if first {
+				x.createErr("Invalid identifier")
+				return lexEOF
+			}
+
+			break
+		}
+
+		first = false
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	switch v := b.String(); v {
+	case "true":
+		return TRUE
+	case "false":
+		return FALSE
+	case "null":
+		return NULL
+	default:
+		x.createErr(fmt.Sprintf("Invalid identifier: %s", v))
+		return lexEOF
+	}
+}
+
+// lexNumber lexes out a number
+func (x *jsonLex) lexNumber(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	gotPeriod := false
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		if c == '.' {
+			if gotPeriod {
+				x.backup()
+				break
+			}
+
+			gotPeriod = true
+		} else if c < '0' || c > '9' {
+			x.backup()
+			break
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			x.createErr(fmt.Sprintf("Internal error: %s", err))
+			return lexEOF
+		}
+	}
+
+	if !gotPeriod {
+		v, err := strconv.ParseInt(b.String(), 0, 0)
+		if err != nil {
+			x.createErr(fmt.Sprintf("Expected number: %s", err))
+			return lexEOF
+		}
+
+		yylval.num = int(v)
+		return NUMBER
+	}
+
+	f, err := strconv.ParseFloat(b.String(), 64)
+	if err != nil {
+		x.createErr(fmt.Sprintf("Expected float: %s", err))
+		return lexEOF
+	}
+
+	yylval.f = float64(f)
+	return FLOAT
+}
+
+// lexString extracts a string from the input
+func (x *jsonLex) lexString(yylval *jsonSymType) int {
+	var b bytes.Buffer
+	for {
+		c := x.next()
+		if c == lexEOF {
+			break
+		}
+
+		// String end
+		if c == '"' {
+			break
+		}
+
+		// If we're escaping a quote, then escape the quote
+		if c == '\\' {
+			n := x.next()
+			switch n {
+			case '"':
+				c = n
+			case 'n':
+				c = '\n'
+			case '\\':
+				c = n
+			default:
+				x.backup()
+			}
+		}
+
+		if _, err := b.WriteRune(c); err != nil {
+			return lexEOF
+		}
+	}
+
+	yylval.str = b.String()
+	return STRING
+}
+
+// Return the next rune for the lexer.
+func (x *jsonLex) next() rune {
+	if int(x.pos) >= len(x.Input) {
+		x.width = 0
+		return lexEOF
+	}
+
+	r, w := utf8.DecodeRuneInString(x.Input[x.pos:])
+	x.width = w
+	x.pos += x.width
+
+	x.col += 1
+	if x.line == 0 {
+		x.line = 1
+	}
+	if r == '\n' {
+		x.line += 1
+		x.col = 0
+	}
+
+	return r
+}
+
+// peek returns but does not consume the next rune in the input
+func (x *jsonLex) peek() rune {
+	r := x.next()
+	x.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per next.
+func (x *jsonLex) backup() {
+	x.col -= 1
+	x.pos -= x.width
+}
+
+// createErr records the given error
+func (x *jsonLex) createErr(msg string) {
+	x.err = fmt.Errorf("Line %d, column %d: %s", x.line, x.col, msg)
+}
+
+// The parser calls this method on a parse error.
+func (x *jsonLex) Error(s string) {
+	x.createErr(s)
+}

vendor/github.com/yudai/hcl/json/parse.go

@@ -0,0 +1,40 @@
+package json
+
+import (
+	"sync"
+
+	"github.com/yudai/hcl/hcl"
+	"github.com/hashicorp/go-multierror"
+)
+
+// jsonErrors are the errors built up from parsing. These should not
+// be accessed directly.
+var jsonErrors []error
+var jsonLock sync.Mutex
+var jsonResult *hcl.Object
+
+// Parse parses the given string and returns the result.
+func Parse(v string) (*hcl.Object, error) {
+	jsonLock.Lock()
+	defer jsonLock.Unlock()
+	jsonErrors = nil
+	jsonResult = nil
+
+	// Parse
+	lex := &jsonLex{Input: v}
+	jsonParse(lex)
+
+	// If we have an error in the lexer itself, return it
+	if lex.err != nil {
+		return nil, lex.err
+	}
+
+	// Build up the errors
+	var err error
+	if len(jsonErrors) > 0 {
+		err = &multierror.Error{Errors: jsonErrors}
+		jsonResult = nil
+	}
+
+	return jsonResult, err
+}

vendor/github.com/yudai/hcl/json/parse.y

@@ -0,0 +1,210 @@
+// This is the yacc input for creating the parser for HCL JSON.
+
+%{
+package json
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/hashicorp/hcl/hcl"
+)
+
+%}
+
+%union {
+	f        float64
+	num      int
+	str      string
+	obj      *hcl.Object
+	objlist  []*hcl.Object
+}
+
+%type	<f> float
+%type	<num> int
+%type	<obj> number object pair value
+%type	<objlist> array elements members
+%type	<str> exp
+
+%token  <f> FLOAT
+%token  <num> NUMBER
+%token  <str> COLON COMMA IDENTIFIER EQUAL NEWLINE STRING
+%token  <str> LEFTBRACE RIGHTBRACE LEFTBRACKET RIGHTBRACKET
+%token  <str> TRUE FALSE NULL MINUS PERIOD EPLUS EMINUS
+
+%%
+
+top:
+	object
+	{
+		jsonResult = $1
+	}
+
+object:
+	LEFTBRACE members RIGHTBRACE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeObject,
+			Value: hcl.ObjectList($2).Flat(),
+		}
+	}
+|	LEFTBRACE RIGHTBRACE
+	{
+		$$ = &hcl.Object{Type: hcl.ValueTypeObject}
+	}
+
+members:
+	pair
+	{
+		$$ = []*hcl.Object{$1}
+	}
+|	members COMMA pair
+	{
+		$$ = append($1, $3)
+	}
+
+pair:
+	STRING COLON value
+	{
+		$3.Key = $1
+		$$ = $3
+	}
+
+value:
+	STRING
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeString,
+			Value: $1,
+		}
+	}
+|	number
+	{
+		$$ = $1
+	}
+|	object
+	{
+		$$ = $1
+	}
+|	array
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeList,
+			Value: $1,
+		}
+	}
+|	TRUE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeBool,
+			Value: true,
+		}
+	}
+|	FALSE
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeBool,
+			Value: false,
+		}
+	}
+|	NULL
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeNil,
+			Value: nil,
+		}
+	}
+
+array:
+	LEFTBRACKET RIGHTBRACKET
+	{
+		$$ = nil
+	}
+|	LEFTBRACKET elements RIGHTBRACKET
+	{
+		$$ = $2
+	}
+
+elements:
+	value
+	{
+		$$ = []*hcl.Object{$1}
+	}
+|	elements COMMA value
+	{
+		$$ = append($1, $3)
+	}
+
+number:
+	int
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeInt,
+			Value: $1,
+		}
+	}
+|	float
+	{
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: $1,
+		}
+	}
+|   int exp
+    {
+		fs := fmt.Sprintf("%d%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: f,
+		}
+    }
+|   float exp
+    {
+		fs := fmt.Sprintf("%f%s", $1, $2)
+		f, err := strconv.ParseFloat(fs, 64)
+		if err != nil {
+			panic(err)
+		}
+
+		$$ = &hcl.Object{
+			Type:  hcl.ValueTypeFloat,
+			Value: f,
+		}
+    }
+
+int:
+	MINUS int
+	{
+		$$ = $2 * -1
+	}
+|	NUMBER
+	{
+		$$ = $1
+	}
+
+float:
+	 MINUS float
+	{
+		$$ = $2 * -1
+	}
+|	FLOAT
+	{
+		$$ = $1
+	}
+
+exp:
+    EPLUS NUMBER
+    {
+        $$ = "e" + strconv.FormatInt(int64($2), 10)
+    }
+|   EMINUS NUMBER
+    {
+        $$ = "e-" + strconv.FormatInt(int64($2), 10)
+    }
+
+%%

vendor/github.com/yudai/hcl/json/y.go

@@ -0,0 +1,699 @@
+//line parse.y:3
+package json
+
+import __yyfmt__ "fmt"
+
+//line parse.y:5
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/yudai/hcl/hcl"
+)
+
+//line parse.y:15
+type jsonSymType struct {
+	yys     int
+	f       float64
+	num     int
+	str     string
+	obj     *hcl.Object
+	objlist []*hcl.Object
+}
+
+const FLOAT = 57346
+const NUMBER = 57347
+const COLON = 57348
+const COMMA = 57349
+const IDENTIFIER = 57350
+const EQUAL = 57351
+const NEWLINE = 57352
+const STRING = 57353
+const LEFTBRACE = 57354
+const RIGHTBRACE = 57355
+const LEFTBRACKET = 57356
+const RIGHTBRACKET = 57357
+const TRUE = 57358
+const FALSE = 57359
+const NULL = 57360
+const MINUS = 57361
+const PERIOD = 57362
+const EPLUS = 57363
+const EMINUS = 57364
+
+var jsonToknames = [...]string{
+	"$end",
+	"error",
+	"$unk",
+	"FLOAT",
+	"NUMBER",
+	"COLON",
+	"COMMA",
+	"IDENTIFIER",
+	"EQUAL",
+	"NEWLINE",
+	"STRING",
+	"LEFTBRACE",
+	"RIGHTBRACE",
+	"LEFTBRACKET",
+	"RIGHTBRACKET",
+	"TRUE",
+	"FALSE",
+	"NULL",
+	"MINUS",
+	"PERIOD",
+	"EPLUS",
+	"EMINUS",
+}
+var jsonStatenames = [...]string{}
+
+const jsonEofCode = 1
+const jsonErrCode = 2
+const jsonMaxDepth = 200
+
+//line parse.y:210
+
+//line yacctab:1
+var jsonExca = [...]int{
+	-1, 1,
+	1, -1,
+	-2, 0,
+}
+
+const jsonNprod = 28
+const jsonPrivate = 57344
+
+var jsonTokenNames []string
+var jsonStates []string
+
+const jsonLast = 53
+
+var jsonAct = [...]int{
+
+	12, 25, 24, 3, 20, 27, 28, 7, 13, 3,
+	21, 22, 30, 17, 18, 19, 23, 25, 24, 26,
+	25, 24, 36, 32, 13, 3, 10, 22, 33, 17,
+	18, 19, 23, 35, 34, 23, 38, 9, 7, 39,
+	5, 29, 6, 8, 37, 15, 2, 1, 4, 31,
+	16, 14, 11,
+}
+var jsonPact = [...]int{
+
+	-9, -1000, -1000, 27, 30, -1000, -1000, 20, -1000, -4,
+	13, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+	-16, -16, -3, 16, -1000, -1000, -1000, 28, 17, -1000,
+	-1000, 29, -1000, -1000, -1000, -1000, -1000, -1000, 13, -1000,
+}
+var jsonPgo = [...]int{
+
+	0, 10, 4, 51, 45, 42, 0, 50, 49, 48,
+	19, 47,
+}
+var jsonR1 = [...]int{
+
+	0, 11, 4, 4, 9, 9, 5, 6, 6, 6,
+	6, 6, 6, 6, 7, 7, 8, 8, 3, 3,
+	3, 3, 2, 2, 1, 1, 10, 10,
+}
+var jsonR2 = [...]int{
+
+	0, 1, 3, 2, 1, 3, 3, 1, 1, 1,
+	1, 1, 1, 1, 2, 3, 1, 3, 1, 1,
+	2, 2, 2, 1, 2, 1, 2, 2,
+}
+var jsonChk = [...]int{
+
+	-1000, -11, -4, 12, -9, 13, -5, 11, 13, 7,
+	6, -5, -6, 11, -3, -4, -7, 16, 17, 18,
+	-2, -1, 14, 19, 5, 4, -10, 21, 22, -10,
+	15, -8, -6, -2, -1, 5, 5, 15, 7, -6,
+}
+var jsonDef = [...]int{
+
+	0, -2, 1, 0, 0, 3, 4, 0, 2, 0,
+	0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+	18, 19, 0, 0, 23, 25, 20, 0, 0, 21,
+	14, 0, 16, 22, 24, 26, 27, 15, 0, 17,
+}
+var jsonTok1 = [...]int{
+
+	1,
+}
+var jsonTok2 = [...]int{
+
+	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+	22,
+}
+var jsonTok3 = [...]int{
+	0,
+}
+
+var jsonErrorMessages = [...]struct {
+	state int
+	token int
+	msg   string
+}{}
+
+//line yaccpar:1
+
+/*	parser for yacc output	*/
+
+var (
+	jsonDebug        = 0
+	jsonErrorVerbose = false
+)
+
+type jsonLexer interface {
+	Lex(lval *jsonSymType) int
+	Error(s string)
+}
+
+type jsonParser interface {
+	Parse(jsonLexer) int
+	Lookahead() int
+}
+
+type jsonParserImpl struct {
+	lookahead func() int
+}
+
+func (p *jsonParserImpl) Lookahead() int {
+	return p.lookahead()
+}
+
+func jsonNewParser() jsonParser {
+	p := &jsonParserImpl{
+		lookahead: func() int { return -1 },
+	}
+	return p
+}
+
+const jsonFlag = -1000
+
+func jsonTokname(c int) string {
+	if c >= 1 && c-1 < len(jsonToknames) {
+		if jsonToknames[c-1] != "" {
+			return jsonToknames[c-1]
+		}
+	}
+	return __yyfmt__.Sprintf("tok-%v", c)
+}
+
+func jsonStatname(s int) string {
+	if s >= 0 && s < len(jsonStatenames) {
+		if jsonStatenames[s] != "" {
+			return jsonStatenames[s]
+		}
+	}
+	return __yyfmt__.Sprintf("state-%v", s)
+}
+
+func jsonErrorMessage(state, lookAhead int) string {
+	const TOKSTART = 4
+
+	if !jsonErrorVerbose {
+		return "syntax error"
+	}
+
+	for _, e := range jsonErrorMessages {
+		if e.state == state && e.token == lookAhead {
+			return "syntax error: " + e.msg
+		}
+	}
+
+	res := "syntax error: unexpected " + jsonTokname(lookAhead)
+
+	// To match Bison, suggest at most four expected tokens.
+	expected := make([]int, 0, 4)
+
+	// Look for shiftable tokens.
+	base := jsonPact[state]
+	for tok := TOKSTART; tok-1 < len(jsonToknames); tok++ {
+		if n := base + tok; n >= 0 && n < jsonLast && jsonChk[jsonAct[n]] == tok {
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+	}
+
+	if jsonDef[state] == -2 {
+		i := 0
+		for jsonExca[i] != -1 || jsonExca[i+1] != state {
+			i += 2
+		}
+
+		// Look for tokens that we accept or reduce.
+		for i += 2; jsonExca[i] >= 0; i += 2 {
+			tok := jsonExca[i]
+			if tok < TOKSTART || jsonExca[i+1] == 0 {
+				continue
+			}
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+
+		// If the default action is to accept or reduce, give up.
+		if jsonExca[i+1] != 0 {
+			return res
+		}
+	}
+
+	for i, tok := range expected {
+		if i == 0 {
+			res += ", expecting "
+		} else {
+			res += " or "
+		}
+		res += jsonTokname(tok)
+	}
+	return res
+}
+
+func jsonlex1(lex jsonLexer, lval *jsonSymType) (char, token int) {
+	token = 0
+	char = lex.Lex(lval)
+	if char <= 0 {
+		token = jsonTok1[0]
+		goto out
+	}
+	if char < len(jsonTok1) {
+		token = jsonTok1[char]
+		goto out
+	}
+	if char >= jsonPrivate {
+		if char < jsonPrivate+len(jsonTok2) {
+			token = jsonTok2[char-jsonPrivate]
+			goto out
+		}
+	}
+	for i := 0; i < len(jsonTok3); i += 2 {
+		token = jsonTok3[i+0]
+		if token == char {
+			token = jsonTok3[i+1]
+			goto out
+		}
+	}
+
+out:
+	if token == 0 {
+		token = jsonTok2[1] /* unknown char */
+	}
+	if jsonDebug >= 3 {
+		__yyfmt__.Printf("lex %s(%d)\n", jsonTokname(token), uint(char))
+	}
+	return char, token
+}
+
+func jsonParse(jsonlex jsonLexer) int {
+	return jsonNewParser().Parse(jsonlex)
+}
+
+func (jsonrcvr *jsonParserImpl) Parse(jsonlex jsonLexer) int {
+	var jsonn int
+	var jsonlval jsonSymType
+	var jsonVAL jsonSymType
+	var jsonDollar []jsonSymType
+	_ = jsonDollar // silence set and not used
+	jsonS := make([]jsonSymType, jsonMaxDepth)
+
+	Nerrs := 0   /* number of errors */
+	Errflag := 0 /* error recovery flag */
+	jsonstate := 0
+	jsonchar := -1
+	jsontoken := -1 // jsonchar translated into internal numbering
+	jsonrcvr.lookahead = func() int { return jsonchar }
+	defer func() {
+		// Make sure we report no lookahead when not parsing.
+		jsonstate = -1
+		jsonchar = -1
+		jsontoken = -1
+	}()
+	jsonp := -1
+	goto jsonstack
+
+ret0:
+	return 0
+
+ret1:
+	return 1
+
+jsonstack:
+	/* put a state and value onto the stack */
+	if jsonDebug >= 4 {
+		__yyfmt__.Printf("char %v in %v\n", jsonTokname(jsontoken), jsonStatname(jsonstate))
+	}
+
+	jsonp++
+	if jsonp >= len(jsonS) {
+		nyys := make([]jsonSymType, len(jsonS)*2)
+		copy(nyys, jsonS)
+		jsonS = nyys
+	}
+	jsonS[jsonp] = jsonVAL
+	jsonS[jsonp].yys = jsonstate
+
+jsonnewstate:
+	jsonn = jsonPact[jsonstate]
+	if jsonn <= jsonFlag {
+		goto jsondefault /* simple state */
+	}
+	if jsonchar < 0 {
+		jsonchar, jsontoken = jsonlex1(jsonlex, &jsonlval)
+	}
+	jsonn += jsontoken
+	if jsonn < 0 || jsonn >= jsonLast {
+		goto jsondefault
+	}
+	jsonn = jsonAct[jsonn]
+	if jsonChk[jsonn] == jsontoken { /* valid shift */
+		jsonchar = -1
+		jsontoken = -1
+		jsonVAL = jsonlval
+		jsonstate = jsonn
+		if Errflag > 0 {
+			Errflag--
+		}
+		goto jsonstack
+	}
+
+jsondefault:
+	/* default state action */
+	jsonn = jsonDef[jsonstate]
+	if jsonn == -2 {
+		if jsonchar < 0 {
+			jsonchar, jsontoken = jsonlex1(jsonlex, &jsonlval)
+		}
+
+		/* look through exception table */
+		xi := 0
+		for {
+			if jsonExca[xi+0] == -1 && jsonExca[xi+1] == jsonstate {
+				break
+			}
+			xi += 2
+		}
+		for xi += 2; ; xi += 2 {
+			jsonn = jsonExca[xi+0]
+			if jsonn < 0 || jsonn == jsontoken {
+				break
+			}
+		}
+		jsonn = jsonExca[xi+1]
+		if jsonn < 0 {
+			goto ret0
+		}
+	}
+	if jsonn == 0 {
+		/* error ... attempt to resume parsing */
+		switch Errflag {
+		case 0: /* brand new error */
+			jsonlex.Error(jsonErrorMessage(jsonstate, jsontoken))
+			Nerrs++
+			if jsonDebug >= 1 {
+				__yyfmt__.Printf("%s", jsonStatname(jsonstate))
+				__yyfmt__.Printf(" saw %s\n", jsonTokname(jsontoken))
+			}
+			fallthrough
+
+		case 1, 2: /* incompletely recovered error ... try again */
+			Errflag = 3
+
+			/* find a state where "error" is a legal shift action */
+			for jsonp >= 0 {
+				jsonn = jsonPact[jsonS[jsonp].yys] + jsonErrCode
+				if jsonn >= 0 && jsonn < jsonLast {
+					jsonstate = jsonAct[jsonn] /* simulate a shift of "error" */
+					if jsonChk[jsonstate] == jsonErrCode {
+						goto jsonstack
+					}
+				}
+
+				/* the current p has no shift on "error", pop stack */
+				if jsonDebug >= 2 {
+					__yyfmt__.Printf("error recovery pops state %d\n", jsonS[jsonp].yys)
+				}
+				jsonp--
+			}
+			/* there is no state on the stack with an error shift ... abort */
+			goto ret1
+
+		case 3: /* no shift yet; clobber input char */
+			if jsonDebug >= 2 {
+				__yyfmt__.Printf("error recovery discards %s\n", jsonTokname(jsontoken))
+			}
+			if jsontoken == jsonEofCode {
+				goto ret1
+			}
+			jsonchar = -1
+			jsontoken = -1
+			goto jsonnewstate /* try again in the same state */
+		}
+	}
+
+	/* reduction by production jsonn */
+	if jsonDebug >= 2 {
+		__yyfmt__.Printf("reduce %v in:\n\t%v\n", jsonn, jsonStatname(jsonstate))
+	}
+
+	jsonnt := jsonn
+	jsonpt := jsonp
+	_ = jsonpt // guard against "declared and not used"
+
+	jsonp -= jsonR2[jsonn]
+	// jsonp is now the index of $0. Perform the default action. Iff the
+	// reduced production is ε, $1 is possibly out of range.
+	if jsonp+1 >= len(jsonS) {
+		nyys := make([]jsonSymType, len(jsonS)*2)
+		copy(nyys, jsonS)
+		jsonS = nyys
+	}
+	jsonVAL = jsonS[jsonp+1]
+
+	/* consult goto table to find next state */
+	jsonn = jsonR1[jsonn]
+	jsong := jsonPgo[jsonn]
+	jsonj := jsong + jsonS[jsonp].yys + 1
+
+	if jsonj >= jsonLast {
+		jsonstate = jsonAct[jsong]
+	} else {
+		jsonstate = jsonAct[jsonj]
+		if jsonChk[jsonstate] != -jsonn {
+			jsonstate = jsonAct[jsong]
+		}
+	}
+	// dummy call; replaced with literal code
+	switch jsonnt {
+
+	case 1:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:39
+		{
+			jsonResult = jsonDollar[1].obj
+		}
+	case 2:
+		jsonDollar = jsonS[jsonpt-3 : jsonpt+1]
+		//line parse.y:45
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeObject,
+				Value: hcl.ObjectList(jsonDollar[2].objlist).Flat(),
+			}
+		}
+	case 3:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:52
+		{
+			jsonVAL.obj = &hcl.Object{Type: hcl.ValueTypeObject}
+		}
+	case 4:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:58
+		{
+			jsonVAL.objlist = []*hcl.Object{jsonDollar[1].obj}
+		}
+	case 5:
+		jsonDollar = jsonS[jsonpt-3 : jsonpt+1]
+		//line parse.y:62
+		{
+			jsonVAL.objlist = append(jsonDollar[1].objlist, jsonDollar[3].obj)
+		}
+	case 6:
+		jsonDollar = jsonS[jsonpt-3 : jsonpt+1]
+		//line parse.y:68
+		{
+			jsonDollar[3].obj.Key = jsonDollar[1].str
+			jsonVAL.obj = jsonDollar[3].obj
+		}
+	case 7:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:75
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeString,
+				Value: jsonDollar[1].str,
+			}
+		}
+	case 8:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:82
+		{
+			jsonVAL.obj = jsonDollar[1].obj
+		}
+	case 9:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:86
+		{
+			jsonVAL.obj = jsonDollar[1].obj
+		}
+	case 10:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:90
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeList,
+				Value: jsonDollar[1].objlist,
+			}
+		}
+	case 11:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:97
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeBool,
+				Value: true,
+			}
+		}
+	case 12:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:104
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeBool,
+				Value: false,
+			}
+		}
+	case 13:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:111
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeNil,
+				Value: nil,
+			}
+		}
+	case 14:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:120
+		{
+			jsonVAL.objlist = nil
+		}
+	case 15:
+		jsonDollar = jsonS[jsonpt-3 : jsonpt+1]
+		//line parse.y:124
+		{
+			jsonVAL.objlist = jsonDollar[2].objlist
+		}
+	case 16:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:130
+		{
+			jsonVAL.objlist = []*hcl.Object{jsonDollar[1].obj}
+		}
+	case 17:
+		jsonDollar = jsonS[jsonpt-3 : jsonpt+1]
+		//line parse.y:134
+		{
+			jsonVAL.objlist = append(jsonDollar[1].objlist, jsonDollar[3].obj)
+		}
+	case 18:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:140
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeInt,
+				Value: jsonDollar[1].num,
+			}
+		}
+	case 19:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:147
+		{
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeFloat,
+				Value: jsonDollar[1].f,
+			}
+		}
+	case 20:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:154
+		{
+			fs := fmt.Sprintf("%d%s", jsonDollar[1].num, jsonDollar[2].str)
+			f, err := strconv.ParseFloat(fs, 64)
+			if err != nil {
+				panic(err)
+			}
+
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeFloat,
+				Value: f,
+			}
+		}
+	case 21:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:167
+		{
+			fs := fmt.Sprintf("%f%s", jsonDollar[1].f, jsonDollar[2].str)
+			f, err := strconv.ParseFloat(fs, 64)
+			if err != nil {
+				panic(err)
+			}
+
+			jsonVAL.obj = &hcl.Object{
+				Type:  hcl.ValueTypeFloat,
+				Value: f,
+			}
+		}
+	case 22:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:182
+		{
+			jsonVAL.num = jsonDollar[2].num * -1
+		}
+	case 23:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:186
+		{
+			jsonVAL.num = jsonDollar[1].num
+		}
+	case 24:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:192
+		{
+			jsonVAL.f = jsonDollar[2].f * -1
+		}
+	case 25:
+		jsonDollar = jsonS[jsonpt-1 : jsonpt+1]
+		//line parse.y:196
+		{
+			jsonVAL.f = jsonDollar[1].f
+		}
+	case 26:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:202
+		{
+			jsonVAL.str = "e" + strconv.FormatInt(int64(jsonDollar[2].num), 10)
+		}
+	case 27:
+		jsonDollar = jsonS[jsonpt-2 : jsonpt+1]
+		//line parse.y:206
+		{
+			jsonVAL.str = "e-" + strconv.FormatInt(int64(jsonDollar[2].num), 10)
+		}
+	}
+	goto jsonstack /* stack new state and value */
+}