func (x *hclLex) createErr(msg string) {
	x.err = fmt.Errorf("Line %d, column %d: %s", x.line, x.col, msg)
}
createErr records the given error
package hcl
import (
	"bytes"
	"fmt"
	"strconv"
	"unicode"
	"unicode/utf8"
)
const lexEOF = 0
type hclLex struct {
	Input string
	lastNumber        bool
	pos               int
	width             int
	col, line         int
	lastCol, lastLine int
	err               error
}
func (x *hclLex) Lex(yylval *hclSymType) int {
	for {
		c := x.next()
		if c == lexEOF {
			return lexEOF
		}
		if unicode.IsSpace(c) {
			x.lastNumber = false
			continue
		}
		switch c {
		case '#':
			fallthrough
		case '/':
			if !x.consumeComment(c) {
				return lexEOF
			}
			continue
		}
		if c >= '0' && c <= '9' {
			x.lastNumber = true
			x.backup()
			return x.lexNumber(yylval)
		}
		if x.lastNumber {
			switch c {
			case 'e':
				fallthrough
			case 'E':
				switch x.next() {
				case '+':
					return EPLUS
				case '-':
					return EMINUS
				default:
					x.backup()
					return EPLUS
				}
			}
		}
		x.lastNumber = false
		switch c {
		case '.':
			return PERIOD
		case '-':
			return MINUS
		case ',':
			return x.lexComma()
		case '=':
			return EQUAL
		case '[':
			return LEFTBRACKET
		case ']':
			return RIGHTBRACKET
		case '{':
			return LEFTBRACE
		case '}':
			return RIGHTBRACE
		case '"':
			return x.lexString(yylval)
		case '<':
			return x.lexHeredoc(yylval)
		default:
			x.backup()
			return x.lexId(yylval)
		}
	}
}
func (x *hclLex) consumeComment(c rune) bool {
	single := c == '#'
	if !single {
		c = x.next()
		if c != '/' && c != '*' {
			x.backup()
			x.createErr(fmt.Sprintf("comment expected, got '%c'", c))
			return false
		}
		single = c == '/'
	}
	nested := 1
	for {
		c = x.next()
		if c == lexEOF {
			x.backup()
			return true
		}
		if single {
			if c == '\n' {
				return true
			}
			continue
		}
		switch c {
		case '/':
			c = x.next()
			if c == '*' {
				nested++
			} else {
				x.backup()
			}
		case '*':
			c = x.next()
			if c == '/' {
				nested--
			} else {
				x.backup()
			}
		default:
		}
		if nested == 0 {
			return true
		}
	}
}
func (x *hclLex) lexComma() int {
	for {
		c := x.peek()
		if unicode.IsSpace(c) {
			x.next()
			continue
		}
		if c == ']' {
			return COMMAEND
		}
		break
	}
	return COMMA
}
func (x *hclLex) lexId(yylval *hclSymType) int {
	var b bytes.Buffer
	first := true
	for {
		c := x.next()
		if c == lexEOF {
			break
		}
		if !unicode.IsDigit(c) && !unicode.IsLetter(c) &&
			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
		}
	}
	yylval.str = b.String()
	switch yylval.str {
	case "true":
		yylval.b = true
		return BOOL
	case "false":
		yylval.b = false
		return BOOL
	}
	return IDENTIFIER
}
func (x *hclLex) lexHeredoc(yylval *hclSymType) int {
	if x.next() != '<' {
		x.createErr("Heredoc must start with <<")
		return lexEOF
	}
	var buf bytes.Buffer
	for {
		c := x.next()
		if c == lexEOF {
			return lexEOF
		}
		if c == '\n' {
			break
		}
		if _, err := buf.WriteRune(c); err != nil {
			return lexEOF
		}
	}
	marker := buf.String()
	if marker == "" {
		x.createErr("Heredoc must have a marker, e.g. <<FOO")
		return lexEOF
	}
	check := true
	buf.Reset()
	for {
		c := x.next()
		if check {
			check = false
			var cs []rune
			for _, r := range marker {
				if r != c {
					break
				}
				cs = append(cs, c)
				c = x.next()
			}
			if len(cs) == len(marker) {
				break
			}
			if len(cs) > 0 {
				for _, c := range cs {
					if _, err := buf.WriteRune(c); err != nil {
						return lexEOF
					}
				}
			}
		}
		if c == lexEOF {
			return lexEOF
		}
		if c == '\n' {
			check = true
		}
		if _, err := buf.WriteRune(c); err != nil {
			return lexEOF
		}
	}
	yylval.str = buf.String()
	return STRING
}
func (x *hclLex) lexNumber(yylval *hclSymType) 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
}
func (x *hclLex) lexString(yylval *hclSymType) int {
	braces := 0
	var b bytes.Buffer
	for {
		c := x.next()
		if c == lexEOF {
			break
		}
		if c == '"' && braces == 0 {
			break
		}
		if c == '\n' {
			x.createErr(fmt.Sprintf("Newline before string closed"))
			return lexEOF
		}
		if c == '\\' {
			n := x.next()
			switch n {
			case '"':
				c = n
			case 'n':
				c = '\n'
			case '\\':
				c = n
			default:
				x.backup()
			}
		}
		if braces == 0 && c == '$' && x.peek() == '{' {
			braces += 1
			if _, err := b.WriteRune(c); err != nil {
				return lexEOF
			}
			c = x.next()
		} else if braces > 0 && c == '{' {
			braces += 1
		}
		if braces > 0 && c == '}' {
			braces -= 1
		}
		if _, err := b.WriteRune(c); err != nil {
			return lexEOF
		}
	}
	yylval.str = b.String()
	return STRING
}
func (x *hclLex) 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
}
func (x *hclLex) peek() rune {
	r := x.next()
	x.backup()
	return r
}
func (x *hclLex) backup() {
	x.col -= 1
	x.pos -= x.width
}