lex.go

Documentation: github.com/magiconair/properties

     1  // Copyright 2013-2022 Frank Schroeder. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  //
     5  // Parts of the lexer are from the template/text/parser package
     6  // For these parts the following applies:
     7  //
     8  // Copyright 2011 The Go Authors. All rights reserved.
     9  // Use of this source code is governed by a BSD-style
    10  // license that can be found in the LICENSE file of the go 1.2
    11  // distribution.
    12  
    13  package properties
    14  
    15  import (
    16  	"fmt"
    17  	"strconv"
    18  	"strings"
    19  	"unicode/utf8"
    20  )
    21  
    22  // item represents a token or text string returned from the scanner.
    23  type item struct {
    24  	typ itemType // The type of this item.
    25  	pos int      // The starting position, in bytes, of this item in the input string.
    26  	val string   // The value of this item.
    27  }
    28  
    29  func (i item) String() string {
    30  	switch {
    31  	case i.typ == itemEOF:
    32  		return "EOF"
    33  	case i.typ == itemError:
    34  		return i.val
    35  	case len(i.val) > 10:
    36  		return fmt.Sprintf("%.10q...", i.val)
    37  	}
    38  	return fmt.Sprintf("%q", i.val)
    39  }
    40  
    41  // itemType identifies the type of lex items.
    42  type itemType int
    43  
    44  const (
    45  	itemError itemType = iota // error occurred; value is text of error
    46  	itemEOF
    47  	itemKey     // a key
    48  	itemValue   // a value
    49  	itemComment // a comment
    50  )
    51  
    52  // defines a constant for EOF
    53  const eof = -1
    54  
    55  // permitted whitespace characters space, FF and TAB
    56  const whitespace = " \f\t"
    57  
    58  // stateFn represents the state of the scanner as a function that returns the next state.
    59  type stateFn func(*lexer) stateFn
    60  
    61  // lexer holds the state of the scanner.
    62  type lexer struct {
    63  	input   string    // the string being scanned
    64  	state   stateFn   // the next lexing function to enter
    65  	pos     int       // current position in the input
    66  	start   int       // start position of this item
    67  	width   int       // width of last rune read from input
    68  	lastPos int       // position of most recent item returned by nextItem
    69  	runes   []rune    // scanned runes for this item
    70  	items   chan item // channel of scanned items
    71  }
    72  
    73  // next returns the next rune in the input.
    74  func (l *lexer) next() rune {
    75  	if l.pos >= len(l.input) {
    76  		l.width = 0
    77  		return eof
    78  	}
    79  	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
    80  	l.width = w
    81  	l.pos += l.width
    82  	return r
    83  }
    84  
    85  // peek returns but does not consume the next rune in the input.
    86  func (l *lexer) peek() rune {
    87  	r := l.next()
    88  	l.backup()
    89  	return r
    90  }
    91  
    92  // backup steps back one rune. Can only be called once per call of next.
    93  func (l *lexer) backup() {
    94  	l.pos -= l.width
    95  }
    96  
    97  // emit passes an item back to the client.
    98  func (l *lexer) emit(t itemType) {
    99  	i := item{t, l.start, string(l.runes)}
   100  	l.items <- i
   101  	l.start = l.pos
   102  	l.runes = l.runes[:0]
   103  }
   104  
   105  // ignore skips over the pending input before this point.
   106  func (l *lexer) ignore() {
   107  	l.start = l.pos
   108  }
   109  
   110  // appends the rune to the current value
   111  func (l *lexer) appendRune(r rune) {
   112  	l.runes = append(l.runes, r)
   113  }
   114  
   115  // accept consumes the next rune if it's from the valid set.
   116  func (l *lexer) accept(valid string) bool {
   117  	if strings.ContainsRune(valid, l.next()) {
   118  		return true
   119  	}
   120  	l.backup()
   121  	return false
   122  }
   123  
   124  // acceptRun consumes a run of runes from the valid set.
   125  func (l *lexer) acceptRun(valid string) {
   126  	for strings.ContainsRune(valid, l.next()) {
   127  	}
   128  	l.backup()
   129  }
   130  
   131  // lineNumber reports which line we're on, based on the position of
   132  // the previous item returned by nextItem. Doing it this way
   133  // means we don't have to worry about peek double counting.
   134  func (l *lexer) lineNumber() int {
   135  	return 1 + strings.Count(l.input[:l.lastPos], "\n")
   136  }
   137  
   138  // errorf returns an error token and terminates the scan by passing
   139  // back a nil pointer that will be the next state, terminating l.nextItem.
   140  func (l *lexer) errorf(format string, args ...interface{}) stateFn {
   141  	l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)}
   142  	return nil
   143  }
   144  
   145  // nextItem returns the next item from the input.
   146  func (l *lexer) nextItem() item {
   147  	i := <-l.items
   148  	l.lastPos = i.pos
   149  	return i
   150  }
   151  
   152  // lex creates a new scanner for the input string.
   153  func lex(input string) *lexer {
   154  	l := &lexer{
   155  		input: input,
   156  		items: make(chan item),
   157  		runes: make([]rune, 0, 32),
   158  	}
   159  	go l.run()
   160  	return l
   161  }
   162  
   163  // run runs the state machine for the lexer.
   164  func (l *lexer) run() {
   165  	for l.state = lexBeforeKey(l); l.state != nil; {
   166  		l.state = l.state(l)
   167  	}
   168  }
   169  
   170  // state functions
   171  
   172  // lexBeforeKey scans until a key begins.
   173  func lexBeforeKey(l *lexer) stateFn {
   174  	switch r := l.next(); {
   175  	case isEOF(r):
   176  		l.emit(itemEOF)
   177  		return nil
   178  
   179  	case isEOL(r):
   180  		l.ignore()
   181  		return lexBeforeKey
   182  
   183  	case isComment(r):
   184  		return lexComment
   185  
   186  	case isWhitespace(r):
   187  		l.ignore()
   188  		return lexBeforeKey
   189  
   190  	default:
   191  		l.backup()
   192  		return lexKey
   193  	}
   194  }
   195  
   196  // lexComment scans a comment line. The comment character has already been scanned.
   197  func lexComment(l *lexer) stateFn {
   198  	l.acceptRun(whitespace)
   199  	l.ignore()
   200  	for {
   201  		switch r := l.next(); {
   202  		case isEOF(r):
   203  			l.ignore()
   204  			l.emit(itemEOF)
   205  			return nil
   206  		case isEOL(r):
   207  			l.emit(itemComment)
   208  			return lexBeforeKey
   209  		default:
   210  			l.appendRune(r)
   211  		}
   212  	}
   213  }
   214  
   215  // lexKey scans the key up to a delimiter
   216  func lexKey(l *lexer) stateFn {
   217  	var r rune
   218  
   219  Loop:
   220  	for {
   221  		switch r = l.next(); {
   222  
   223  		case isEscape(r):
   224  			err := l.scanEscapeSequence()
   225  			if err != nil {
   226  				return l.errorf(err.Error())
   227  			}
   228  
   229  		case isEndOfKey(r):
   230  			l.backup()
   231  			break Loop
   232  
   233  		case isEOF(r):
   234  			break Loop
   235  
   236  		default:
   237  			l.appendRune(r)
   238  		}
   239  	}
   240  
   241  	if len(l.runes) > 0 {
   242  		l.emit(itemKey)
   243  	}
   244  
   245  	if isEOF(r) {
   246  		l.emit(itemEOF)
   247  		return nil
   248  	}
   249  
   250  	return lexBeforeValue
   251  }
   252  
   253  // lexBeforeValue scans the delimiter between key and value.
   254  // Leading and trailing whitespace is ignored.
   255  // We expect to be just after the key.
   256  func lexBeforeValue(l *lexer) stateFn {
   257  	l.acceptRun(whitespace)
   258  	l.accept(":=")
   259  	l.acceptRun(whitespace)
   260  	l.ignore()
   261  	return lexValue
   262  }
   263  
   264  // lexValue scans text until the end of the line. We expect to be just after the delimiter.
   265  func lexValue(l *lexer) stateFn {
   266  	for {
   267  		switch r := l.next(); {
   268  		case isEscape(r):
   269  			if isEOL(l.peek()) {
   270  				l.next()
   271  				l.acceptRun(whitespace)
   272  			} else {
   273  				err := l.scanEscapeSequence()
   274  				if err != nil {
   275  					return l.errorf(err.Error())
   276  				}
   277  			}
   278  
   279  		case isEOL(r):
   280  			l.emit(itemValue)
   281  			l.ignore()
   282  			return lexBeforeKey
   283  
   284  		case isEOF(r):
   285  			l.emit(itemValue)
   286  			l.emit(itemEOF)
   287  			return nil
   288  
   289  		default:
   290  			l.appendRune(r)
   291  		}
   292  	}
   293  }
   294  
   295  // scanEscapeSequence scans either one of the escaped characters
   296  // or a unicode literal. We expect to be after the escape character.
   297  func (l *lexer) scanEscapeSequence() error {
   298  	switch r := l.next(); {
   299  
   300  	case isEscapedCharacter(r):
   301  		l.appendRune(decodeEscapedCharacter(r))
   302  		return nil
   303  
   304  	case atUnicodeLiteral(r):
   305  		return l.scanUnicodeLiteral()
   306  
   307  	case isEOF(r):
   308  		return fmt.Errorf("premature EOF")
   309  
   310  	// silently drop the escape character and append the rune as is
   311  	default:
   312  		l.appendRune(r)
   313  		return nil
   314  	}
   315  }
   316  
   317  // scans a unicode literal in the form \uXXXX. We expect to be after the \u.
   318  func (l *lexer) scanUnicodeLiteral() error {
   319  	// scan the digits
   320  	d := make([]rune, 4)
   321  	for i := 0; i < 4; i++ {
   322  		d[i] = l.next()
   323  		if d[i] == eof || !strings.ContainsRune("0123456789abcdefABCDEF", d[i]) {
   324  			return fmt.Errorf("invalid unicode literal")
   325  		}
   326  	}
   327  
   328  	// decode the digits into a rune
   329  	r, err := strconv.ParseInt(string(d), 16, 0)
   330  	if err != nil {
   331  		return err
   332  	}
   333  
   334  	l.appendRune(rune(r))
   335  	return nil
   336  }
   337  
   338  // decodeEscapedCharacter returns the unescaped rune. We expect to be after the escape character.
   339  func decodeEscapedCharacter(r rune) rune {
   340  	switch r {
   341  	case 'f':
   342  		return '\f'
   343  	case 'n':
   344  		return '\n'
   345  	case 'r':
   346  		return '\r'
   347  	case 't':
   348  		return '\t'
   349  	default:
   350  		return r
   351  	}
   352  }
   353  
   354  // atUnicodeLiteral reports whether we are at a unicode literal.
   355  // The escape character has already been consumed.
   356  func atUnicodeLiteral(r rune) bool {
   357  	return r == 'u'
   358  }
   359  
   360  // isComment reports whether we are at the start of a comment.
   361  func isComment(r rune) bool {
   362  	return r == '#' || r == '!'
   363  }
   364  
   365  // isEndOfKey reports whether the rune terminates the current key.
   366  func isEndOfKey(r rune) bool {
   367  	return strings.ContainsRune(" \f\t\r\n:=", r)
   368  }
   369  
   370  // isEOF reports whether we are at EOF.
   371  func isEOF(r rune) bool {
   372  	return r == eof
   373  }
   374  
   375  // isEOL reports whether we are at a new line character.
   376  func isEOL(r rune) bool {
   377  	return r == '\n' || r == '\r'
   378  }
   379  
   380  // isEscape reports whether the rune is the escape character which
   381  // prefixes unicode literals and other escaped characters.
   382  func isEscape(r rune) bool {
   383  	return r == '\\'
   384  }
   385  
   386  // isEscapedCharacter reports whether we are at one of the characters that need escaping.
   387  // The escape character has already been consumed.
   388  func isEscapedCharacter(r rune) bool {
   389  	return strings.ContainsRune(" :=fnrt", r)
   390  }
   391  
   392  // isWhitespace reports whether the rune is a whitespace character.
   393  func isWhitespace(r rune) bool {
   394  	return strings.ContainsRune(whitespace, r)
   395  }
   396
View as plain text