Source file src/github.com/BurntSushi/toml/parse.go

Documentation: github.com/BurntSushi/toml

     1  package toml
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"strconv"
     7  	"strings"
     8  	"time"
     9  	"unicode/utf8"
    10  
    11  	"github.com/BurntSushi/toml/internal"
    12  )
    13  
    14  type parser struct {
    15  	lx         *lexer
    16  	context    Key      // Full key for the current hash in scope.
    17  	currentKey string   // Base key name for everything except hashes.
    18  	pos        Position // Current position in the TOML file.
    19  	tomlNext   bool
    20  
    21  	ordered []Key // List of keys in the order that they appear in the TOML data.
    22  
    23  	keyInfo   map[string]keyInfo     // Map keyname → info about the TOML key.
    24  	mapping   map[string]interface{} // Map keyname → key value.
    25  	implicits map[string]struct{}    // Record implicit keys (e.g. "key.group.names").
    26  }
    27  
    28  type keyInfo struct {
    29  	pos      Position
    30  	tomlType tomlType
    31  }
    32  
    33  func parse(data string) (p *parser, err error) {
    34  	_, tomlNext := os.LookupEnv("BURNTSUSHI_TOML_110")
    35  
    36  	defer func() {
    37  		if r := recover(); r != nil {
    38  			if pErr, ok := r.(ParseError); ok {
    39  				pErr.input = data
    40  				err = pErr
    41  				return
    42  			}
    43  			panic(r)
    44  		}
    45  	}()
    46  
    47  	// Read over BOM; do this here as the lexer calls utf8.DecodeRuneInString()
    48  	// which mangles stuff. UTF-16 BOM isn't strictly valid, but some tools add
    49  	// it anyway.
    50  	if strings.HasPrefix(data, "\xff\xfe") || strings.HasPrefix(data, "\xfe\xff") { // UTF-16
    51  		data = data[2:]
    52  	} else if strings.HasPrefix(data, "\xef\xbb\xbf") { // UTF-8
    53  		data = data[3:]
    54  	}
    55  
    56  	// Examine first few bytes for NULL bytes; this probably means it's a UTF-16
    57  	// file (second byte in surrogate pair being NULL). Again, do this here to
    58  	// avoid having to deal with UTF-8/16 stuff in the lexer.
    59  	ex := 6
    60  	if len(data) < 6 {
    61  		ex = len(data)
    62  	}
    63  	if i := strings.IndexRune(data[:ex], 0); i > -1 {
    64  		return nil, ParseError{
    65  			Message:  "files cannot contain NULL bytes; probably using UTF-16; TOML files must be UTF-8",
    66  			Position: Position{Line: 1, Start: i, Len: 1},
    67  			Line:     1,
    68  			input:    data,
    69  		}
    70  	}
    71  
    72  	p = &parser{
    73  		keyInfo:   make(map[string]keyInfo),
    74  		mapping:   make(map[string]interface{}),
    75  		lx:        lex(data, tomlNext),
    76  		ordered:   make([]Key, 0),
    77  		implicits: make(map[string]struct{}),
    78  		tomlNext:  tomlNext,
    79  	}
    80  	for {
    81  		item := p.next()
    82  		if item.typ == itemEOF {
    83  			break
    84  		}
    85  		p.topLevel(item)
    86  	}
    87  
    88  	return p, nil
    89  }
    90  
    91  func (p *parser) panicErr(it item, err error) {
    92  	panic(ParseError{
    93  		err:      err,
    94  		Position: it.pos,
    95  		Line:     it.pos.Len,
    96  		LastKey:  p.current(),
    97  	})
    98  }
    99  
   100  func (p *parser) panicItemf(it item, format string, v ...interface{}) {
   101  	panic(ParseError{
   102  		Message:  fmt.Sprintf(format, v...),
   103  		Position: it.pos,
   104  		Line:     it.pos.Len,
   105  		LastKey:  p.current(),
   106  	})
   107  }
   108  
   109  func (p *parser) panicf(format string, v ...interface{}) {
   110  	panic(ParseError{
   111  		Message:  fmt.Sprintf(format, v...),
   112  		Position: p.pos,
   113  		Line:     p.pos.Line,
   114  		LastKey:  p.current(),
   115  	})
   116  }
   117  
   118  func (p *parser) next() item {
   119  	it := p.lx.nextItem()
   120  	//fmt.Printf("ITEM %-18s line %-3d │ %q\n", it.typ, it.pos.Line, it.val)
   121  	if it.typ == itemError {
   122  		if it.err != nil {
   123  			panic(ParseError{
   124  				Position: it.pos,
   125  				Line:     it.pos.Line,
   126  				LastKey:  p.current(),
   127  				err:      it.err,
   128  			})
   129  		}
   130  
   131  		p.panicItemf(it, "%s", it.val)
   132  	}
   133  	return it
   134  }
   135  
   136  func (p *parser) nextPos() item {
   137  	it := p.next()
   138  	p.pos = it.pos
   139  	return it
   140  }
   141  
   142  func (p *parser) bug(format string, v ...interface{}) {
   143  	panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
   144  }
   145  
   146  func (p *parser) expect(typ itemType) item {
   147  	it := p.next()
   148  	p.assertEqual(typ, it.typ)
   149  	return it
   150  }
   151  
   152  func (p *parser) assertEqual(expected, got itemType) {
   153  	if expected != got {
   154  		p.bug("Expected '%s' but got '%s'.", expected, got)
   155  	}
   156  }
   157  
   158  func (p *parser) topLevel(item item) {
   159  	switch item.typ {
   160  	case itemCommentStart: // # ..
   161  		p.expect(itemText)
   162  	case itemTableStart: // [ .. ]
   163  		name := p.nextPos()
   164  
   165  		var key Key
   166  		for ; name.typ != itemTableEnd && name.typ != itemEOF; name = p.next() {
   167  			key = append(key, p.keyString(name))
   168  		}
   169  		p.assertEqual(itemTableEnd, name.typ)
   170  
   171  		p.addContext(key, false)
   172  		p.setType("", tomlHash, item.pos)
   173  		p.ordered = append(p.ordered, key)
   174  	case itemArrayTableStart: // [[ .. ]]
   175  		name := p.nextPos()
   176  
   177  		var key Key
   178  		for ; name.typ != itemArrayTableEnd && name.typ != itemEOF; name = p.next() {
   179  			key = append(key, p.keyString(name))
   180  		}
   181  		p.assertEqual(itemArrayTableEnd, name.typ)
   182  
   183  		p.addContext(key, true)
   184  		p.setType("", tomlArrayHash, item.pos)
   185  		p.ordered = append(p.ordered, key)
   186  	case itemKeyStart: // key = ..
   187  		outerContext := p.context
   188  		/// Read all the key parts (e.g. 'a' and 'b' in 'a.b')
   189  		k := p.nextPos()
   190  		var key Key
   191  		for ; k.typ != itemKeyEnd && k.typ != itemEOF; k = p.next() {
   192  			key = append(key, p.keyString(k))
   193  		}
   194  		p.assertEqual(itemKeyEnd, k.typ)
   195  
   196  		/// The current key is the last part.
   197  		p.currentKey = key[len(key)-1]
   198  
   199  		/// All the other parts (if any) are the context; need to set each part
   200  		/// as implicit.
   201  		context := key[:len(key)-1]
   202  		for i := range context {
   203  			p.addImplicitContext(append(p.context, context[i:i+1]...))
   204  		}
   205  		p.ordered = append(p.ordered, p.context.add(p.currentKey))
   206  
   207  		/// Set value.
   208  		vItem := p.next()
   209  		val, typ := p.value(vItem, false)
   210  		p.set(p.currentKey, val, typ, vItem.pos)
   211  
   212  		/// Remove the context we added (preserving any context from [tbl] lines).
   213  		p.context = outerContext
   214  		p.currentKey = ""
   215  	default:
   216  		p.bug("Unexpected type at top level: %s", item.typ)
   217  	}
   218  }
   219  
   220  // Gets a string for a key (or part of a key in a table name).
   221  func (p *parser) keyString(it item) string {
   222  	switch it.typ {
   223  	case itemText:
   224  		return it.val
   225  	case itemString, itemMultilineString,
   226  		itemRawString, itemRawMultilineString:
   227  		s, _ := p.value(it, false)
   228  		return s.(string)
   229  	default:
   230  		p.bug("Unexpected key type: %s", it.typ)
   231  	}
   232  	panic("unreachable")
   233  }
   234  
   235  var datetimeRepl = strings.NewReplacer(
   236  	"z", "Z",
   237  	"t", "T",
   238  	" ", "T")
   239  
   240  // value translates an expected value from the lexer into a Go value wrapped
   241  // as an empty interface.
   242  func (p *parser) value(it item, parentIsArray bool) (interface{}, tomlType) {
   243  	switch it.typ {
   244  	case itemString:
   245  		return p.replaceEscapes(it, it.val), p.typeOfPrimitive(it)
   246  	case itemMultilineString:
   247  		return p.replaceEscapes(it, p.stripEscapedNewlines(stripFirstNewline(it.val))), p.typeOfPrimitive(it)
   248  	case itemRawString:
   249  		return it.val, p.typeOfPrimitive(it)
   250  	case itemRawMultilineString:
   251  		return stripFirstNewline(it.val), p.typeOfPrimitive(it)
   252  	case itemInteger:
   253  		return p.valueInteger(it)
   254  	case itemFloat:
   255  		return p.valueFloat(it)
   256  	case itemBool:
   257  		switch it.val {
   258  		case "true":
   259  			return true, p.typeOfPrimitive(it)
   260  		case "false":
   261  			return false, p.typeOfPrimitive(it)
   262  		default:
   263  			p.bug("Expected boolean value, but got '%s'.", it.val)
   264  		}
   265  	case itemDatetime:
   266  		return p.valueDatetime(it)
   267  	case itemArray:
   268  		return p.valueArray(it)
   269  	case itemInlineTableStart:
   270  		return p.valueInlineTable(it, parentIsArray)
   271  	default:
   272  		p.bug("Unexpected value type: %s", it.typ)
   273  	}
   274  	panic("unreachable")
   275  }
   276  
   277  func (p *parser) valueInteger(it item) (interface{}, tomlType) {
   278  	if !numUnderscoresOK(it.val) {
   279  		p.panicItemf(it, "Invalid integer %q: underscores must be surrounded by digits", it.val)
   280  	}
   281  	if numHasLeadingZero(it.val) {
   282  		p.panicItemf(it, "Invalid integer %q: cannot have leading zeroes", it.val)
   283  	}
   284  
   285  	num, err := strconv.ParseInt(it.val, 0, 64)
   286  	if err != nil {
   287  		// Distinguish integer values. Normally, it'd be a bug if the lexer
   288  		// provides an invalid integer, but it's possible that the number is
   289  		// out of range of valid values (which the lexer cannot determine).
   290  		// So mark the former as a bug but the latter as a legitimate user
   291  		// error.
   292  		if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrRange {
   293  			p.panicErr(it, errParseRange{i: it.val, size: "int64"})
   294  		} else {
   295  			p.bug("Expected integer value, but got '%s'.", it.val)
   296  		}
   297  	}
   298  	return num, p.typeOfPrimitive(it)
   299  }
   300  
   301  func (p *parser) valueFloat(it item) (interface{}, tomlType) {
   302  	parts := strings.FieldsFunc(it.val, func(r rune) bool {
   303  		switch r {
   304  		case '.', 'e', 'E':
   305  			return true
   306  		}
   307  		return false
   308  	})
   309  	for _, part := range parts {
   310  		if !numUnderscoresOK(part) {
   311  			p.panicItemf(it, "Invalid float %q: underscores must be surrounded by digits", it.val)
   312  		}
   313  	}
   314  	if len(parts) > 0 && numHasLeadingZero(parts[0]) {
   315  		p.panicItemf(it, "Invalid float %q: cannot have leading zeroes", it.val)
   316  	}
   317  	if !numPeriodsOK(it.val) {
   318  		// As a special case, numbers like '123.' or '1.e2',
   319  		// which are valid as far as Go/strconv are concerned,
   320  		// must be rejected because TOML says that a fractional
   321  		// part consists of '.' followed by 1+ digits.
   322  		p.panicItemf(it, "Invalid float %q: '.' must be followed by one or more digits", it.val)
   323  	}
   324  	val := strings.Replace(it.val, "_", "", -1)
   325  	if val == "+nan" || val == "-nan" { // Go doesn't support this, but TOML spec does.
   326  		val = "nan"
   327  	}
   328  	num, err := strconv.ParseFloat(val, 64)
   329  	if err != nil {
   330  		if e, ok := err.(*strconv.NumError); ok && e.Err == strconv.ErrRange {
   331  			p.panicErr(it, errParseRange{i: it.val, size: "float64"})
   332  		} else {
   333  			p.panicItemf(it, "Invalid float value: %q", it.val)
   334  		}
   335  	}
   336  	return num, p.typeOfPrimitive(it)
   337  }
   338  
   339  var dtTypes = []struct {
   340  	fmt  string
   341  	zone *time.Location
   342  	next bool
   343  }{
   344  	{time.RFC3339Nano, time.Local, false},
   345  	{"2006-01-02T15:04:05.999999999", internal.LocalDatetime, false},
   346  	{"2006-01-02", internal.LocalDate, false},
   347  	{"15:04:05.999999999", internal.LocalTime, false},
   348  
   349  	// tomlNext
   350  	{"2006-01-02T15:04Z07:00", time.Local, true},
   351  	{"2006-01-02T15:04", internal.LocalDatetime, true},
   352  	{"15:04", internal.LocalTime, true},
   353  }
   354  
   355  func (p *parser) valueDatetime(it item) (interface{}, tomlType) {
   356  	it.val = datetimeRepl.Replace(it.val)
   357  	var (
   358  		t   time.Time
   359  		ok  bool
   360  		err error
   361  	)
   362  	for _, dt := range dtTypes {
   363  		if dt.next && !p.tomlNext {
   364  			continue
   365  		}
   366  		t, err = time.ParseInLocation(dt.fmt, it.val, dt.zone)
   367  		if err == nil {
   368  			ok = true
   369  			break
   370  		}
   371  	}
   372  	if !ok {
   373  		p.panicItemf(it, "Invalid TOML Datetime: %q.", it.val)
   374  	}
   375  	return t, p.typeOfPrimitive(it)
   376  }
   377  
   378  func (p *parser) valueArray(it item) (interface{}, tomlType) {
   379  	p.setType(p.currentKey, tomlArray, it.pos)
   380  
   381  	var (
   382  		types []tomlType
   383  
   384  		// Initialize to a non-nil empty slice. This makes it consistent with
   385  		// how S = [] decodes into a non-nil slice inside something like struct
   386  		// { S []string }. See #338
   387  		array = []interface{}{}
   388  	)
   389  	for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
   390  		if it.typ == itemCommentStart {
   391  			p.expect(itemText)
   392  			continue
   393  		}
   394  
   395  		val, typ := p.value(it, true)
   396  		array = append(array, val)
   397  		types = append(types, typ)
   398  
   399  		// XXX: types isn't used here, we need it to record the accurate type
   400  		// information.
   401  		//
   402  		// Not entirely sure how to best store this; could use "key[0]",
   403  		// "key[1]" notation, or maybe store it on the Array type?
   404  		_ = types
   405  	}
   406  	return array, tomlArray
   407  }
   408  
   409  func (p *parser) valueInlineTable(it item, parentIsArray bool) (interface{}, tomlType) {
   410  	var (
   411  		hash         = make(map[string]interface{})
   412  		outerContext = p.context
   413  		outerKey     = p.currentKey
   414  	)
   415  
   416  	p.context = append(p.context, p.currentKey)
   417  	prevContext := p.context
   418  	p.currentKey = ""
   419  
   420  	p.addImplicit(p.context)
   421  	p.addContext(p.context, parentIsArray)
   422  
   423  	/// Loop over all table key/value pairs.
   424  	for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() {
   425  		if it.typ == itemCommentStart {
   426  			p.expect(itemText)
   427  			continue
   428  		}
   429  
   430  		/// Read all key parts.
   431  		k := p.nextPos()
   432  		var key Key
   433  		for ; k.typ != itemKeyEnd && k.typ != itemEOF; k = p.next() {
   434  			key = append(key, p.keyString(k))
   435  		}
   436  		p.assertEqual(itemKeyEnd, k.typ)
   437  
   438  		/// The current key is the last part.
   439  		p.currentKey = key[len(key)-1]
   440  
   441  		/// All the other parts (if any) are the context; need to set each part
   442  		/// as implicit.
   443  		context := key[:len(key)-1]
   444  		for i := range context {
   445  			p.addImplicitContext(append(p.context, context[i:i+1]...))
   446  		}
   447  		p.ordered = append(p.ordered, p.context.add(p.currentKey))
   448  
   449  		/// Set the value.
   450  		val, typ := p.value(p.next(), false)
   451  		p.set(p.currentKey, val, typ, it.pos)
   452  		hash[p.currentKey] = val
   453  
   454  		/// Restore context.
   455  		p.context = prevContext
   456  	}
   457  	p.context = outerContext
   458  	p.currentKey = outerKey
   459  	return hash, tomlHash
   460  }
   461  
   462  // numHasLeadingZero checks if this number has leading zeroes, allowing for '0',
   463  // +/- signs, and base prefixes.
   464  func numHasLeadingZero(s string) bool {
   465  	if len(s) > 1 && s[0] == '0' && !(s[1] == 'b' || s[1] == 'o' || s[1] == 'x') { // Allow 0b, 0o, 0x
   466  		return true
   467  	}
   468  	if len(s) > 2 && (s[0] == '-' || s[0] == '+') && s[1] == '0' {
   469  		return true
   470  	}
   471  	return false
   472  }
   473  
   474  // numUnderscoresOK checks whether each underscore in s is surrounded by
   475  // characters that are not underscores.
   476  func numUnderscoresOK(s string) bool {
   477  	switch s {
   478  	case "nan", "+nan", "-nan", "inf", "-inf", "+inf":
   479  		return true
   480  	}
   481  	accept := false
   482  	for _, r := range s {
   483  		if r == '_' {
   484  			if !accept {
   485  				return false
   486  			}
   487  		}
   488  
   489  		// isHexadecimal is a superset of all the permissable characters
   490  		// surrounding an underscore.
   491  		accept = isHexadecimal(r)
   492  	}
   493  	return accept
   494  }
   495  
   496  // numPeriodsOK checks whether every period in s is followed by a digit.
   497  func numPeriodsOK(s string) bool {
   498  	period := false
   499  	for _, r := range s {
   500  		if period && !isDigit(r) {
   501  			return false
   502  		}
   503  		period = r == '.'
   504  	}
   505  	return !period
   506  }
   507  
   508  // Set the current context of the parser, where the context is either a hash or
   509  // an array of hashes, depending on the value of the `array` parameter.
   510  //
   511  // Establishing the context also makes sure that the key isn't a duplicate, and
   512  // will create implicit hashes automatically.
   513  func (p *parser) addContext(key Key, array bool) {
   514  	var ok bool
   515  
   516  	// Always start at the top level and drill down for our context.
   517  	hashContext := p.mapping
   518  	keyContext := make(Key, 0)
   519  
   520  	// We only need implicit hashes for key[0:-1]
   521  	for _, k := range key[0 : len(key)-1] {
   522  		_, ok = hashContext[k]
   523  		keyContext = append(keyContext, k)
   524  
   525  		// No key? Make an implicit hash and move on.
   526  		if !ok {
   527  			p.addImplicit(keyContext)
   528  			hashContext[k] = make(map[string]interface{})
   529  		}
   530  
   531  		// If the hash context is actually an array of tables, then set
   532  		// the hash context to the last element in that array.
   533  		//
   534  		// Otherwise, it better be a table, since this MUST be a key group (by
   535  		// virtue of it not being the last element in a key).
   536  		switch t := hashContext[k].(type) {
   537  		case []map[string]interface{}:
   538  			hashContext = t[len(t)-1]
   539  		case map[string]interface{}:
   540  			hashContext = t
   541  		default:
   542  			p.panicf("Key '%s' was already created as a hash.", keyContext)
   543  		}
   544  	}
   545  
   546  	p.context = keyContext
   547  	if array {
   548  		// If this is the first element for this array, then allocate a new
   549  		// list of tables for it.
   550  		k := key[len(key)-1]
   551  		if _, ok := hashContext[k]; !ok {
   552  			hashContext[k] = make([]map[string]interface{}, 0, 4)
   553  		}
   554  
   555  		// Add a new table. But make sure the key hasn't already been used
   556  		// for something else.
   557  		if hash, ok := hashContext[k].([]map[string]interface{}); ok {
   558  			hashContext[k] = append(hash, make(map[string]interface{}))
   559  		} else {
   560  			p.panicf("Key '%s' was already created and cannot be used as an array.", key)
   561  		}
   562  	} else {
   563  		p.setValue(key[len(key)-1], make(map[string]interface{}))
   564  	}
   565  	p.context = append(p.context, key[len(key)-1])
   566  }
   567  
   568  // set calls setValue and setType.
   569  func (p *parser) set(key string, val interface{}, typ tomlType, pos Position) {
   570  	p.setValue(key, val)
   571  	p.setType(key, typ, pos)
   572  }
   573  
   574  // setValue sets the given key to the given value in the current context.
   575  // It will make sure that the key hasn't already been defined, account for
   576  // implicit key groups.
   577  func (p *parser) setValue(key string, value interface{}) {
   578  	var (
   579  		tmpHash    interface{}
   580  		ok         bool
   581  		hash       = p.mapping
   582  		keyContext Key
   583  	)
   584  	for _, k := range p.context {
   585  		keyContext = append(keyContext, k)
   586  		if tmpHash, ok = hash[k]; !ok {
   587  			p.bug("Context for key '%s' has not been established.", keyContext)
   588  		}
   589  		switch t := tmpHash.(type) {
   590  		case []map[string]interface{}:
   591  			// The context is a table of hashes. Pick the most recent table
   592  			// defined as the current hash.
   593  			hash = t[len(t)-1]
   594  		case map[string]interface{}:
   595  			hash = t
   596  		default:
   597  			p.panicf("Key '%s' has already been defined.", keyContext)
   598  		}
   599  	}
   600  	keyContext = append(keyContext, key)
   601  
   602  	if _, ok := hash[key]; ok {
   603  		// Normally redefining keys isn't allowed, but the key could have been
   604  		// defined implicitly and it's allowed to be redefined concretely. (See
   605  		// the `valid/implicit-and-explicit-after.toml` in toml-test)
   606  		//
   607  		// But we have to make sure to stop marking it as an implicit. (So that
   608  		// another redefinition provokes an error.)
   609  		//
   610  		// Note that since it has already been defined (as a hash), we don't
   611  		// want to overwrite it. So our business is done.
   612  		if p.isArray(keyContext) {
   613  			p.removeImplicit(keyContext)
   614  			hash[key] = value
   615  			return
   616  		}
   617  		if p.isImplicit(keyContext) {
   618  			p.removeImplicit(keyContext)
   619  			return
   620  		}
   621  
   622  		// Otherwise, we have a concrete key trying to override a previous
   623  		// key, which is *always* wrong.
   624  		p.panicf("Key '%s' has already been defined.", keyContext)
   625  	}
   626  
   627  	hash[key] = value
   628  }
   629  
   630  // setType sets the type of a particular value at a given key. It should be
   631  // called immediately AFTER setValue.
   632  //
   633  // Note that if `key` is empty, then the type given will be applied to the
   634  // current context (which is either a table or an array of tables).
   635  func (p *parser) setType(key string, typ tomlType, pos Position) {
   636  	keyContext := make(Key, 0, len(p.context)+1)
   637  	keyContext = append(keyContext, p.context...)
   638  	if len(key) > 0 { // allow type setting for hashes
   639  		keyContext = append(keyContext, key)
   640  	}
   641  	// Special case to make empty keys ("" = 1) work.
   642  	// Without it it will set "" rather than `""`.
   643  	// TODO: why is this needed? And why is this only needed here?
   644  	if len(keyContext) == 0 {
   645  		keyContext = Key{""}
   646  	}
   647  	p.keyInfo[keyContext.String()] = keyInfo{tomlType: typ, pos: pos}
   648  }
   649  
   650  // Implicit keys need to be created when tables are implied in "a.b.c.d = 1" and
   651  // "[a.b.c]" (the "a", "b", and "c" hashes are never created explicitly).
   652  func (p *parser) addImplicit(key Key)        { p.implicits[key.String()] = struct{}{} }
   653  func (p *parser) removeImplicit(key Key)     { delete(p.implicits, key.String()) }
   654  func (p *parser) isImplicit(key Key) bool    { _, ok := p.implicits[key.String()]; return ok }
   655  func (p *parser) isArray(key Key) bool       { return p.keyInfo[key.String()].tomlType == tomlArray }
   656  func (p *parser) addImplicitContext(key Key) { p.addImplicit(key); p.addContext(key, false) }
   657  
   658  // current returns the full key name of the current context.
   659  func (p *parser) current() string {
   660  	if len(p.currentKey) == 0 {
   661  		return p.context.String()
   662  	}
   663  	if len(p.context) == 0 {
   664  		return p.currentKey
   665  	}
   666  	return fmt.Sprintf("%s.%s", p.context, p.currentKey)
   667  }
   668  
   669  func stripFirstNewline(s string) string {
   670  	if len(s) > 0 && s[0] == '\n' {
   671  		return s[1:]
   672  	}
   673  	if len(s) > 1 && s[0] == '\r' && s[1] == '\n' {
   674  		return s[2:]
   675  	}
   676  	return s
   677  }
   678  
   679  // stripEscapedNewlines removes whitespace after line-ending backslashes in
   680  // multiline strings.
   681  //
   682  // A line-ending backslash is an unescaped \ followed only by whitespace until
   683  // the next newline. After a line-ending backslash, all whitespace is removed
   684  // until the next non-whitespace character.
   685  func (p *parser) stripEscapedNewlines(s string) string {
   686  	var b strings.Builder
   687  	var i int
   688  	for {
   689  		ix := strings.Index(s[i:], `\`)
   690  		if ix < 0 {
   691  			b.WriteString(s)
   692  			return b.String()
   693  		}
   694  		i += ix
   695  
   696  		if len(s) > i+1 && s[i+1] == '\\' {
   697  			// Escaped backslash.
   698  			i += 2
   699  			continue
   700  		}
   701  		// Scan until the next non-whitespace.
   702  		j := i + 1
   703  	whitespaceLoop:
   704  		for ; j < len(s); j++ {
   705  			switch s[j] {
   706  			case ' ', '\t', '\r', '\n':
   707  			default:
   708  				break whitespaceLoop
   709  			}
   710  		}
   711  		if j == i+1 {
   712  			// Not a whitespace escape.
   713  			i++
   714  			continue
   715  		}
   716  		if !strings.Contains(s[i:j], "\n") {
   717  			// This is not a line-ending backslash.
   718  			// (It's a bad escape sequence, but we can let
   719  			// replaceEscapes catch it.)
   720  			i++
   721  			continue
   722  		}
   723  		b.WriteString(s[:i])
   724  		s = s[j:]
   725  		i = 0
   726  	}
   727  }
   728  
   729  func (p *parser) replaceEscapes(it item, str string) string {
   730  	replaced := make([]rune, 0, len(str))
   731  	s := []byte(str)
   732  	r := 0
   733  	for r < len(s) {
   734  		if s[r] != '\\' {
   735  			c, size := utf8.DecodeRune(s[r:])
   736  			r += size
   737  			replaced = append(replaced, c)
   738  			continue
   739  		}
   740  		r += 1
   741  		if r >= len(s) {
   742  			p.bug("Escape sequence at end of string.")
   743  			return ""
   744  		}
   745  		switch s[r] {
   746  		default:
   747  			p.bug("Expected valid escape code after \\, but got %q.", s[r])
   748  		case ' ', '\t':
   749  			p.panicItemf(it, "invalid escape: '\\%c'", s[r])
   750  		case 'b':
   751  			replaced = append(replaced, rune(0x0008))
   752  			r += 1
   753  		case 't':
   754  			replaced = append(replaced, rune(0x0009))
   755  			r += 1
   756  		case 'n':
   757  			replaced = append(replaced, rune(0x000A))
   758  			r += 1
   759  		case 'f':
   760  			replaced = append(replaced, rune(0x000C))
   761  			r += 1
   762  		case 'r':
   763  			replaced = append(replaced, rune(0x000D))
   764  			r += 1
   765  		case 'e':
   766  			if p.tomlNext {
   767  				replaced = append(replaced, rune(0x001B))
   768  				r += 1
   769  			}
   770  		case '"':
   771  			replaced = append(replaced, rune(0x0022))
   772  			r += 1
   773  		case '\\':
   774  			replaced = append(replaced, rune(0x005C))
   775  			r += 1
   776  		case 'x':
   777  			if p.tomlNext {
   778  				escaped := p.asciiEscapeToUnicode(it, s[r+1:r+3])
   779  				replaced = append(replaced, escaped)
   780  				r += 3
   781  			}
   782  		case 'u':
   783  			// At this point, we know we have a Unicode escape of the form
   784  			// `uXXXX` at [r, r+5). (Because the lexer guarantees this
   785  			// for us.)
   786  			escaped := p.asciiEscapeToUnicode(it, s[r+1:r+5])
   787  			replaced = append(replaced, escaped)
   788  			r += 5
   789  		case 'U':
   790  			// At this point, we know we have a Unicode escape of the form
   791  			// `uXXXX` at [r, r+9). (Because the lexer guarantees this
   792  			// for us.)
   793  			escaped := p.asciiEscapeToUnicode(it, s[r+1:r+9])
   794  			replaced = append(replaced, escaped)
   795  			r += 9
   796  		}
   797  	}
   798  	return string(replaced)
   799  }
   800  
   801  func (p *parser) asciiEscapeToUnicode(it item, bs []byte) rune {
   802  	s := string(bs)
   803  	hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
   804  	if err != nil {
   805  		p.bug("Could not parse '%s' as a hexadecimal number, but the lexer claims it's OK: %s", s, err)
   806  	}
   807  	if !utf8.ValidRune(rune(hex)) {
   808  		p.panicItemf(it, "Escaped character '\\u%s' is not valid UTF-8.", s)
   809  	}
   810  	return rune(hex)
   811  }
   812  

View as plain text