mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-19 09:39:59 +00:00
961c878e0d
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
166 lines
3.0 KiB
Go
166 lines
3.0 KiB
Go
package ini
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"io/ioutil"
|
|
|
|
"github.com/aws/aws-sdk-go/aws/awserr"
|
|
)
|
|
|
|
const (
|
|
// ErrCodeUnableToReadFile is used when a file is failed to be
|
|
// opened or read from.
|
|
ErrCodeUnableToReadFile = "FailedRead"
|
|
)
|
|
|
|
// TokenType represents the various different tokens types
|
|
type TokenType int
|
|
|
|
func (t TokenType) String() string {
|
|
switch t {
|
|
case TokenNone:
|
|
return "none"
|
|
case TokenLit:
|
|
return "literal"
|
|
case TokenSep:
|
|
return "sep"
|
|
case TokenOp:
|
|
return "op"
|
|
case TokenWS:
|
|
return "ws"
|
|
case TokenNL:
|
|
return "newline"
|
|
case TokenComment:
|
|
return "comment"
|
|
case TokenComma:
|
|
return "comma"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// TokenType enums
|
|
const (
|
|
TokenNone = TokenType(iota)
|
|
TokenLit
|
|
TokenSep
|
|
TokenComma
|
|
TokenOp
|
|
TokenWS
|
|
TokenNL
|
|
TokenComment
|
|
)
|
|
|
|
type iniLexer struct{}
|
|
|
|
// Tokenize will return a list of tokens during lexical analysis of the
|
|
// io.Reader.
|
|
func (l *iniLexer) Tokenize(r io.Reader) ([]Token, error) {
|
|
b, err := ioutil.ReadAll(r)
|
|
if err != nil {
|
|
return nil, awserr.New(ErrCodeUnableToReadFile, "unable to read file", err)
|
|
}
|
|
|
|
return l.tokenize(b)
|
|
}
|
|
|
|
func (l *iniLexer) tokenize(b []byte) ([]Token, error) {
|
|
runes := bytes.Runes(b)
|
|
var err error
|
|
n := 0
|
|
tokenAmount := countTokens(runes)
|
|
tokens := make([]Token, tokenAmount)
|
|
count := 0
|
|
|
|
for len(runes) > 0 && count < tokenAmount {
|
|
switch {
|
|
case isWhitespace(runes[0]):
|
|
tokens[count], n, err = newWSToken(runes)
|
|
case isComma(runes[0]):
|
|
tokens[count], n = newCommaToken(), 1
|
|
case isComment(runes):
|
|
tokens[count], n, err = newCommentToken(runes)
|
|
case isNewline(runes):
|
|
tokens[count], n, err = newNewlineToken(runes)
|
|
case isSep(runes):
|
|
tokens[count], n, err = newSepToken(runes)
|
|
case isOp(runes):
|
|
tokens[count], n, err = newOpToken(runes)
|
|
default:
|
|
tokens[count], n, err = newLitToken(runes)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
count++
|
|
|
|
runes = runes[n:]
|
|
}
|
|
|
|
return tokens[:count], nil
|
|
}
|
|
|
|
func countTokens(runes []rune) int {
|
|
count, n := 0, 0
|
|
var err error
|
|
|
|
for len(runes) > 0 {
|
|
switch {
|
|
case isWhitespace(runes[0]):
|
|
_, n, err = newWSToken(runes)
|
|
case isComma(runes[0]):
|
|
_, n = newCommaToken(), 1
|
|
case isComment(runes):
|
|
_, n, err = newCommentToken(runes)
|
|
case isNewline(runes):
|
|
_, n, err = newNewlineToken(runes)
|
|
case isSep(runes):
|
|
_, n, err = newSepToken(runes)
|
|
case isOp(runes):
|
|
_, n, err = newOpToken(runes)
|
|
default:
|
|
_, n, err = newLitToken(runes)
|
|
}
|
|
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
|
|
count++
|
|
runes = runes[n:]
|
|
}
|
|
|
|
return count + 1
|
|
}
|
|
|
|
// Token indicates a metadata about a given value.
|
|
type Token struct {
|
|
t TokenType
|
|
ValueType ValueType
|
|
base int
|
|
raw []rune
|
|
}
|
|
|
|
var emptyValue = Value{}
|
|
|
|
func newToken(t TokenType, raw []rune, v ValueType) Token {
|
|
return Token{
|
|
t: t,
|
|
raw: raw,
|
|
ValueType: v,
|
|
}
|
|
}
|
|
|
|
// Raw return the raw runes that were consumed
|
|
func (tok Token) Raw() []rune {
|
|
return tok.raw
|
|
}
|
|
|
|
// Type returns the token type
|
|
func (tok Token) Type() TokenType {
|
|
return tok.t
|
|
}
|