clerk @ e586ae2516f828afd5a62156055812e727a17d1c

···
        
        1
        +module github.com/olexsmir/ledger-tools

      
        
        2
        +

      
        
        3
        +go 1.26.2

      
        
        4
        +

      
        
        5
        +tool golang.org/x/tools/cmd/stringer

      
        
        6
        +

      
        
        7
        +require github.com/shopspring/decimal v1.4.0

      
        
        8
        +

      
        
        9
        +require (

      
        
        10
        +	golang.org/x/mod v0.36.0 // indirect

      
        
        11
        +	golang.org/x/sync v0.20.0 // indirect

      
        
        12
        +	golang.org/x/tools v0.45.0 // indirect

      
        
        13
        +)

      

···
        
        1
        +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

      
        
        2
        +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

      
        
        3
        +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=

      
        
        4
        +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=

      
        
        5
        +golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=

      
        
        6
        +golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=

      
        
        7
        +golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=

      
        
        8
        +golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=

      
        
        9
        +golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=

      
        
        10
        +golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=

      

···
        
        1
        +package golden

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"flag"

      
        
        5
        +	"os"

      
        
        6
        +	"path/filepath"

      
        
        7
        +	"strings"

      
        
        8
        +	"testing"

      
        
        9
        +)

      
        
        10
        +

      
        
        11
        +var update = flag.Bool("update", false, "update golden files")

      
        
        12
        +

      
        
        13
        +func Assert(t *testing.T, got string) {

      
        
        14
        +	t.Helper()

      
        
        15
        +

      
        
        16
        +	name := strings.NewReplacer("/", "__", " ", "_").Replace(t.Name())

      
        
        17
        +	name = strings.TrimLeft(name, "Test")

      
        
        18
        +	path := filepath.Join("testdata", "golden", name+".golden")

      
        
        19
        +

      
        
        20
        +	if *update {

      
        
        21
        +		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {

      
        
        22
        +			t.Fatalf("creating golden dir: %v", err)

      
        
        23
        +		}

      
        
        24
        +		t.Logf("Saving golden file in %s", got)

      
        
        25
        +		if err := os.WriteFile(path, []byte(got), 0o644); err != nil {

      
        
        26
        +			t.Fatalf("writing golden file: %v", err)

      
        
        27
        +		}

      
        
        28
        +		return

      
        
        29
        +	}

      
        
        30
        +

      
        
        31
        +	golden, err := os.ReadFile(path)

      
        
        32
        +	if os.IsNotExist(err) {

      
        
        33
        +		t.Fatalf("no golden file, run with -update:\n%s", got)

      
        
        34
        +	}

      
        
        35
        +	if err != nil {

      
        
        36
        +		t.Fatalf("reading golden file: %v", err)

      
        
        37
        +	}

      
        
        38
        +

      
        
        39
        +	if string(golden) != got {

      
        
        40
        +		t.Fatalf("golden mismatch\nwant:\n%s\ngot:\n%s", string(golden), got)

      
        
        41
        +	}

      
        
        42
        +}

      

···
        
        1
        +package ast

      
        
        2
        +

      
        
        3
        +import "github.com/olexsmir/ledger-tools/journal/token"

      
        
        4
        +

      
        
        5
        +type Journal struct {

      
        
        6
        +	Entries []Entry

      
        
        7
        +	Errors  []*ParseError

      
        
        8
        +}

      
        
        9
        +

      
        
        10
        +type Entry interface {

      
        
        11
        +	entryNode()

      
        
        12
        +}

      
        
        13
        +

      
        
        14
        +type ParseError struct {

      
        
        15
        +	Span    token.Span

      
        
        16
        +	Message string

      
        
        17
        +}

      
        
        18
        +

      
        
        19
        +type FileError struct {

      
        
        20
        +	Path    string

      
        
        21
        +	Span    token.Span

      
        
        22
        +	Message string

      
        
        23
        +}

      
        
        24
        +

      
        
        25
        +type Date struct {

      
        
        26
        +	Year, Month, Day int

      
        
        27
        +	Sep              byte //  '-' '/' '.'

      
        
        28
        +	Span             token.Span

      
        
        29
        +}

      
        
        30
        +

      
        
        31
        +type Time struct {

      
        
        32
        +	Hour, Minute, Second int

      
        
        33
        +	Span                 token.Span

      
        
        34
        +}

      
        
        35
        +

      
        
        36
        +type DateTime struct {

      
        
        37
        +	Date Date

      
        
        38
        +	Time *Time

      
        
        39
        +	Span token.Span

      
        
        40
        +}

      
        
        41
        +

      
        
        42
        +type Comment struct {

      
        
        43
        +	Marker byte // ';' '#' '%' '*'

      
        
        44
        +	Text   string

      
        
        45
        +	Span   token.Span

      
        
        46
        +}

      
        
        47
        +

      
        
        48
        +func (Comment) entryNode() {}

      
        
        49
        +

      
        
        50
        +type StatusType int

      
        
        51
        +

      
        
        52
        +func (s StatusType) String() string {

      
        
        53
        +	switch s {

      
        
        54
        +	case StatusCleared:

      
        
        55
        +		return "*"

      
        
        56
        +	case StatusPending:

      
        
        57
        +		return "!"

      
        
        58
        +	case StatusNone:

      
        
        59
        +		return ""

      
        
        60
        +	default:

      
        
        61
        +		panic("unreachable")

      
        
        62
        +	}

      
        
        63
        +}

      
        
        64
        +

      
        
        65
        +const (

      
        
        66
        +	StatusCleared StatusType = iota // * cleared

      
        
        67
        +	StatusPending                   // ! pending

      
        
        68
        +	StatusNone                      // not set

      
        
        69
        +)

      
        
        70
        +

      
        
        71
        +type Status struct {

      
        
        72
        +	// Value byte // '!' '*'

      
        
        73
        +	Value StatusType

      
        
        74
        +	Span  token.Span

      
        
        75
        +}

      
        
        76
        +

      
        
        77
        +type Payee struct {

      
        
        78
        +	Name string

      
        
        79
        +	Span token.Span

      
        
        80
        +}

      
        
        81
        +

      
        
        82
        +type Account struct {

      
        
        83
        +	Name string // 'expenses:food'

      
        
        84
        +	Span token.Span

      
        
        85
        +}

      

···
        
        1
        +package ast

      
        
        2
        +

      
        
        3
        +import "github.com/olexsmir/ledger-tools/journal/token"

      
        
        4
        +

      
        
        5
        +type AccountDirective struct {

      
        
        6
        +	Account Account

      
        
        7
        +	Comment *Comment

      
        
        8
        +	Span    token.Span

      
        
        9
        +}

      
        
        10
        +

      
        
        11
        +func (AccountDirective) entryNode() {}

      
        
        12
        +

      
        
        13
        +type CommodityDirective struct {

      
        
        14
        +	Commodity string

      
        
        15
        +	Format    *Amount // optional format hint: "1,000.00 UAH"

      
        
        16
        +	Comment   *Comment

      
        
        17
        +	Span      token.Span

      
        
        18
        +}

      
        
        19
        +

      
        
        20
        +func (CommodityDirective) entryNode() {}

      
        
        21
        +

      
        
        22
        +type PayeeDirective struct {

      
        
        23
        +	Name    string

      
        
        24
        +	Comment *Comment

      
        
        25
        +	Span    token.Span

      
        
        26
        +}

      
        
        27
        +

      
        
        28
        +func (PayeeDirective) entryNode() {}

      
        
        29
        +

      
        
        30
        +type TagDirective struct {

      
        
        31
        +	Name    string

      
        
        32
        +	Comment *Comment

      
        
        33
        +	Span    token.Span

      
        
        34
        +}

      
        
        35
        +

      
        
        36
        +func (TagDirective) entryNode() {}

      
        
        37
        +

      
        
        38
        +type IncludeDirective struct {

      
        
        39
        +	Path    string

      
        
        40
        +	Comment *Comment

      
        
        41
        +	Span    token.Span

      
        
        42
        +}

      
        
        43
        +

      
        
        44
        +func (IncludeDirective) entryNode() {}

      
        
        45
        +

      
        
        46
        +type AliasDirective struct {

      
        
        47
        +	From, To string

      
        
        48
        +	Span     token.Span

      
        
        49
        +}

      
        
        50
        +

      
        
        51
        +func (AliasDirective) entryNode() {}

      
        
        52
        +

      
        
        53
        +type YearDirective struct {

      
        
        54
        +	Year int

      
        
        55
        +	Span token.Span

      
        
        56
        +}

      
        
        57
        +

      
        
        58
        +func (YearDirective) entryNode() {}

      
        
        59
        +

      
        
        60
        +type DecimalMarkDirective struct {

      
        
        61
        +	Mark byte // '.' ','

      
        
        62
        +	Span token.Span

      
        
        63
        +}

      
        
        64
        +

      
        
        65
        +func (DecimalMarkDirective) entryNode() {}

      
        
        66
        +

      
        
        67
        +type DefaultCommodityDirective struct {

      
        
        68
        +	Amount Amount

      
        
        69
        +	Span   token.Span

      
        
        70
        +}

      
        
        71
        +

      
        
        72
        +func (DefaultCommodityDirective) entryNode() {}

      
        
        73
        +

      
        
        74
        +type MarketPriceDirective struct {

      
        
        75
        +	DateTime  DateTime

      
        
        76
        +	Commodity string

      
        
        77
        +	Amount    Amount

      
        
        78
        +	Span      token.Span

      
        
        79
        +}

      
        
        80
        +

      
        
        81
        +func (MarketPriceDirective) entryNode() {}

      
        
        82
        +

      
        
        83
        +type ApplyDirective struct {

      
        
        84
        +	Expr    string // text after apply e.g "tag foo"

      
        
        85
        +	Comment *Comment

      
        
        86
        +	Span    token.Span

      
        
        87
        +}

      
        
        88
        +

      
        
        89
        +func (ApplyDirective) entryNode() {}

      
        
        90
        +

      
        
        91
        +type EndDirective struct {

      
        
        92
        +	Expr    string // text after end e.g "tag"

      
        
        93
        +	Comment *Comment

      
        
        94
        +	Span    token.Span

      
        
        95
        +}

      
        
        96
        +

      
        
        97
        +func (EndDirective) entryNode() {}

      
        
        98
        +

      
        
        99
        +type CommentBlockDirective struct {

      
        
        100
        +	Header  string // text after "comment" on the same line

      
        
        101
        +	Content string

      
        
        102
        +	Comment *Comment

      
        
        103
        +	Span    token.Span

      
        
        104
        +}

      
        
        105
        +

      
        
        106
        +func (CommentBlockDirective) entryNode() {}

      
        
        107
        +

      
        
        108
        +type IgnoredDirective struct {

      
        
        109
        +	Span token.Span

      
        
        110
        +}

      
        
        111
        +

      
        
        112
        +func (IgnoredDirective) entryNode() {}

      

···
        
        1
        +package ast

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"fmt"

      
        
        5
        +	"strings"

      
        
        6
        +)

      
        
        7
        +

      
        
        8
        +func Dump(f *Journal) string {

      
        
        9
        +	var b strings.Builder

      
        
        10
        +	dumpJournal(&b, f)

      
        
        11
        +	return b.String()

      
        
        12
        +}

      
        
        13
        +

      
        
        14
        +func dumpJournal(b *strings.Builder, f *Journal) {

      
        
        15
        +	fmt.Fprintf(b, "Journal\n")

      
        
        16
        +	for _, e := range f.Entries {

      
        
        17
        +		dumpEntry(b, e, 1)

      
        
        18
        +	}

      
        
        19
        +	if len(f.Errors) > 0 {

      
        
        20
        +		fmt.Fprintf(b, "  Errors\n")

      
        
        21
        +		for _, err := range f.Errors {

      
        
        22
        +			fmt.Fprintf(b, "    %s: %s\n", err.Span, err.Message)

      
        
        23
        +		}

      
        
        24
        +	}

      
        
        25
        +}

      
        
        26
        +

      
        
        27
        +func dumpEntry(b *strings.Builder, e Entry, depth int) {

      
        
        28
        +	switch e := e.(type) {

      
        
        29
        +	case *Transaction:

      
        
        30
        +		dumpTransaction(b, e, depth)

      
        
        31
        +	case *PeriodicTransaction:

      
        
        32
        +		dumpPeriodicTransaction(b, e, depth)

      
        
        33
        +	case *AutomatedTransaction:

      
        
        34
        +		dumpAutomatedTransaction(b, e, depth)

      
        
        35
        +	case *BlankLine:

      
        
        36
        +		indent(b, depth)

      
        
        37
        +		fmt.Fprintf(b, "BlankLine %s\n", e.Span)

      
        
        38
        +	case *Comment:

      
        
        39
        +		dumpComment(b, e, depth)

      
        
        40
        +	case *AccountDirective:

      
        
        41
        +		dumpAccountDirective(b, e, depth)

      
        
        42
        +	case *CommodityDirective:

      
        
        43
        +		dumpCommodityDirective(b, e, depth)

      
        
        44
        +	case *IncludeDirective:

      
        
        45
        +		indent(b, depth)

      
        
        46
        +		fmt.Fprintf(b, "IncludeDirective %s\n", e.Span)

      
        
        47
        +		indent(b, depth+1)

      
        
        48
        +		fmt.Fprintf(b, "Path: %q\n", e.Path)

      
        
        49
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        50
        +	case *AliasDirective:

      
        
        51
        +		indent(b, depth)

      
        
        52
        +		fmt.Fprintf(b, "AliasDirective %s\n", e.Span)

      
        
        53
        +		indent(b, depth+1)

      
        
        54
        +		fmt.Fprintf(b, "From: %q\n", e.From)

      
        
        55
        +		indent(b, depth+1)

      
        
        56
        +		fmt.Fprintf(b, "To: %q\n", e.To)

      
        
        57
        +	case *PayeeDirective:

      
        
        58
        +		indent(b, depth)

      
        
        59
        +		fmt.Fprintf(b, "PayeeDirective %s\n", e.Span)

      
        
        60
        +		indent(b, depth+1)

      
        
        61
        +		fmt.Fprintf(b, "Name: %q\n", e.Name)

      
        
        62
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        63
        +	case *TagDirective:

      
        
        64
        +		indent(b, depth)

      
        
        65
        +		fmt.Fprintf(b, "TagDirective %s\n", e.Span)

      
        
        66
        +		indent(b, depth+1)

      
        
        67
        +		fmt.Fprintf(b, "Name: %q\n", e.Name)

      
        
        68
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        69
        +	case *YearDirective:

      
        
        70
        +		indent(b, depth)

      
        
        71
        +		fmt.Fprintf(b, "YearDirective %s\n", e.Span)

      
        
        72
        +		indent(b, depth+1)

      
        
        73
        +		fmt.Fprintf(b, "Year: %d\n", e.Year)

      
        
        74
        +	case *DecimalMarkDirective:

      
        
        75
        +		indent(b, depth)

      
        
        76
        +		fmt.Fprintf(b, "DecimalMarkDirective %s\n", e.Span)

      
        
        77
        +		indent(b, depth+1)

      
        
        78
        +		fmt.Fprintf(b, "Mark: %q\n", string(e.Mark))

      
        
        79
        +	case *MarketPriceDirective:

      
        
        80
        +		dumpMarketPriceDirective(b, e, depth)

      
        
        81
        +	case *DefaultCommodityDirective:

      
        
        82
        +		indent(b, depth)

      
        
        83
        +		fmt.Fprintf(b, "DefaultCommodityDirective %s\n", e.Span)

      
        
        84
        +		dumpAmount(b, &e.Amount, depth+1)

      
        
        85
        +	case *ApplyDirective:

      
        
        86
        +		indent(b, depth)

      
        
        87
        +		fmt.Fprintf(b, "ApplyDirective %s\n", e.Span)

      
        
        88
        +		indent(b, depth+1)

      
        
        89
        +		fmt.Fprintf(b, "Expr: %q\n", e.Expr)

      
        
        90
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        91
        +	case *EndDirective:

      
        
        92
        +		indent(b, depth)

      
        
        93
        +		fmt.Fprintf(b, "EndDirective %s\n", e.Span)

      
        
        94
        +		indent(b, depth+1)

      
        
        95
        +		fmt.Fprintf(b, "Expr: %q\n", e.Expr)

      
        
        96
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        97
        +	case *CommentBlockDirective:

      
        
        98
        +		indent(b, depth)

      
        
        99
        +		fmt.Fprintf(b, "CommentBlockDirective %s\n", e.Span)

      
        
        100
        +		indent(b, depth+1)

      
        
        101
        +		fmt.Fprintf(b, "Header: %q\n", e.Header)

      
        
        102
        +		indent(b, depth+1)

      
        
        103
        +		fmt.Fprintf(b, "Content: %q\n", e.Content)

      
        
        104
        +		dumpOptComment(b, e.Comment, depth+1)

      
        
        105
        +	case *IgnoredDirective:

      
        
        106
        +		indent(b, depth)

      
        
        107
        +		fmt.Fprintf(b, "IgnoredDirective %s\n", e.Span)

      
        
        108
        +	default:

      
        
        109
        +		indent(b, depth)

      
        
        110
        +		fmt.Fprintf(b, "Unknown %T\n", e)

      
        
        111
        +	}

      
        
        112
        +}

      
        
        113
        +

      
        
        114
        +func indent(b *strings.Builder, depth int) {

      
        
        115
        +	b.WriteString(strings.Repeat("  ", depth))

      
        
        116
        +}

      
        
        117
        +

      
        
        118
        +func dumpTransaction(b *strings.Builder, t *Transaction, depth int) {

      
        
        119
        +	indent(b, depth)

      
        
        120
        +	fmt.Fprintf(b, "Transaction %s\n", t.Span)

      
        
        121
        +	indent(b, depth+1)

      
        
        122
        +	fmt.Fprintf(b, "Date: %s\n", dumpDate(t.Date))

      
        
        123
        +	if t.SecondDate != nil {

      
        
        124
        +		indent(b, depth+1)

      
        
        125
        +		fmt.Fprintf(b, "SecondDate: %s\n", dumpDate(*t.SecondDate))

      
        
        126
        +	}

      
        
        127
        +	if t.Status != nil {

      
        
        128
        +		indent(b, depth+1)

      
        
        129
        +		fmt.Fprintf(b, "State: %q\n", t.Status.Value)

      
        
        130
        +	}

      
        
        131
        +	if t.Code != nil {

      
        
        132
        +		indent(b, depth+1)

      
        
        133
        +		fmt.Fprintf(b, "Code: %q\n", *t.Code)

      
        
        134
        +	}

      
        
        135
        +	if t.Payee != nil {

      
        
        136
        +		indent(b, depth+1)

      
        
        137
        +		fmt.Fprintf(b, "Payee: %q %s\n", t.Payee.Name, t.Payee.Span)

      
        
        138
        +	}

      
        
        139
        +	if t.Note != nil {

      
        
        140
        +		indent(b, depth+1)

      
        
        141
        +		fmt.Fprintf(b, "Note: %q\n", *t.Note)

      
        
        142
        +	}

      
        
        143
        +	dumpOptComment(b, t.Comment, depth+1)

      
        
        144
        +	if len(t.HeaderComments) > 0 {

      
        
        145
        +		indent(b, depth+1)

      
        
        146
        +		fmt.Fprintf(b, "HeaderComments %s\n", t.Span)

      
        
        147
        +		for _, c := range t.HeaderComments {

      
        
        148
        +			dumpComment(b, &c, depth+2)

      
        
        149
        +		}

      
        
        150
        +	}

      
        
        151
        +	for _, p := range t.Postings {

      
        
        152
        +		dumpPosting(b, p, depth+1)

      
        
        153
        +	}

      
        
        154
        +}

      
        
        155
        +

      
        
        156
        +func dumpAutomatedTransaction(b *strings.Builder, t *AutomatedTransaction, depth int) {

      
        
        157
        +	indent(b, depth)

      
        
        158
        +	fmt.Fprintf(b, "AutomatedTransaction %s\n", t.Span)

      
        
        159
        +	indent(b, depth+1)

      
        
        160
        +	fmt.Fprintf(b, "Expr: %q\n", t.Expr)

      
        
        161
        +	dumpOptComment(b, t.Comment, depth+1)

      
        
        162
        +	if len(t.HeaderComments) > 0 {

      
        
        163
        +		indent(b, depth+1)

      
        
        164
        +		fmt.Fprintf(b, "HeaderComments %s\n", t.Span)

      
        
        165
        +		for _, c := range t.HeaderComments {

      
        
        166
        +			dumpComment(b, c, depth+2)

      
        
        167
        +		}

      
        
        168
        +	}

      
        
        169
        +	for _, p := range t.Postings {

      
        
        170
        +		dumpPosting(b, p, depth+1)

      
        
        171
        +	}

      
        
        172
        +}

      
        
        173
        +

      
        
        174
        +func dumpPeriodicTransaction(b *strings.Builder, t *PeriodicTransaction, depth int) {

      
        
        175
        +	indent(b, depth)

      
        
        176
        +	fmt.Fprintf(b, "PeriodicTransaction %s\n", t.Span)

      
        
        177
        +	if t.Period != nil {

      
        
        178
        +		indent(b, depth+1)

      
        
        179
        +		fmt.Fprintf(b, "Period: %q\n", t.Period.Raw)

      
        
        180
        +		if t.Period.From != nil {

      
        
        181
        +			indent(b, depth+1)

      
        
        182
        +			fmt.Fprintf(b, "From: %s\n", dumpDate(*t.Period.From))

      
        
        183
        +		}

      
        
        184
        +		if t.Period.To != nil {

      
        
        185
        +			indent(b, depth+1)

      
        
        186
        +			fmt.Fprintf(b, "To: %s\n", dumpDate(*t.Period.To))

      
        
        187
        +		}

      
        
        188
        +	}

      
        
        189
        +	if t.Status != nil {

      
        
        190
        +		indent(b, depth+1)

      
        
        191
        +		fmt.Fprintf(b, "Status: %q\n", t.Status.Value)

      
        
        192
        +	}

      
        
        193
        +	if t.Code != nil {

      
        
        194
        +		indent(b, depth+1)

      
        
        195
        +		fmt.Fprintf(b, "Code: %q\n", *t.Code)

      
        
        196
        +	}

      
        
        197
        +	if t.Description != nil {

      
        
        198
        +		indent(b, depth+1)

      
        
        199
        +		fmt.Fprintf(b, "Description: %q\n", *t.Description)

      
        
        200
        +	}

      
        
        201
        +	if t.Note != nil {

      
        
        202
        +		indent(b, depth+1)

      
        
        203
        +		fmt.Fprintf(b, "Note: %q\n", *t.Note)

      
        
        204
        +	}

      
        
        205
        +	dumpOptComment(b, t.Comment, depth+1)

      
        
        206
        +	if len(t.HeaderComments) > 0 {

      
        
        207
        +		indent(b, depth+1)

      
        
        208
        +		fmt.Fprintf(b, "HeaderComments\n")

      
        
        209
        +		for _, c := range t.HeaderComments {

      
        
        210
        +			dumpComment(b, c, depth+2)

      
        
        211
        +		}

      
        
        212
        +	}

      
        
        213
        +	for _, p := range t.Postings {

      
        
        214
        +		dumpPosting(b, p, depth+1)

      
        
        215
        +	}

      
        
        216
        +}

      
        
        217
        +

      
        
        218
        +func dumpPosting(b *strings.Builder, p *Posting, depth int) {

      
        
        219
        +	indent(b, depth)

      
        
        220
        +	fmt.Fprintf(b, "Posting %s\n", p.Span)

      
        
        221
        +	if p.Type != PostingReal {

      
        
        222
        +		indent(b, depth+1)

      
        
        223
        +		fmt.Fprintf(b, "Type: %s\n", p.Type)

      
        
        224
        +	}

      
        
        225
        +	if p.Status != nil {

      
        
        226
        +		indent(b, depth+1)

      
        
        227
        +		fmt.Fprintf(b, "Status: %q\n", p.Status.Value)

      
        
        228
        +	}

      
        
        229
        +	dumpAccount(b, p.Account, depth+1)

      
        
        230
        +	if p.Amount != nil {

      
        
        231
        +		dumpAmount(b, p.Amount, depth+1)

      
        
        232
        +	} else {

      
        
        233
        +		indent(b, depth+1)

      
        
        234
        +		fmt.Fprintf(b, "Amount: <elided>\n")

      
        
        235
        +	}

      
        
        236
        +	if p.Cost != nil {

      
        
        237
        +		dumpCost(b, p.Cost, depth+1)

      
        
        238
        +	}

      
        
        239
        +	if p.Balance != nil {

      
        
        240
        +		dumpBalanceAssertion(b, p.Balance, depth+1)

      
        
        241
        +	}

      
        
        242
        +	dumpOptComment(b, p.Comment, depth+1)

      
        
        243
        +	if len(p.Comments) > 0 {

      
        
        244
        +		for _, c := range p.Comments {

      
        
        245
        +			dumpComment(b, &c, depth+1)

      
        
        246
        +		}

      
        
        247
        +	}

      
        
        248
        +}

      
        
        249
        +

      
        
        250
        +func dumpAmount(b *strings.Builder, a *Amount, depth int) {

      
        
        251
        +	indent(b, depth)

      
        
        252
        +	fmt.Fprintf(b, "Amount %s\n", a.Span)

      
        
        253
        +	indent(b, depth+1)

      
        
        254
        +	fmt.Fprintf(b, "Quantity: %s\n", a.Quantity.String())

      
        
        255
        +	indent(b, depth+1)

      
        
        256
        +	fmt.Fprintf(b, "Commodity: %q\n", a.Commodity)

      
        
        257
        +	indent(b, depth+1)

      
        
        258
        +	fmt.Fprintf(b, "CommodityPos: %s\n", a.CommodityPos)

      
        
        259
        +	indent(b, depth+1)

      
        
        260
        +	fmt.Fprintf(b, "HasSpace: %v\n", a.HasSpace)

      
        
        261
        +	if a.IsExpr {

      
        
        262
        +		indent(b, depth+1)

      
        
        263
        +		fmt.Fprintf(b, "IsExpr: true\n")

      
        
        264
        +	}

      
        
        265
        +	if a.Expr != "" {

      
        
        266
        +		indent(b, depth+1)

      
        
        267
        +		fmt.Fprintf(b, "Expr: %q\n", a.Expr)

      
        
        268
        +	}

      
        
        269
        +	indent(b, depth+1)

      
        
        270
        +	fmt.Fprintf(b, "Precision: %d\n", a.QuantityFmt.Precision)

      
        
        271
        +	indent(b, depth+1)

      
        
        272
        +	fmt.Fprintf(b, "Decimal: %q\n", string(a.QuantityFmt.Decimal))

      
        
        273
        +	if a.QuantityFmt.Thousands != 0 {

      
        
        274
        +		indent(b, depth+1)

      
        
        275
        +		fmt.Fprintf(b, "Thousands: %q\n", string(a.QuantityFmt.Thousands))

      
        
        276
        +	}

      
        
        277
        +}

      
        
        278
        +

      
        
        279
        +func dumpCost(b *strings.Builder, c *Cost, depth int) {

      
        
        280
        +	indent(b, depth)

      
        
        281
        +	if c.IsTotal {

      
        
        282
        +		fmt.Fprintf(b, "Cost(total) %s\n", c.Span)

      
        
        283
        +	} else {

      
        
        284
        +		fmt.Fprintf(b, "Cost(unit) %s\n", c.Span)

      
        
        285
        +	}

      
        
        286
        +	dumpAmount(b, c.Amount, depth+1)

      
        
        287
        +}

      
        
        288
        +

      
        
        289
        +func dumpBalanceAssertion(b *strings.Builder, ba *BalanceAssertion, depth int) {

      
        
        290
        +	indent(b, depth)

      
        
        291
        +	fmt.Fprintf(b, "BalanceAssertion %s\n", ba.Span)

      
        
        292
        +	indent(b, depth+1)

      
        
        293
        +	fmt.Fprintf(b, "IsStrict: %v\n", ba.IsStrict)

      
        
        294
        +	indent(b, depth+1)

      
        
        295
        +	fmt.Fprintf(b, "IsInclusive: %v\n", ba.IsInclusive)

      
        
        296
        +	dumpAmount(b, &ba.Amount, depth+1)

      
        
        297
        +}

      
        
        298
        +

      
        
        299
        +func dumpAccount(b *strings.Builder, a Account, depth int) {

      
        
        300
        +	indent(b, depth)

      
        
        301
        +	fmt.Fprintf(b, "Account %q %s\n", a.Name, a.Span)

      
        
        302
        +}

      
        
        303
        +

      
        
        304
        +func dumpAccountDirective(b *strings.Builder, a *AccountDirective, depth int) {

      
        
        305
        +	indent(b, depth)

      
        
        306
        +	fmt.Fprintf(b, "AccountDirective %s\n", a.Span)

      
        
        307
        +	dumpAccount(b, a.Account, depth+1)

      
        
        308
        +	dumpOptComment(b, a.Comment, depth+1)

      
        
        309
        +}

      
        
        310
        +

      
        
        311
        +func dumpCommodityDirective(b *strings.Builder, c *CommodityDirective, depth int) {

      
        
        312
        +	indent(b, depth)

      
        
        313
        +	fmt.Fprintf(b, "CommodityDirective %s\n", c.Span)

      
        
        314
        +	indent(b, depth+1)

      
        
        315
        +	fmt.Fprintf(b, "Commodity: %q\n", c.Commodity)

      
        
        316
        +	if c.Format != nil {

      
        
        317
        +		dumpAmount(b, c.Format, depth+1)

      
        
        318
        +	}

      
        
        319
        +	dumpOptComment(b, c.Comment, depth+1)

      
        
        320
        +}

      
        
        321
        +

      
        
        322
        +func dumpMarketPriceDirective(b *strings.Builder, m *MarketPriceDirective, depth int) {

      
        
        323
        +	indent(b, depth)

      
        
        324
        +	fmt.Fprintf(b, "MarketPriceDirective %s\n", m.Span)

      
        
        325
        +	indent(b, depth+1)

      
        
        326
        +	fmt.Fprintf(b, "Date: %s\n", dumpDate(m.DateTime.Date))

      
        
        327
        +	if m.DateTime.Time != nil {

      
        
        328
        +		indent(b, depth+1)

      
        
        329
        +		fmt.Fprintf(b, "Time: %02d:%02d:%02d\n", m.DateTime.Time.Hour, m.DateTime.Time.Minute, m.DateTime.Time.Second)

      
        
        330
        +	}

      
        
        331
        +	indent(b, depth+1)

      
        
        332
        +	fmt.Fprintf(b, "Commodity: %q\n", m.Commodity)

      
        
        333
        +	dumpAmount(b, &m.Amount, depth+1)

      
        
        334
        +}

      
        
        335
        +

      
        
        336
        +func dumpComment(b *strings.Builder, c *Comment, depth int) {

      
        
        337
        +	indent(b, depth)

      
        
        338
        +	fmt.Fprintf(b, "Comment %s\n", c.Span)

      
        
        339
        +	indent(b, depth+1)

      
        
        340
        +	fmt.Fprintf(b, "Marker: %q\n", string(c.Marker))

      
        
        341
        +	indent(b, depth+1)

      
        
        342
        +	fmt.Fprintf(b, "Text: %q\n", c.Text)

      
        
        343
        +}

      
        
        344
        +

      
        
        345
        +func dumpOptComment(b *strings.Builder, c *Comment, depth int) {

      
        
        346
        +	if c == nil {

      
        
        347
        +		return

      
        
        348
        +	}

      
        
        349
        +	dumpComment(b, c, depth)

      
        
        350
        +}

      
        
        351
        +

      
        
        352
        +func dumpDate(d Date) string {

      
        
        353
        +	return fmt.Sprintf("%04d%s%02d%s%02d", d.Year, string(d.Sep), d.Month, string(d.Sep), d.Day)

      
        
        354
        +}

      

···
        
        1
        +package ast

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"github.com/olexsmir/ledger-tools/journal/token"

      
        
        5
        +	"github.com/shopspring/decimal"

      
        
        6
        +)

      
        
        7
        +

      
        
        8
        +type BlankLine struct{ Span token.Span }

      
        
        9
        +

      
        
        10
        +func (BlankLine) entryNode() {}

      
        
        11
        +

      
        
        12
        +type Transaction struct {

      
        
        13
        +	Date           Date

      
        
        14
        +	SecondDate     *Date

      
        
        15
        +	Status         *Status

      
        
        16
        +	Code           *string

      
        
        17
        +	Payee          *Payee

      
        
        18
        +	Note           *string   // part after |

      
        
        19
        +	Comment        *Comment  // inline ; on header line

      
        
        20
        +	HeaderComments []Comment // indented ; lines before first posting

      
        
        21
        +	Postings       []*Posting

      
        
        22
        +	Span           token.Span

      
        
        23
        +}

      
        
        24
        +

      
        
        25
        +func (Transaction) entryNode() {}

      
        
        26
        +

      
        
        27
        +type Period struct {

      
        
        28
        +	Raw  string // "monthly", "every 2 weeks"

      
        
        29
        +	From *Date

      
        
        30
        +	To   *Date

      
        
        31
        +	Span token.Span

      
        
        32
        +}

      
        
        33
        +

      
        
        34
        +func (Period) entryNode() {}

      
        
        35
        +

      
        
        36
        +type PeriodicTransaction struct {

      
        
        37
        +	Period         *Period

      
        
        38
        +	Status         *Status

      
        
        39
        +	Code           *string

      
        
        40
        +	Description    *string

      
        
        41
        +	Note           *string

      
        
        42
        +	Comment        *Comment

      
        
        43
        +	HeaderComments []*Comment

      
        
        44
        +	Postings       []*Posting

      
        
        45
        +	Span           token.Span

      
        
        46
        +}

      
        
        47
        +

      
        
        48
        +func (PeriodicTransaction) entryNode() {}

      
        
        49
        +

      
        
        50
        +type AutomatedTransaction struct {

      
        
        51
        +	Expr           string

      
        
        52
        +	Postings       []*Posting

      
        
        53
        +	Comment        *Comment   // inline ; on header line

      
        
        54
        +	HeaderComments []*Comment // indented ; lines before first posting

      
        
        55
        +	Span           token.Span

      
        
        56
        +}

      
        
        57
        +

      
        
        58
        +func (AutomatedTransaction) entryNode() {}

      
        
        59
        +

      
        
        60
        +type PostingType int

      
        
        61
        +

      
        
        62
        +const (

      
        
        63
        +	PostingReal              PostingType = iota

      
        
        64
        +	PostingVirtualBalanced               // '['

      
        
        65
        +	PostingVirtualUnbalanced             // '('

      
        
        66
        +)

      
        
        67
        +

      
        
        68
        +func (p PostingType) String() string {

      
        
        69
        +	switch p {

      
        
        70
        +	case PostingReal:

      
        
        71
        +		return "real"

      
        
        72
        +	case PostingVirtualBalanced:

      
        
        73
        +		return "balanced virtual"

      
        
        74
        +	case PostingVirtualUnbalanced:

      
        
        75
        +		return "unbalanced virtual"

      
        
        76
        +	default:

      
        
        77
        +		panic("unreachable")

      
        
        78
        +	}

      
        
        79
        +}

      
        
        80
        +

      
        
        81
        +type Posting struct {

      
        
        82
        +	Type     PostingType

      
        
        83
        +	Status   *Status

      
        
        84
        +	Account  Account

      
        
        85
        +	Amount   *Amount // nil == auto-balancing

      
        
        86
        +	Cost     *Cost   // @ @@

      
        
        87
        +	Balance  *BalanceAssertion

      
        
        88
        +	Comment  *Comment

      
        
        89
        +	Comments []Comment // continuation comment lines

      
        
        90
        +	Span     token.Span

      
        
        91
        +}

      
        
        92
        +

      
        
        93
        +type Amount struct {

      
        
        94
        +	IsNegative   bool

      
        
        95
        +	Quantity     decimal.Decimal

      
        
        96
        +	QuantityFmt  QuantityFormat

      
        
        97
        +	Commodity    string

      
        
        98
        +	CommodityPos CommodityPos // Before | After

      
        
        99
        +	HasSpace     bool         // "$10" vs "$ 10"

      
        
        100
        +	IsExpr       bool         // e.g: *-1

      
        
        101
        +	Expr         string       // expression text e.g. "amount * -1". set only if IsExpr is true

      
        
        102
        +	Span         token.Span

      
        
        103
        +}

      
        
        104
        +

      
        
        105
        +type Cost struct {

      
        
        106
        +	IsTotal bool // @ vs @@

      
        
        107
        +	Amount  *Amount

      
        
        108
        +	Span    token.Span

      
        
        109
        +}

      
        
        110
        +

      
        
        111
        +type BalanceAssertion struct {

      
        
        112
        +	IsStrict    bool // ==  vs =

      
        
        113
        +	IsInclusive bool // ===

      
        
        114
        +	Amount      Amount

      
        
        115
        +	Span        token.Span

      
        
        116
        +}

      
        
        117
        +

      
        
        118
        +type CommodityPos int

      
        
        119
        +

      
        
        120
        +func (c CommodityPos) String() string {

      
        
        121
        +	if c == CommodityBefore {

      
        
        122
        +		return "Before"

      
        
        123
        +	}

      
        
        124
        +	return "After"

      
        
        125
        +}

      
        
        126
        +

      
        
        127
        +const (

      
        
        128
        +	CommodityBefore CommodityPos = iota

      
        
        129
        +	CommodityAfter

      
        
        130
        +)

      
        
        131
        +

      
        
        132
        +type QuantityFormat struct {

      
        
        133
        +	Decimal   byte // '.' or ','

      
        
        134
        +	Thousands byte // ',' '.' ' ' or 0

      
        
        135
        +	Precision int

      
        
        136
        +}

      

···
        
        1
        +package ast

      
        
        2
        +

      
        
        3
        +// todo: support lots

      

···
        
        1
        +package lexer

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"fmt"

      
        
        5
        +	"strings"

      
        
        6
        +

      
        
        7
        +	"github.com/olexsmir/ledger-tools/journal/token"

      
        
        8
        +)

      
        
        9
        +

      
        
        10
        +func (l *Lexer) Dump() string {

      
        
        11
        +	var b strings.Builder

      
        
        12
        +	for {

      
        
        13
        +		t := l.Next()

      
        
        14
        +		fmt.Fprintf(&b, "%-12s %-20q %d:%d-%d:%d\n",

      
        
        15
        +			t.Type,

      
        
        16
        +			t.Literal,

      
        
        17
        +			t.Span.Start.Line,

      
        
        18
        +			t.Span.Start.Col,

      
        
        19
        +			t.Span.End.Line,

      
        
        20
        +			t.Span.End.Col)

      
        
        21
        +		if t.Type == token.EOF {

      
        
        22
        +			break

      
        
        23
        +		}

      
        
        24
        +	}

      
        
        25
        +	return b.String()

      
        
        26
        +}

      

···
        
        1
        +package lexer

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"strings"

      
        
        5
        +	"unicode"

      
        
        6
        +	"unicode/utf8"

      
        
        7
        +

      
        
        8
        +	"github.com/olexsmir/ledger-tools/journal/token"

      
        
        9
        +)

      
        
        10
        +

      
        
        11
        +type Mode uint

      
        
        12
        +

      
        
        13
        +const (

      
        
        14
        +	// start of a line, nothing consumed

      
        
        15
        +	ModeDefault Mode = iota

      
        
        16
        +

      
        
        17
        +	// after ; # * % ; at start of line, or anywhere inline

      
        
        18
        +	// everything until \n is comment text

      
        
        19
        +	ModeComment

      
        
        20
        +

      
        
        21
        +	// after lexing a date at column 0

      
        
        22
        +	// expects: optional status, optional code, description, comment

      
        
        23
        +	ModeTransaction

      
        
        24
        +

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

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

      
        
        27
        +	ModePosting

      
        
        28
        +

      
        
        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
        +	// after a directive keyword like account, commodity, include

      
        
        38
        +	// expects: rest of directive content

      
        
        39
        +	ModeDirective

      
        
        40
        +)

      
        
        41
        +

      
        
        42
        +type Lexer struct {

      
        
        43
        +	file  string

      
        
        44
        +	input []byte

      
        
        45
        +	mode  Mode

      
        
        46
        +

      
        
        47
        +	ch     rune // current rune (0 = EOF/sentinel)

      
        
        48
        +	chSize int  // byte size of current rune

      
        
        49
        +	pos    int  // current byte offset (points at ch)

      
        
        50
        +	rpos   int  // next byte offset to read (one ahead of pos)

      
        
        51
        +	col    int  // current column (1-based)

      
        
        52
        +	line   int  // current line (1-based)

      
        
        53
        +

      
        
        54
        +	postingExpectAccount bool

      
        
        55
        +}

      
        
        56
        +

      
        
        57
        +func New(file string, input []byte) *Lexer {

      
        
        58
        +	l := &Lexer{

      
        
        59
        +		file:  file,

      
        
        60
        +		input: input,

      
        
        61
        +		line:  1,

      
        
        62
        +	}

      
        
        63
        +	l.advance()

      
        
        64
        +	if l.ch == '\uFEFF' { // start of the input

      
        
        65
        +		l.advance()

      
        
        66
        +	}

      
        
        67
        +	return l

      
        
        68
        +}

      
        
        69
        +

      
        
        70
        +// Next returns next token in the input

      
        
        71
        +func (l *Lexer) Next() token.Token {

      
        
        72
        +	switch l.mode {

      
        
        73
        +	case ModeDefault:

      
        
        74
        +		return l.lexDefault()

      
        
        75
        +	case ModeComment:

      
        
        76
        +		return l.lexComment()

      
        
        77
        +	case ModeTransaction:

      
        
        78
        +		return l.lexTransaction()

      
        
        79
        +	case ModePosting:

      
        
        80
        +		return l.lexPosting()

      
        
        81
        +	case ModePeriodic:

      
        
        82
        +		return l.lexPeriodic()

      
        
        83
        +	case ModeAutomated:

      
        
        84
        +		return l.lexAutomated()

      
        
        85
        +	case ModeDirective:

      
        
        86
        +		return l.lexDirective()

      
        
        87
        +	}

      
        
        88
        +	panic("unreachable")

      
        
        89
        +}

      
        
        90
        +

      
        
        91
        +func (l *Lexer) lexDefault() token.Token {

      
        
        92
        +	switch {

      
        
        93
        +	case l.ch == 0:

      
        
        94
        +		return l.token(token.EOF, "")

      
        
        95
        +	case l.ch == '\n':

      
        
        96
        +		return l.lexNewline()

      
        
        97
        +	case l.ch == '\r':

      
        
        98
        +		l.col = 0

      
        
        99
        +		l.advance()

      
        
        100
        +		return l.lexNewline()

      
        
        101
        +	case l.ch == ' ' || l.ch == '\t':

      
        
        102
        +		tok := l.lexIndent()

      
        
        103
        +		l.mode = ModePosting

      
        
        104
        +		l.postingExpectAccount = true

      
        
        105
        +		return tok

      
        
        106
        +	case l.ch == ';' || l.ch == '#' || l.ch == '%':

      
        
        107
        +		l.mode = ModeComment

      
        
        108
        +		return l.lexSingle(token.SEMICOLON) // todo: ??

      
        
        109
        +	case l.ch == '*': // * at col 0 == comment

      
        
        110
        +		l.mode = ModeComment

      
        
        111
        +		return l.lexSingle(token.STAR)

      
        
        112
        +	case l.ch == '~':

      
        
        113
        +		l.mode = ModePeriodic

      
        
        114
        +		return l.lexSingle(token.TILDE)

      
        
        115
        +	case l.ch == '=':

      
        
        116
        +		l.mode = ModeAutomated

      
        
        117
        +		return l.lexSingle(token.EQ)

      
        
        118
        +	case l.ch == '+':

      
        
        119
        +		return l.lexSingle(token.PLUS)

      
        
        120
        +	case l.ch == '-':

      
        
        121
        +		return l.lexSingle(token.MINUS)

      
        
        122
        +	case l.ch == '.':

      
        
        123
        +		return l.lexSingle(token.TEXT)

      
        
        124
        +	case l.isAlpha():

      
        
        125
        +		return l.lexKeyword()

      
        
        126
        +	case l.isDigit():

      
        
        127
        +		if !l.isDate() {

      
        
        128
        +			s := l.save()

      
        
        129
        +			for l.isDigit() || l.ch == '-' || l.ch == '/' || l.ch == '.' {

      
        
        130
        +				l.advance()

      
        
        131
        +			}

      
        
        132
        +			return token.Token{Type: token.ILLEGAL, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        133
        +		}

      
        
        134
        +		tok := l.lexDate()

      
        
        135
        +		l.mode = ModeTransaction

      
        
        136
        +		return tok

      
        
        137
        +	default:

      
        
        138
        +		s := l.save()

      
        
        139
        +		l.advance()

      
        
        140
        +		return token.Token{Type: token.ILLEGAL, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        141
        +	}

      
        
        142
        +}

      
        
        143
        +

      
        
        144
        +func (l *Lexer) lexComment() token.Token {

      
        
        145
        +	if l.ch == '\n' || l.ch == 0 {

      
        
        146
        +		l.mode = ModeDefault

      
        
        147
        +		return l.lexNewline()

      
        
        148
        +	}

      
        
        149
        +

      
        
        150
        +	for l.ch == ' ' || l.ch == '\t' {

      
        
        151
        +		l.lexWhitespace()

      
        
        152
        +	}

      
        
        153
        +

      
        
        154
        +	if l.ch == '\n' || l.ch == 0 {

      
        
        155
        +		l.mode = ModeDefault

      
        
        156
        +		return l.lexNewline()

      
        
        157
        +	}

      
        
        158
        +

      
        
        159
        +	s := l.save()

      
        
        160
        +	for l.ch != '\n' && l.ch != 0 {

      
        
        161
        +		l.advance()

      
        
        162
        +	}

      
        
        163
        +	return token.Token{Type: token.TEXT, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        164
        +}

      
        
        165
        +

      
        
        166
        +func (l *Lexer) lexTransaction() token.Token {

      
        
        167
        +	switch l.ch {

      
        
        168
        +	case 0:

      
        
        169
        +		return l.token(token.EOF, "")

      
        
        170
        +	case '\n':

      
        
        171
        +		l.mode = ModeDefault

      
        
        172
        +		return l.lexNewline()

      
        
        173
        +	case '\r':

      
        
        174
        +		l.col = 0

      
        
        175
        +		l.advance()

      
        
        176
        +		return l.lexNewline()

      
        
        177
        +	case ';':

      
        
        178
        +		l.mode = ModeComment

      
        
        179
        +		return l.lexSingle(token.SEMICOLON)

      
        
        180
        +	case ' ', '\t':

      
        
        181
        +		return l.lexWhitespace()

      
        
        182
        +	case '*': // * after date = status

      
        
        183
        +		return l.lexSingle(token.STAR)

      
        
        184
        +	case '!':

      
        
        185
        +		return l.lexSingle(token.BANG)

      
        
        186
        +	case '|':

      
        
        187
        +		return l.lexSingle(token.PIPE)

      
        
        188
        +	case '+':

      
        
        189
        +		return l.lexSingle(token.PLUS)

      
        
        190
        +	case '-':

      
        
        191
        +		return l.lexSingle(token.MINUS)

      
        
        192
        +	case '=':

      
        
        193
        +		return l.lexEquals()

      
        
        194
        +	default: // description / payee

      
        
        195
        +		if l.isDate() { // secondsry date after =

      
        
        196
        +			return l.lexDate()

      
        
        197
        +		}

      
        
        198
        +		return l.lexText()

      
        
        199
        +	}

      
        
        200
        +}

      
        
        201
        +

      
        
        202
        +func (l *Lexer) lexPeriodic() token.Token {

      
        
        203
        +	switch l.ch {

      
        
        204
        +	case 0:

      
        
        205
        +		return l.token(token.EOF, "")

      
        
        206
        +	case '\n':

      
        
        207
        +		l.mode = ModeDefault

      
        
        208
        +		return l.lexNewline()

      
        
        209
        +	case '\r':

      
        
        210
        +		l.col = 0

      
        
        211
        +		l.advance()

      
        
        212
        +		return l.lexNewline()

      
        
        213
        +	case ';', '%', '#':

      
        
        214
        +		l.mode = ModeComment

      
        
        215
        +		return l.lexSingle(token.SEMICOLON) // todo: ??

      
        
        216
        +	case ' ', '\t':

      
        
        217
        +		return l.lexWhitespace()

      
        
        218
        +	default:

      
        
        219
        +		return l.lexText()

      
        
        220
        +	}

      
        
        221
        +}

      
        
        222
        +

      
        
        223
        +func (l *Lexer) lexAutomated() token.Token {

      
        
        224
        +	switch l.ch {

      
        
        225
        +	case 0:

      
        
        226
        +		return l.token(token.EOF, "")

      
        
        227
        +	case '\n':

      
        
        228
        +		l.mode = ModeDefault

      
        
        229
        +		return l.lexNewline()

      
        
        230
        +	case '\r':

      
        
        231
        +		l.col = 0

      
        
        232
        +		l.advance()

      
        
        233
        +		return l.lexNewline()

      
        
        234
        +	case ' ', '\t':

      
        
        235
        +		return l.lexWhitespace()

      
        
        236
        +	case ';', '%', '#':

      
        
        237
        +		l.mode = ModeComment

      
        
        238
        +		return l.lexSingle(token.SEMICOLON) // todo: ??

      
        
        239
        +	default:

      
        
        240
        +		return l.lexText()

      
        
        241
        +	}

      
        
        242
        +}

      
        
        243
        +

      
        
        244
        +func (l *Lexer) lexPosting() token.Token {

      
        
        245
        +	switch {

      
        
        246
        +	case l.ch == 0:

      
        
        247
        +		l.postingExpectAccount = false

      
        
        248
        +		return l.token(token.EOF, "")

      
        
        249
        +	case l.ch == '\n':

      
        
        250
        +		l.postingExpectAccount = false

      
        
        251
        +		l.mode = ModeDefault

      
        
        252
        +		return l.lexNewline()

      
        
        253
        +	case l.ch == ';':

      
        
        254
        +		l.postingExpectAccount = false

      
        
        255
        +		l.mode = ModeComment

      
        
        256
        +		return l.lexSingle(token.SEMICOLON)

      
        
        257
        +	case l.ch == ' ' || l.ch == '\t':

      
        
        258
        +		return l.lexWhitespace()

      
        
        259
        +	case l.postingExpectAccount && l.ch == '*':

      
        
        260
        +		return l.lexSingle(token.STAR)

      
        
        261
        +	case l.postingExpectAccount && l.ch == '!':

      
        
        262
        +		return l.lexSingle(token.BANG)

      
        
        263
        +	case l.ch == '=':

      
        
        264
        +		return l.lexEquals()

      
        
        265
        +	case l.ch == '@':

      
        
        266
        +		return l.lexAt()

      
        
        267
        +	case l.ch == '{':

      
        
        268
        +		return l.lexLBrace()

      
        
        269
        +	case l.ch == '}':

      
        
        270
        +		return l.lexRBrace()

      
        
        271
        +	case l.ch == '(':

      
        
        272
        +		if !l.postingExpectAccount {

      
        
        273
        +			return l.lexParenExpr()

      
        
        274
        +		}

      
        
        275
        +		return l.lexSingle(token.LPAREN)

      
        
        276
        +	case l.ch == ')':

      
        
        277
        +		return l.lexSingle(token.RPAREN)

      
        
        278
        +	case l.ch == '[':

      
        
        279
        +		return l.lexSingle(token.LBRACKET)

      
        
        280
        +	case l.ch == ']':

      
        
        281
        +		return l.lexSingle(token.RBRACKET)

      
        
        282
        +	case l.postingExpectAccount && l.ch != '*' && l.ch != '!' && l.ch != '(' && l.ch != '[':

      
        
        283
        +		l.postingExpectAccount = false

      
        
        284
        +		return l.lexAccountText()

      
        
        285
        +	case l.ch == '*': // after account name

      
        
        286
        +		return l.lexSingle(token.STAR)

      
        
        287
        +	case l.isDigit(), l.ch == '.':

      
        
        288
        +		return l.lexNumber()

      
        
        289
        +	case l.ch == '-':

      
        
        290
        +		return l.lexSingle(token.MINUS)

      
        
        291
        +	case l.ch == '+':

      
        
        292
        +		return l.lexSingle(token.PLUS)

      
        
        293
        +	case l.isCommodityStart():

      
        
        294
        +		return l.lexCommodityMark()

      
        
        295
        +	case l.ch >= 'a' && l.ch <= 'z':

      
        
        296
        +		return l.lexCommodityMark()

      
        
        297
        +	default:

      
        
        298
        +		return l.lexAccountText()

      
        
        299
        +	}

      
        
        300
        +}

      
        
        301
        +

      
        
        302
        +func (l *Lexer) lexDirective() token.Token {

      
        
        303
        +	switch l.ch {

      
        
        304
        +	case '\n', 0:

      
        
        305
        +		l.mode = ModeDefault

      
        
        306
        +		return l.lexNewline()

      
        
        307
        +	case ';':

      
        
        308
        +		l.mode = ModeComment

      
        
        309
        +		return l.lexSingle(token.SEMICOLON)

      
        
        310
        +	case ' ', '\t':

      
        
        311
        +		return l.lexWhitespace()

      
        
        312
        +	case '=':

      
        
        313
        +		return l.lexSingle(token.EQ)

      
        
        314
        +	case '+':

      
        
        315
        +		return l.lexSingle(token.PLUS)

      
        
        316
        +	case '-':

      
        
        317
        +		return l.lexSingle(token.MINUS)

      
        
        318
        +	case '.':

      
        
        319
        +		return l.lexSingle(token.TEXT)

      
        
        320
        +	default:

      
        
        321
        +		if l.isCommodityStart() {

      
        
        322
        +			return l.lexCommodityMark()

      
        
        323
        +		}

      
        
        324
        +		if l.isTime() {

      
        
        325
        +			return l.lexTime()

      
        
        326
        +		}

      
        
        327
        +		if l.isDate() {

      
        
        328
        +			return l.lexDate()

      
        
        329
        +		}

      
        
        330
        +		if l.isDigit() {

      
        
        331
        +			return l.lexNumber()

      
        
        332
        +		}

      
        
        333
        +		return l.lexText()

      
        
        334
        +	}

      
        
        335
        +	// case l.ch == '/': // regex in 'alias'

      
        
        336
        +	// 	return l.lexSingle(token.SLASH)

      
        
        337
        +}

      
        
        338
        +

      
        
        339
        +func (l *Lexer) lexSingle(kind token.Type) token.Token {

      
        
        340
        +	s := l.save()

      
        
        341
        +	l.advance()

      
        
        342
        +	return token.Token{

      
        
        343
        +		Type:    kind,

      
        
        344
        +		Literal: string(l.input[s.offset:l.pos]),

      
        
        345
        +		Span:    l.span(s),

      
        
        346
        +	}

      
        
        347
        +}

      
        
        348
        +

      
        
        349
        +func (l *Lexer) lexNewline() token.Token {

      
        
        350
        +	s := l.save()

      
        
        351
        +	l.advance()

      
        
        352
        +	l.mode = ModeDefault

      
        
        353
        +	return token.Token{Type: token.NEWLINE, Literal: "\n", Span: l.span(s)}

      
        
        354
        +}

      
        
        355
        +

      
        
        356
        +func (l *Lexer) lexWhitespace() token.Token {

      
        
        357
        +	s := l.save()

      
        
        358
        +	for l.ch == ' ' || l.ch == '\t' {

      
        
        359
        +		l.advance()

      
        
        360
        +	}

      
        
        361
        +	lit := string(l.input[s.offset:l.pos])

      
        
        362
        +	return token.Token{Type: token.WHITESPACE, Literal: lit, Span: l.span(s)}

      
        
        363
        +}

      
        
        364
        +

      
        
        365
        +func (l *Lexer) lexIndent() token.Token {

      
        
        366
        +	s := l.save()

      
        
        367
        +	for l.ch == ' ' || l.ch == '\t' {

      
        
        368
        +		l.advance()

      
        
        369
        +	}

      
        
        370
        +	lit := string(l.input[s.offset:l.pos])

      
        
        371
        +	return token.Token{Type: token.INDENT, Literal: lit, Span: l.span(s)}

      
        
        372
        +}

      
        
        373
        +

      
        
        374
        +func (l *Lexer) lexEquals() token.Token {

      
        
        375
        +	s := l.save()

      
        
        376
        +	l.advance()

      
        
        377
        +	if l.ch == '=' {

      
        
        378
        +		l.advance()

      
        
        379
        +		switch l.ch {

      
        
        380
        +		case '=':

      
        
        381
        +			l.advance()

      
        
        382
        +			return token.Token{Type: token.EQEQEQ, Literal: "===", Span: l.span(s)}

      
        
        383
        +		case '*':

      
        
        384
        +			l.advance()

      
        
        385
        +			return token.Token{Type: token.EQEQEQ, Literal: "==*", Span: l.span(s)}

      
        
        386
        +		default:

      
        
        387
        +			return token.Token{Type: token.EQEQ, Literal: "==", Span: l.span(s)}

      
        
        388
        +		}

      
        
        389
        +	}

      
        
        390
        +	return token.Token{Type: token.EQ, Literal: "=", Span: l.span(s)}

      
        
        391
        +}

      
        
        392
        +

      
        
        393
        +func (l *Lexer) lexAt() token.Token {

      
        
        394
        +	s := l.save()

      
        
        395
        +	l.advance()

      
        
        396
        +	if l.ch == '@' {

      
        
        397
        +		l.advance()

      
        
        398
        +		return token.Token{Type: token.ATAT, Literal: "@@", Span: l.span(s)}

      
        
        399
        +	}

      
        
        400
        +	return token.Token{Type: token.AT, Literal: "@", Span: l.span(s)}

      
        
        401
        +}

      
        
        402
        +

      
        
        403
        +func (l *Lexer) lexText() token.Token {

      
        
        404
        +	s := l.save()

      
        
        405
        +	l.advance()

      
        
        406
        +	for l.ch != '\n' && l.ch != ';' && l.ch != 0 && l.ch != ' ' && l.ch != '\t' {

      
        
        407
        +		l.advance()

      
        
        408
        +	}

      
        
        409
        +	lit := string(l.input[s.offset:l.pos])

      
        
        410
        +	return token.Token{Type: token.TEXT, Literal: lit, Span: l.span(s)}

      
        
        411
        +}

      
        
        412
        +

      
        
        413
        +func (l *Lexer) lexAccountText() token.Token {

      
        
        414
        +	s := l.save()

      
        
        415
        +	for l.ch != '\n' && l.ch != ';' && l.ch != 0 && l.ch != ')' && l.ch != ']' {

      
        
        416
        +		// two spaces = end of account name

      
        
        417
        +		if l.isTwoSpaces() {

      
        
        418
        +			break

      
        
        419
        +		}

      
        
        420
        +		l.advance()

      
        
        421
        +	}

      
        
        422
        +	lit := string(l.input[s.offset:l.pos])

      
        
        423
        +	return token.Token{Type: token.TEXT, Literal: lit, Span: l.span(s)}

      
        
        424
        +}

      
        
        425
        +

      
        
        426
        +func (l *Lexer) lexParenExpr() token.Token {

      
        
        427
        +	s := l.save()

      
        
        428
        +	depth := 0

      
        
        429
        +	for l.ch != '\n' && l.ch != 0 {

      
        
        430
        +		if l.ch == '(' {

      
        
        431
        +			depth++

      
        
        432
        +		} else if l.ch == ')' {

      
        
        433
        +			depth--

      
        
        434
        +			if depth == 0 {

      
        
        435
        +				l.advance()

      
        
        436
        +				break

      
        
        437
        +			}

      
        
        438
        +		}

      
        
        439
        +		l.advance()

      
        
        440
        +	}

      
        
        441
        +	lit := string(l.input[s.offset:l.pos])

      
        
        442
        +	return token.Token{Type: token.PARENEXPR, Literal: lit, Span: l.span(s)}

      
        
        443
        +}

      
        
        444
        +

      
        
        445
        +func (l *Lexer) lexNumber() token.Token {

      
        
        446
        +	s := l.save()

      
        
        447
        +	for l.isDigit() || l.ch == '.' || l.ch == ',' || l.ch == '_' {

      
        
        448
        +		l.advance()

      
        
        449
        +	}

      
        
        450
        +	lit := string(l.input[s.offset:l.pos])

      
        
        451
        +	kind := token.INT

      
        
        452
        +	if strings.ContainsAny(lit, ".,") {

      
        
        453
        +		kind = token.DECIMAL

      
        
        454
        +	}

      
        
        455
        +	return token.Token{Type: kind, Literal: lit, Span: l.span(s)}

      
        
        456
        +}

      
        
        457
        +

      
        
        458
        +func (l *Lexer) lexKeyword() token.Token {

      
        
        459
        +	s := l.save()

      
        
        460
        +	for l.ch != 0 && l.ch != '\n' && l.ch != '\r' && l.ch != ' ' && l.ch != '\t' && l.ch != ';' {

      
        
        461
        +		l.advance()

      
        
        462
        +	}

      
        
        463
        +	lit := string(l.input[s.offset:l.pos])

      
        
        464
        +	kind := l.keyword(lit)

      
        
        465
        +	if kind == token.ILLEGAL { // todo: report an error ??

      
        
        466
        +		kind = token.TEXT

      
        
        467
        +	} else {

      
        
        468
        +		l.mode = ModeDirective

      
        
        469
        +	}

      
        
        470
        +	return token.Token{Type: kind, Literal: lit, Span: l.span(s)}

      
        
        471
        +}

      
        
        472
        +

      
        
        473
        +func (l *Lexer) lexDate() token.Token {

      
        
        474
        +	s := l.save()

      
        
        475
        +	for l.isDigit() || (l.isDateSep() && l.peekIsDigit()) {

      
        
        476
        +		l.advance()

      
        
        477
        +	}

      
        
        478
        +	return token.Token{Type: token.DATE, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        479
        +}

      
        
        480
        +

      
        
        481
        +func (l *Lexer) lexCommodityMark() token.Token {

      
        
        482
        +	s := l.save()

      
        
        483
        +

      
        
        484
        +	if l.ch == '"' {

      
        
        485
        +		l.advance()

      
        
        486
        +		for l.ch != '"' && l.ch != '\n' && l.ch != 0 {

      
        
        487
        +			l.advance()

      
        
        488
        +		}

      
        
        489
        +		if l.ch == '"' {

      
        
        490
        +			l.advance()

      
        
        491
        +		}

      
        
        492
        +		return token.Token{Type: token.COMMODITYMARK, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        493
        +	}

      
        
        494
        +

      
        
        495
        +	if unicode.IsLetter(l.ch) {

      
        
        496
        +		for unicode.IsLetter(l.ch) || unicode.IsDigit(l.ch) {

      
        
        497
        +			l.advance()

      
        
        498
        +		}

      
        
        499
        +		return token.Token{Type: token.COMMODITYMARK, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        500
        +	}

      
        
        501
        +

      
        
        502
        +	l.advance()

      
        
        503
        +	return token.Token{Type: token.COMMODITYMARK, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        504
        +}

      
        
        505
        +

      
        
        506
        +func (l *Lexer) lexLBrace() token.Token {

      
        
        507
        +	s := l.save()

      
        
        508
        +	l.advance()

      
        
        509
        +	if l.ch == '{' {

      
        
        510
        +		l.advance()

      
        
        511
        +		return token.Token{Type: token.LBRACELBRACE, Literal: "{{", Span: l.span(s)}

      
        
        512
        +	}

      
        
        513
        +	return token.Token{Type: token.LBRACE, Literal: "{", Span: l.span(s)}

      
        
        514
        +}

      
        
        515
        +

      
        
        516
        +func (l *Lexer) lexRBrace() token.Token {

      
        
        517
        +	s := l.save()

      
        
        518
        +	l.advance()

      
        
        519
        +	if l.ch == '}' {

      
        
        520
        +		l.advance()

      
        
        521
        +		return token.Token{Type: token.RBRACERBRACE, Literal: "}}", Span: l.span(s)}

      
        
        522
        +	}

      
        
        523
        +	return token.Token{Type: token.RBRACE, Literal: "}", Span: l.span(s)}

      
        
        524
        +}

      
        
        525
        +

      
        
        526
        +func (l *Lexer) advance() {

      
        
        527
        +	if l.rpos >= len(l.input) {

      
        
        528
        +		l.ch = 0

      
        
        529
        +		l.chSize = 0

      
        
        530
        +	} else {

      
        
        531
        +		r, size := utf8.DecodeRune(l.input[l.rpos:])

      
        
        532
        +		l.ch = r

      
        
        533
        +		l.chSize = size

      
        
        534
        +	}

      
        
        535
        +	l.pos = l.rpos

      
        
        536
        +	l.rpos += l.chSize

      
        
        537
        +	if l.ch == '\n' || l.ch == '\r' {

      
        
        538
        +		l.line++

      
        
        539
        +		l.col = 0

      
        
        540
        +	} else {

      
        
        541
        +		l.col++

      
        
        542
        +	}

      
        
        543
        +}

      
        
        544
        +

      
        
        545
        +func (l *Lexer) peek() rune {

      
        
        546
        +	r, _ := utf8.DecodeRune(l.input[l.rpos:])

      
        
        547
        +	return r

      
        
        548
        +}

      
        
        549
        +

      
        
        550
        +func (l *Lexer) peekN(n int) byte {

      
        
        551
        +	if l.pos+n >= len(l.input) {

      
        
        552
        +		return 0

      
        
        553
        +	}

      
        
        554
        +	return l.input[l.pos+n]

      
        
        555
        +}

      
        
        556
        +

      
        
        557
        +func (l *Lexer) isDigit() bool { return l.ch >= '0' && l.ch <= '9' }

      
        
        558
        +func (l *Lexer) isAlpha() bool {

      
        
        559
        +	return (l.ch >= 'a' && l.ch <= 'z') ||

      
        
        560
        +		(l.ch >= 'A' && l.ch <= 'Z')

      
        
        561
        +}

      
        
        562
        +

      
        
        563
        +func (l *Lexer) isTwoSpaces() bool { return l.ch == ' ' && l.peek() == ' ' }

      
        
        564
        +

      
        
        565
        +func (l *Lexer) isDateSep() bool { return l.ch == '-' || l.ch == '/' || l.ch == '.' }

      
        
        566
        +

      
        
        567
        +func (l *Lexer) peekIsDigit() bool {

      
        
        568
        +	r := l.peek()

      
        
        569
        +	return r >= '0' && r <= '9'

      
        
        570
        +}

      
        
        571
        +

      
        
        572
        +func (l *Lexer) isCommodityStart() bool {

      
        
        573
        +	if l.ch == '$' || (l.ch >= 'A' && l.ch <= 'Z') {

      
        
        574
        +		return true

      
        
        575
        +	}

      
        
        576
        +	if l.ch < utf8.RuneSelf {

      
        
        577
        +		return false

      
        
        578
        +	}

      
        
        579
        +	return unicode.In(l.ch, unicode.Sc) || unicode.IsLetter(l.ch)

      
        
        580
        +}

      
        
        581
        +

      
        
        582
        +func (l *Lexer) isDate() bool {

      
        
        583
        +	if !l.isDigit() {

      
        
        584
        +		return false

      
        
        585
        +	}

      
        
        586
        +	// YYYY/M/D or YYYY/MM/DD

      
        
        587
        +	if l.peekN(1) >= '0' && l.peekN(1) <= '9' &&

      
        
        588
        +		l.peekN(2) >= '0' && l.peekN(2) <= '9' &&

      
        
        589
        +		l.peekN(3) >= '0' && l.peekN(3) <= '9' {

      
        
        590
        +		sep := l.peekN(4)

      
        
        591
        +		if sep == '/' || sep == '-' || sep == '.' {

      
        
        592
        +			if l.peekN(5) >= '0' && l.peekN(5) <= '9' {

      
        
        593
        +				if l.peekN(6) == sep {

      
        
        594
        +					return l.peekN(7) >= '0' && l.peekN(7) <= '9'

      
        
        595
        +				}

      
        
        596
        +				if l.peekN(7) == sep {

      
        
        597
        +					return l.peekN(8) >= '0' && l.peekN(8) <= '9'

      
        
        598
        +				}

      
        
        599
        +			}

      
        
        600
        +		}

      
        
        601
        +		return false

      
        
        602
        +	}

      
        
        603
        +	// M/D or MM/DD(year inferred, only / and - separators; . is ambiguous with decimal numbers like 1.01)

      
        
        604
        +	if (l.peekN(1) == '/' || l.peekN(1) == '-') &&

      
        
        605
        +		l.peekN(2) >= '0' && l.peekN(2) <= '9' &&

      
        
        606
        +		l.ch >= '1' && l.ch <= '9' {

      
        
        607
        +		return validDay(l.peekN(2), l.peekN(3))

      
        
        608
        +	}

      
        
        609
        +	if (l.peekN(2) == '/' || l.peekN(2) == '-') &&

      
        
        610
        +		l.peekN(3) >= '0' && l.peekN(3) <= '9' {

      
        
        611
        +		m := int(l.ch-'0')*10 + int(l.peekN(1)-'0')

      
        
        612
        +		return m >= 1 && m <= 12 && validDay(l.peekN(3), l.peekN(4))

      
        
        613
        +	}

      
        
        614
        +	return false

      
        
        615
        +}

      
        
        616
        +

      
        
        617
        +func validDay(first, second byte) bool {

      
        
        618
        +	d := int(first - '0')

      
        
        619
        +	if second >= '0' && second <= '9' {

      
        
        620
        +		d = d*10 + int(second-'0')

      
        
        621
        +	}

      
        
        622
        +	return d >= 1 && d <= 31

      
        
        623
        +}

      
        
        624
        +

      
        
        625
        +func (l *Lexer) isTime() bool {

      
        
        626
        +	if !l.isDigit() {

      
        
        627
        +		return false

      
        
        628
        +	}

      
        
        629
        +	return l.peekN(2) == ':'

      
        
        630
        +}

      
        
        631
        +

      
        
        632
        +func (l *Lexer) lexTime() token.Token {

      
        
        633
        +	s := l.save()

      
        
        634
        +	for l.isDigit() || l.ch == ':' {

      
        
        635
        +		l.advance()

      
        
        636
        +	}

      
        
        637
        +	return token.Token{Type: token.TIME, Literal: string(l.input[s.offset:l.pos]), Span: l.span(s)}

      
        
        638
        +}

      
        
        639
        +

      
        
        640
        +type savedPos struct{ offset, line, col int }

      
        
        641
        +

      
        
        642
        +func (l *Lexer) save() savedPos {

      
        
        643
        +	return savedPos{l.pos, l.line, l.col}

      
        
        644
        +}

      
        
        645
        +

      
        
        646
        +func (l *Lexer) span(s savedPos) token.Span {

      
        
        647
        +	return token.Span{

      
        
        648
        +		Start: token.Pos{File: l.file, Offset: s.offset, Line: s.line, Col: s.col},

      
        
        649
        +		End:   token.Pos{File: l.file, Offset: l.pos, Line: l.line, Col: l.col},

      
        
        650
        +	}

      
        
        651
        +}

      
        
        652
        +

      
        
        653
        +func (l *Lexer) token(kind token.Type, literal string) token.Token {

      
        
        654
        +	s := savedPos{l.pos, l.line, l.col}

      
        
        655
        +	return token.Token{Type: kind, Literal: literal, Span: l.span(s)}

      
        
        656
        +}

      
        
        657
        +

      
        
        658
        +func (l *Lexer) keyword(s string) token.Type {

      
        
        659
        +	switch s {

      
        
        660
        +	case "comment":

      
        
        661
        +		return token.COMMENTKW

      
        
        662
        +	case "account":

      
        
        663
        +		return token.ACCOUNT

      
        
        664
        +	case "commodity":

      
        
        665
        +		return token.COMMODITY

      
        
        666
        +	case "include":

      
        
        667
        +		return token.INCLUDE

      
        
        668
        +	case "alias":

      
        
        669
        +		return token.ALIAS

      
        
        670
        +	case "payee":

      
        
        671
        +		return token.PAYEE

      
        
        672
        +	case "tag":

      
        
        673
        +		return token.TAG

      
        
        674
        +	case "apply":

      
        
        675
        +		return token.APPLY

      
        
        676
        +	case "end":

      
        
        677
        +		return token.END

      
        
        678
        +	case "Y", "year":

      
        
        679
        +		return token.YEAR

      
        
        680
        +	case "decimal-mark":

      
        
        681
        +		return token.DECIMALMARK

      
        
        682
        +	case "D":

      
        
        683
        +		return token.D

      
        
        684
        +	case "P":

      
        
        685
        +		return token.P

      
        
        686
        +	case "N":

      
        
        687
        +		return token.N

      
        
        688
        +	default:

      
        
        689
        +		return token.ILLEGAL

      
        
        690
        +	}

      
        
        691
        +}