all repos

clerk @ 25c8f80b71674079b26e4189b4030a90fffb8c26

missing tooling for ledger/hledger
1 files changed, 9 insertions(+), 36 deletions(-)
lexer: merge periodic and automated modes
Author: Oleksandr Smirnov olexsmir@gmail.com
Committed at: 2026-09-29 19:57:41 +0300
Authored at: 2026-09-26 20:44:18 +0300
Change ID: wmkumnnmlrqrzpkpwtzrlxtuwskoylxo
Parent: d12c079
M journal/lexer/lexer.go
···
        22
        22
         	// expects: optional status, optional code, description, comment

      
        23
        23
         	modeTransaction

      
        24
        24
         

      
        
        25
        +	// after ~ or =, at the head of a periodic or automated transaction

      
        
        26
        +	// expects: period or expression, then optional description, then optional comment

      
        
        27
        +	modeExpr

      
        
        28
        +

      
        25
        29
         	// after lexing an indent at start of line

      
        26
        30
         	// expects: account name, then two spaces, then amount

      
        27
        31
         	modePosting

      
        28
        32
         

      
        29
        
        -	// after ~, period expression

      
        30
        
        -	// expects: period, optional description (after 2+ spaces), optional comment

      
        31
        
        -	modePeriodic

      
        32
        
        -

      
        33
        
        -	// after =, automates transaction

      
        34
        
        -	// expects: expression

      
        35
        
        -	modeAutomated

      
        36
        
        -

      
        37
        33
         	// after a directive keyword like account, commodity, include

      
        38
        34
         	// expects: rest of directive content

      
        39
        35
         	modeDirective

      ···
        87
        83
         		return l.lexTransaction()

      
        88
        84
         	case modePosting:

      
        89
        85
         		return l.lexPosting()

      
        90
        
        -	case modePeriodic:

      
        91
        
        -		return l.lexPeriodic()

      
        92
        
        -	case modeAutomated:

      
        93
        
        -		return l.lexAutomated()

      
        
        86
        +	case modeExpr:

      
        
        87
        +		return l.lexExpr()

      
        94
        88
         	case modeDirective:

      
        95
        89
         		return l.lexDirective()

      
        96
        90
         	}

      ···
        131
        125
         		l.mode = modeComment

      
        132
        126
         		return l.lexSingle(token.STAR)

      
        133
        127
         	case l.ch == '~':

      
        134
        
        -		l.mode = modePeriodic

      
        
        128
        +		l.mode = modeExpr

      
        135
        129
         		return l.lexSingle(token.TILDE)

      
        136
        130
         	case l.ch == '=':

      
        137
        
        -		l.mode = modeAutomated

      
        
        131
        +		l.mode = modeExpr

      
        138
        132
         		return l.lexSingle(token.EQ)

      
        139
        133
         	case l.ch == '+':

      
        140
        134
         		return l.lexSingle(token.PLUS)

      ···
        268
        262
         	return token.Token{Type: token.TEXT, Literal: lit, Span: l.span(s)}

      
        269
        263
         }

      
        270
        264
         

      
        271
        
        -func (l *Lexer) lexPeriodic() token.Token {

      
        
        265
        +func (l *Lexer) lexExpr() token.Token {

      
        272
        266
         	switch l.ch {

      
        273
        267
         	case 0:

      
        274
        268
         		return l.token(token.EOF, "")

      ···
        284
        278
         		return l.lexSingle(token.SEMICOLON)

      
        285
        279
         	case ' ', '\t':

      
        286
        280
         		return l.lexWhitespace()

      
        287
        
        -	default:

      
        288
        
        -		return l.lexText()

      
        289
        
        -	}

      
        290
        
        -}

      
        291
        
        -

      
        292
        
        -func (l *Lexer) lexAutomated() token.Token {

      
        293
        
        -	switch l.ch {

      
        294
        
        -	case 0:

      
        295
        
        -		return l.token(token.EOF, "")

      
        296
        
        -	case '\n':

      
        297
        
        -		l.mode = modeDefault

      
        298
        
        -		return l.lexNewline()

      
        299
        
        -	case '\r':

      
        300
        
        -		l.col = 0

      
        301
        
        -		l.advance()

      
        302
        
        -		return l.lexNewline()

      
        303
        
        -	case ' ', '\t':

      
        304
        
        -		return l.lexWhitespace()

      
        305
        
        -	case ';':

      
        306
        
        -		l.mode = modeComment

      
        307
        
        -		return l.lexSingle(token.SEMICOLON)

      
        308
        281
         	default:

      
        309
        282
         		return l.lexText()

      
        310
        283
         	}