Compare commits
No commits in common. 'v0.2.x' and 'main' have entirely different histories.
32 changed files with 795 additions and 1069 deletions
@ -0,0 +1,13 @@ |
|||||||
|
# http://editorconfig.org |
||||||
|
|
||||||
|
root = true |
||||||
|
|
||||||
|
[*] |
||||||
|
charset = utf-8 |
||||||
|
end_of_line = lf |
||||||
|
insert_final_newline = true |
||||||
|
trim_trailing_whitespace = true |
||||||
|
|
||||||
|
[*.go] |
||||||
|
indent_style = tab |
||||||
|
indent_size = 4 |
||||||
@ -1,4 +1,4 @@ |
|||||||
Copyright 2021 JPI Technologies Ltd <oss@jpi.io> |
Copyright 2023 JPI Technologies Ltd <oss@jpi.io> |
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
of this software and associated documentation files (the "Software"), to deal |
of this software and associated documentation files (the "Software"), to deal |
||||||
@ -1,15 +1,50 @@ |
|||||||
.PHONY: all fmt build test |
.PHONY: all clean generate fmt |
||||||
|
.PHONY: tidy get build test up |
||||||
|
|
||||||
GO ?= go
|
GO ?= go
|
||||||
|
GOFMT ?= gofmt
|
||||||
|
GOFMT_FLAGS = -w -l -s
|
||||||
|
GOGENERATE_FLAGS = -v
|
||||||
|
|
||||||
all: fmt build |
GOPATH ?= $(shell $(GO) env GOPATH)
|
||||||
|
GOBIN ?= $(GOPATH)/bin
|
||||||
|
|
||||||
fmt: |
TMPDIR ?= $(CURDIR)/.tmp
|
||||||
$(GO) fmt ./...
|
TOOLSDIR = $(CURDIR)/tools
|
||||||
$(GO) mod tidy || true
|
|
||||||
|
|
||||||
build: |
REVIVE_CONF ?= $(TOOLSDIR)/revive.toml
|
||||||
$(GO) get -v ./...
|
REVIVE_RUN_ARGS ?= -config $(REVIVE_CONF) -formatter friendly
|
||||||
|
REVIVE ?= $(GO) run -v github.com/mgechev/revive
|
||||||
|
|
||||||
test: |
V = 0
|
||||||
$(GO) test -v ./...
|
Q = $(if $(filter 1,$V),,@)
|
||||||
|
M = $(shell if [ "$$(tput colors 2> /dev/null || echo 0)" -ge 8 ]; then printf "\033[34;1m▶\033[0m"; else printf "▶"; fi)
|
||||||
|
|
||||||
|
all: get generate tidy build |
||||||
|
|
||||||
|
clean: ; $(info $(M) cleaning…) |
||||||
|
rm -rf $(TMPDIR)
|
||||||
|
|
||||||
|
fmt: ; $(info $(M) reformatting sources…) |
||||||
|
$Q find . -name '*.go' | xargs -r $(GOFMT) $(GOFMT_FLAGS)
|
||||||
|
|
||||||
|
tidy: | fmt ; $(info $(M) tidying up…) |
||||||
|
$Q $(GO) mod tidy
|
||||||
|
$Q $(GO) vet ./...
|
||||||
|
$Q $(REVIVE) $(REVIVE_RUN_ARGS) ./...
|
||||||
|
|
||||||
|
get: ; $(info $(M) downloading dependencies…) |
||||||
|
$Q $(GO) get -v -tags tools ./...
|
||||||
|
|
||||||
|
build: ; $(info $(M) building…) |
||||||
|
$Q $(GO) build -v ./...
|
||||||
|
|
||||||
|
test: ; $(info $(M) building…) |
||||||
|
$Q $(GO) test ./...
|
||||||
|
|
||||||
|
up: ; $(info $(M) updating dependencies…) |
||||||
|
$Q $(GO) get -u -v ./...
|
||||||
|
$Q $(GO) mod tidy
|
||||||
|
|
||||||
|
generate: ; $(info $(M) generating data…) |
||||||
|
$Q git grep -l '^//go:generate' | sort -uV | xargs -r -n1 $(GO) generate $(GOGENERATE_FLAGS)
|
||||||
|
|||||||
@ -1,4 +0,0 @@ |
|||||||
asciigoat.org/core |
|
||||||
================== |
|
||||||
|
|
||||||
helpers and general structs used by asciigoat parsers and generators |
|
||||||
@ -0,0 +1,78 @@ |
|||||||
|
# asciigoat's core library |
||||||
|
|
||||||
|
[![Go Reference][godoc-badge]][godoc] |
||||||
|
[![Go Report Card][goreport-badge]][goreport] |
||||||
|
|
||||||
|
This package contains the basics for writing simple parsers of |
||||||
|
text languages heavily inspired by |
||||||
|
[Rob Pike](https://en.wikipedia.org/wiki/Rob_Pike)'s talk on |
||||||
|
[Lexical Scanning in Go](https://go.dev/talks/2011/lex.slide#1) in 2011 which |
||||||
|
you can [watch online](https://www.youtube.com/watch?v=HxaD_trXwRE) to get |
||||||
|
better understanding of the ideas behind **asciigoat**. |
||||||
|
|
||||||
|
**asciigoat** is [MIT](https://opensource.org/license/mit/) licensed. |
||||||
|
|
||||||
|
[godoc]: https://pkg.go.dev/asciigoat.org/core |
||||||
|
[godoc-badge]: https://pkg.go.dev/badge/asciigoat.org/core.svg |
||||||
|
[goreport]: https://goreportcard.com/report/asciigoat.org/core |
||||||
|
[goreport-badge]: https://goreportcard.com/badge/asciigoat.org/core |
||||||
|
|
||||||
|
[godoc-lexer-reader]: https://pkg.go.dev/asciigoat.org/core/lexer#Reader |
||||||
|
[godoc-readcloser]: https://pkg.go.dev/asciigoat.org/core#ReadCloser |
||||||
|
|
||||||
|
## Lexer |
||||||
|
|
||||||
|
### lexer.Reader |
||||||
|
|
||||||
|
The lexer package provides [`lexer.Reader`][godoc-lexer-reader] which is |
||||||
|
actually an [`io.RuneScanner`](https://pkg.go.dev/io#RuneScanner) |
||||||
|
that buffers accepted runes until you are ready to |
||||||
|
[emit](https://pkg.go.dev/asciigoat.org/core/lexer#Reader.Emit) or |
||||||
|
[discard](https://pkg.go.dev/asciigoat.org/core/lexer#Reader.Discard). |
||||||
|
|
||||||
|
### lexer.Position |
||||||
|
|
||||||
|
[`lexer.Position`](https://pkg.go.dev/asciigoat.org/core/lexer#Position) |
||||||
|
is a `(Line, Column)` pair with methods to facilitate tracking |
||||||
|
your position on the source [Reader](https://pkg.go.dev/io#Reader). |
||||||
|
|
||||||
|
### lexer.Error |
||||||
|
|
||||||
|
[`lexer.Error`](https://pkg.go.dev/asciigoat.org/core/lexer#Error) |
||||||
|
is an [unwrappable](https://pkg.go.dev/errors#Unwrap) error with a |
||||||
|
token position and hint attached. |
||||||
|
|
||||||
|
### lexer.StateFn |
||||||
|
|
||||||
|
At the heart of **asciigoat** we have _state functions_ as proposed on [Rob Pike's famous talk](https://www.youtube.com/watch?v=HxaD_trXwRE) which return the next _state function_ parsing is done. |
||||||
|
Additionally there is a [`Run()`](https://pkg.go.dev/asciigoat.org/lexer#Run) helper that implements the loop. |
||||||
|
|
||||||
|
### rune checkers |
||||||
|
|
||||||
|
_Rune checkers_ are simple functions that tell if a rune is of a class or it's not. |
||||||
|
Fundamental checkers are provided by the [`unicode` package](https://pkg.go.dev/unicode). |
||||||
|
|
||||||
|
Our [`lexer.Reader`][godoc-lexer-reader] uses them on its `Accept()` and `AcceptAll()` methods to |
||||||
|
make it easier to consume the _source_ document. |
||||||
|
|
||||||
|
To facilitate the declaration of _rune classes_ in the context of **asciigoat** powered parsers we include |
||||||
|
a series of rune checker factories. |
||||||
|
|
||||||
|
* `NewIsIn(string)` |
||||||
|
* `NewIsInRunes(...rune)` |
||||||
|
* `NewIsNot(checker)` |
||||||
|
* `NewIsOneOf(...checker)` |
||||||
|
|
||||||
|
## Others |
||||||
|
|
||||||
|
### ReadCloser |
||||||
|
|
||||||
|
[ReadCloser][godoc-readcloser] assists in providing a |
||||||
|
[io.Closer](https://pkg.go.dev/io#Closer) to Readers or buffers without on, |
||||||
|
or unearthing one if available so |
||||||
|
[io.ReadCloser](https://pkg.go.dev/io#ReadCloser) can be fulfilled. |
||||||
|
|
||||||
|
## See also |
||||||
|
|
||||||
|
* [asciigoat.org/ini](https://asciigoat.org/ini) |
||||||
|
* [oss.jpi.io](https://oss.jpi.io) |
||||||
@ -1,37 +0,0 @@ |
|||||||
/* |
|
||||||
Package ebmf implements an ISO/IEC 14977 |
|
||||||
Extended Backus–Naur Form parser, verifiers, |
|
||||||
and additional related helpers for AsciiGoat |
|
||||||
|
|
||||||
A syntax highlighter for vim and a copy of the final draft of the standard |
|
||||||
are included in the doc/ directory. The official standard can be downloaded from |
|
||||||
http://standards.iso.org/ittf/PubliclyAvailableStandards/s026153_ISO_IEC_14977_1996(E).zip
|
|
||||||
|
|
||||||
An uberly simplified version of the EBNF grammar looks like: |
|
||||||
|
|
||||||
letter = "A" | "B" | "C" | "D" | "E" | "F" | "G" |
|
||||||
| "H" | "I" | "J" | "K" | "L" | "M" | "N" |
|
||||||
| "O" | "P" | "Q" | "R" | "S" | "T" | "U" |
|
||||||
| "V" | "W" | "X" | "Y" | "Z" ; |
|
||||||
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; |
|
||||||
symbol = "[" | "]" | "{" | "}" | "(" | ")" | "<" | ">" |
|
||||||
| "'" | '"' | "=" | "|" | "." | "," | ";" ; |
|
||||||
character = letter | digit | symbol | "_" ; |
|
||||||
|
|
||||||
identifier = letter , { letter | digit | "_" } ; |
|
||||||
terminal = "'" , character , { character } , "'" |
|
||||||
| '"' , character , { character } , '"' ; |
|
||||||
|
|
||||||
lhs = identifier ; |
|
||||||
rhs = identifier |
|
||||||
| terminal |
|
||||||
| "[" , rhs , "]" |
|
||||||
| "{" , rhs , "}" |
|
||||||
| "(" , rhs , ")" |
|
||||||
| rhs , "|" , rhs |
|
||||||
| rhs , "," , rhs ; |
|
||||||
|
|
||||||
rule = lhs , "=" , rhs , ";" ; |
|
||||||
grammar = { rule } ; |
|
||||||
*/ |
|
||||||
package ebnf |
|
||||||
@ -1,36 +0,0 @@ |
|||||||
" Vim syntax file |
|
||||||
" Language: EBNF |
|
||||||
" Maintainer: Hans Fugal |
|
||||||
" Last Change: $Date: 2003/01/28 14:42:09 $ |
|
||||||
" Version: $Id: ebnf.vim,v 1.1 2003/01/28 14:42:09 fugalh Exp $ |
|
||||||
" With thanks to Michael Brailsford for the BNF syntax file. |
|
||||||
|
|
||||||
" Quit when a syntax file was already loaded |
|
||||||
if version < 600 |
|
||||||
syntax clear |
|
||||||
elseif exists("b:current_syntax") |
|
||||||
finish |
|
||||||
endif |
|
||||||
|
|
||||||
syn match ebnfMetaIdentifier /[A-Za-z]/ skipwhite skipempty nextgroup=ebnfSeperator |
|
||||||
|
|
||||||
syn match ebnfSeperator "=" contained nextgroup=ebnfProduction skipwhite skipempty |
|
||||||
|
|
||||||
syn region ebnfProduction start=/\zs[^\.;]/ end=/[\.;]/me=e-1 contained contains=ebnfSpecial,ebnfDelimiter,ebnfTerminal,ebnfSpecialSequence,ebnfComment nextgroup=ebnfEndProduction skipwhite skipempty |
|
||||||
syn match ebnfDelimiter #[,(|)\]}\[{/!]\|\(\*)\)\|\((\*\)\|\(/)\)\|\(:)\)\|\((/\)\|\((:\)# contained |
|
||||||
syn match ebnfSpecial /[\-\*]/ contained |
|
||||||
syn region ebnfSpecialSequence matchgroup=Delimiter start=/?/ end=/?/ contained |
|
||||||
syn match ebnfEndProduction /[\.;]/ contained |
|
||||||
syn region ebnfTerminal matchgroup=delimiter start=/"/ end=/"/ contained |
|
||||||
syn region ebnfTerminal matchgroup=delimiter start=/'/ end=/'/ contained |
|
||||||
syn region ebnfComment start="(\*" end="\*)" |
|
||||||
|
|
||||||
|
|
||||||
hi link ebnfComment Comment |
|
||||||
hi link ebnfMetaIdentifier Identifier |
|
||||||
hi link ebnfSeperator ebnfSpecial |
|
||||||
hi link ebnfEndProduction ebnfDelimiter |
|
||||||
hi link ebnfDelimiter Delimiter |
|
||||||
hi link ebnfSpecial Special |
|
||||||
hi link ebnfSpecialSequence Statement |
|
||||||
hi link ebnfTerminal Constant |
|
||||||
Binary file not shown.
@ -1,20 +0,0 @@ |
|||||||
package token |
|
||||||
|
|
||||||
// types of Token
|
|
||||||
type TokenType int |
|
||||||
|
|
||||||
const ( |
|
||||||
TokenError TokenType = iota + 1 |
|
||||||
TokenEOF |
|
||||||
) |
|
||||||
|
|
||||||
func (typ TokenType) String() string { |
|
||||||
switch typ { |
|
||||||
case TokenError: |
|
||||||
return "ERROR" |
|
||||||
case TokenEOF: |
|
||||||
return "EOF" |
|
||||||
default: |
|
||||||
return "UNDEFINED" |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,25 +0,0 @@ |
|||||||
package token |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"testing" |
|
||||||
) |
|
||||||
|
|
||||||
func TestTokenTypeToString(t *testing.T) { |
|
||||||
var foo TokenType |
|
||||||
|
|
||||||
for _, o := range []struct { |
|
||||||
typ TokenType |
|
||||||
str string |
|
||||||
}{ |
|
||||||
{foo, "UNDEFINED"}, |
|
||||||
{TokenError, "ERROR"}, |
|
||||||
{TokenEOF, "EOF"}, |
|
||||||
{1234, "UNDEFINED"}, |
|
||||||
} { |
|
||||||
str := fmt.Sprintf("%s", o.typ) |
|
||||||
if str != o.str { |
|
||||||
t.Errorf("TokenType:%v stringified as %s instead of %s.", int(o.typ), str, o.str) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -0,0 +1,2 @@ |
|||||||
|
// Package core provides the foundations of asciigoat packages
|
||||||
|
package core |
||||||
@ -1,3 +1,22 @@ |
|||||||
module asciigoat.org/core |
module asciigoat.org/core |
||||||
|
|
||||||
go 1.16 |
go 1.19 |
||||||
|
|
||||||
|
require github.com/mgechev/revive v1.3.3 |
||||||
|
|
||||||
|
require ( |
||||||
|
github.com/BurntSushi/toml v1.3.2 // indirect |
||||||
|
github.com/chavacava/garif v0.1.0 // indirect |
||||||
|
github.com/fatih/color v1.15.0 // indirect |
||||||
|
github.com/fatih/structtag v1.2.0 // indirect |
||||||
|
github.com/mattn/go-colorable v0.1.13 // indirect |
||||||
|
github.com/mattn/go-isatty v0.0.19 // indirect |
||||||
|
github.com/mattn/go-runewidth v0.0.15 // indirect |
||||||
|
github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect |
||||||
|
github.com/mitchellh/go-homedir v1.1.0 // indirect |
||||||
|
github.com/olekukonko/tablewriter v0.0.5 // indirect |
||||||
|
github.com/pkg/errors v0.9.1 // indirect |
||||||
|
github.com/rivo/uniseg v0.4.4 // indirect |
||||||
|
golang.org/x/sys v0.11.0 // indirect |
||||||
|
golang.org/x/tools v0.12.0 // indirect |
||||||
|
) |
||||||
|
|||||||
@ -0,0 +1,52 @@ |
|||||||
|
github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8= |
||||||
|
github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= |
||||||
|
github.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc= |
||||||
|
github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww= |
||||||
|
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= |
||||||
|
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= |
||||||
|
github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= |
||||||
|
github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4= |
||||||
|
github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94= |
||||||
|
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= |
||||||
|
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= |
||||||
|
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= |
||||||
|
github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= |
||||||
|
github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= |
||||||
|
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= |
||||||
|
github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= |
||||||
|
github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= |
||||||
|
github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0= |
||||||
|
github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg= |
||||||
|
github.com/mgechev/revive v1.3.3 h1:GUWzV3g185agbHN4ZdaQvR6zrLVYTUSA2ktvIinivK0= |
||||||
|
github.com/mgechev/revive v1.3.3/go.mod h1:NhpOtVtDbjYNDj697eDUBTobijCDHQKar4HDKc0TuTo= |
||||||
|
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= |
||||||
|
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= |
||||||
|
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= |
||||||
|
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= |
||||||
|
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= |
||||||
|
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= |
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= |
||||||
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||||
|
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= |
||||||
|
github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= |
||||||
|
github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= |
||||||
|
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= |
||||||
|
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= |
||||||
|
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= |
||||||
|
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= |
||||||
|
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= |
||||||
|
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= |
||||||
|
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= |
||||||
|
golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc= |
||||||
|
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= |
||||||
|
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= |
||||||
|
golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM= |
||||||
|
golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= |
||||||
|
golang.org/x/tools v0.12.0 h1:YW6HUoUmYBpwSgyaGaZq1fHjrBjX1rlpZ54T6mu2kss= |
||||||
|
golang.org/x/tools v0.12.0/go.mod h1:Sc0INKfu04TlqNoRA1hgpFZbhYXHPr4V5DzpSBTPqQM= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||||
|
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= |
||||||
|
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= |
||||||
|
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= |
||||||
@ -0,0 +1,70 @@ |
|||||||
|
package lexer |
||||||
|
|
||||||
|
import ( |
||||||
|
"errors" |
||||||
|
"fmt" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
_ error = (*Error)(nil) |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
// ErrUnacceptableRune indicates the read rune isn't acceptable in the context
|
||||||
|
ErrUnacceptableRune = errors.New("rune not acceptable in context") |
||||||
|
|
||||||
|
// ErrNotImplemented indicates something hasn't been implemented yet
|
||||||
|
ErrNotImplemented = errors.New("not implemented") |
||||||
|
) |
||||||
|
|
||||||
|
// Error represents a generic parsing error
|
||||||
|
type Error struct { |
||||||
|
Filename string |
||||||
|
Line int |
||||||
|
Column int |
||||||
|
|
||||||
|
Content string |
||||||
|
Hint string |
||||||
|
Err error |
||||||
|
} |
||||||
|
|
||||||
|
func (err Error) prefix() string { |
||||||
|
switch { |
||||||
|
case err.Line > 0 || err.Column > 0: |
||||||
|
if err.Filename != "" { |
||||||
|
return fmt.Sprintf("%s:%v:%v", err.Filename, err.Line, err.Column) |
||||||
|
} |
||||||
|
|
||||||
|
return fmt.Sprintf("%v:%v", err.Line, err.Column) |
||||||
|
default: |
||||||
|
return err.Filename |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (err Error) Error() string { |
||||||
|
var s []string |
||||||
|
|
||||||
|
prefix := err.prefix() |
||||||
|
if prefix != "" { |
||||||
|
s = append(s, prefix) |
||||||
|
} |
||||||
|
|
||||||
|
if err.Err != nil { |
||||||
|
s = append(s, err.Err.Error()) |
||||||
|
} |
||||||
|
|
||||||
|
if err.Content != "" { |
||||||
|
s = append(s, fmt.Sprintf("%q", err.Content)) |
||||||
|
} |
||||||
|
|
||||||
|
if err.Hint != "" { |
||||||
|
s = append(s, err.Hint) |
||||||
|
} |
||||||
|
|
||||||
|
return strings.Join(s, ": ") |
||||||
|
} |
||||||
|
|
||||||
|
func (err Error) Unwrap() error { |
||||||
|
return err.Err |
||||||
|
} |
||||||
@ -1,126 +1,31 @@ |
|||||||
|
// Package lexer provides basic helpers to implement parsers
|
||||||
package lexer |
package lexer |
||||||
|
|
||||||
import ( |
import ( |
||||||
"errors" |
"errors" |
||||||
"fmt" |
"io" |
||||||
|
|
||||||
"asciigoat.org/core/runes" |
|
||||||
) |
) |
||||||
|
|
||||||
// state function
|
// StateFn is a State Function of the parser
|
||||||
type StateFn func(Lexer) StateFn |
type StateFn func() (StateFn, error) |
||||||
|
|
||||||
type Lexer interface { |
|
||||||
Run() // run state machine
|
|
||||||
|
|
||||||
Position() TokenPosition // base for the next token
|
|
||||||
Tokens() <-chan Token // tokens output
|
|
||||||
|
|
||||||
AtLeast(n int) ([]rune, error) |
|
||||||
|
|
||||||
NewLine() |
|
||||||
Step(n int) |
|
||||||
|
|
||||||
Emit(TokenType) |
|
||||||
EmitError(error) |
|
||||||
EmitErrorf(string, ...interface{}) |
|
||||||
EmitSyntaxError(string, ...interface{}) |
|
||||||
} |
|
||||||
|
|
||||||
type lexer struct { |
|
||||||
start StateFn // initial state
|
|
||||||
|
|
||||||
in *runes.Feeder // runes source
|
|
||||||
pos TokenPosition // base for the next token
|
|
||||||
cursor int // look ahead pointer
|
|
||||||
tokens chan Token // tokens output
|
|
||||||
} |
|
||||||
|
|
||||||
func NewLexer(start StateFn, in *runes.Feeder, tokens int) Lexer { |
|
||||||
return &lexer{ |
|
||||||
start: start, |
|
||||||
in: in, |
|
||||||
pos: TokenPosition{1, 1}, |
|
||||||
tokens: make(chan Token, tokens), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) Run() { |
|
||||||
defer close(lex.tokens) |
|
||||||
|
|
||||||
for state := lex.start; state != nil; { |
|
||||||
state = state(lex) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) AtLeast(n int) ([]rune, error) { |
|
||||||
min := lex.cursor |
|
||||||
if n > 0 { |
|
||||||
min += n |
|
||||||
} |
|
||||||
|
|
||||||
s, err := lex.in.AtLeast(min) |
|
||||||
if len(s) > lex.cursor { |
|
||||||
s = s[lex.cursor:] |
|
||||||
} else { |
|
||||||
s = nil |
|
||||||
} |
|
||||||
return s, err |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) Position() TokenPosition { |
// Run runs a state machine until the state function either
|
||||||
return lex.pos |
// returns nil or an error
|
||||||
} |
func Run(fn StateFn) error { |
||||||
|
for fn != nil { |
||||||
func (lex *lexer) Step(n int) { |
var err error |
||||||
lex.cursor += n |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) NewLine() { |
|
||||||
lex.pos.NewLine() |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) Tokens() <-chan Token { |
|
||||||
return lex.tokens |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) Emit(typ TokenType) { |
|
||||||
var text []rune |
|
||||||
|
|
||||||
pos := lex.pos |
|
||||||
|
|
||||||
// extract text to emit, and update cursor for the next
|
|
||||||
if n := lex.cursor; n > 0 { |
|
||||||
text = lex.in.Runes()[:n] |
|
||||||
lex.in.Skip(n) |
|
||||||
lex.pos.Step(n) |
|
||||||
lex.cursor = 0 |
|
||||||
} |
|
||||||
|
|
||||||
lex.tokens <- NewToken(typ, text, pos) |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) EmitError(err error) { |
|
||||||
// if no error is passed, assume they mean EOF
|
|
||||||
if err == nil { |
|
||||||
err = EOF |
|
||||||
} |
|
||||||
|
|
||||||
lex.tokens <- NewErrorToken(err, lex.pos) |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) EmitErrorf(s string, args ...interface{}) { |
|
||||||
if len(args) > 0 { |
|
||||||
s = fmt.Sprintf(s, args...) |
|
||||||
} |
|
||||||
|
|
||||||
lex.tokens <- NewErrorToken(errors.New(s), lex.pos) |
|
||||||
} |
|
||||||
|
|
||||||
func (lex *lexer) EmitSyntaxError(s string, args ...interface{}) { |
fn, err = fn() |
||||||
if len(args) > 0 { |
switch { |
||||||
s = fmt.Sprintf(s, args...) |
case errors.Is(err, io.EOF): |
||||||
|
// EOF
|
||||||
|
return nil |
||||||
|
case err != nil: |
||||||
|
// failed
|
||||||
|
return err |
||||||
|
} |
||||||
} |
} |
||||||
|
|
||||||
lex.tokens <- NewSyntaxErrorToken(s, lex.pos, lex.cursor, lex.in.Runes()) |
// ended
|
||||||
|
return nil |
||||||
} |
} |
||||||
|
|||||||
@ -0,0 +1,86 @@ |
|||||||
|
package lexer |
||||||
|
|
||||||
|
import "fmt" |
||||||
|
|
||||||
|
// Position indicates a line and column pair on a file.
|
||||||
|
// Counting starts at 1.
|
||||||
|
type Position struct { |
||||||
|
Line int |
||||||
|
Column int |
||||||
|
} |
||||||
|
|
||||||
|
// String generates a pretty "(Line, Column)"" representation of the Position
|
||||||
|
func (p Position) String() string { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
return fmt.Sprintf("(%v, %v)", p.Line, p.Column) |
||||||
|
} |
||||||
|
|
||||||
|
// GoString generates a string representation of the Position for %#v usage
|
||||||
|
func (p Position) GoString() string { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
return fmt.Sprintf("lexer.Position{%v, %v}", p.Line, p.Column) |
||||||
|
} |
||||||
|
|
||||||
|
// Reset places a position at (1,1)
|
||||||
|
func (p *Position) Reset() { |
||||||
|
p.Line, p.Column = 1, 1 |
||||||
|
} |
||||||
|
|
||||||
|
// Step moves the column one place
|
||||||
|
func (p *Position) Step() { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
p.Column++ |
||||||
|
} |
||||||
|
|
||||||
|
// StepN moves the column N places forward
|
||||||
|
func (p *Position) StepN(n int) { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
switch { |
||||||
|
case n > 0: |
||||||
|
p.Column += n |
||||||
|
default: |
||||||
|
panic(fmt.Errorf("invalid %v increment", n)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// StepLine moves position to the start of the next line
|
||||||
|
func (p *Position) StepLine() { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
p.Line++ |
||||||
|
p.Column = 1 |
||||||
|
} |
||||||
|
|
||||||
|
// Add adds a relative position considering
|
||||||
|
// potential new lines
|
||||||
|
func (p *Position) Add(rel Position) { |
||||||
|
if p.Line == 0 { |
||||||
|
p.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
switch { |
||||||
|
case rel.Line == 0: |
||||||
|
// nothing
|
||||||
|
case rel.Line > 1: |
||||||
|
// includes new lines
|
||||||
|
p.Line += rel.Line - 1 |
||||||
|
p.Column = rel.Column |
||||||
|
default: |
||||||
|
// same line
|
||||||
|
p.Column += rel.Column - 1 |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,256 @@ |
|||||||
|
package lexer |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"errors" |
||||||
|
"io" |
||||||
|
"strings" |
||||||
|
"unicode/utf8" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
// ReadBufferSize indicates the initial buffer size
|
||||||
|
ReadBufferSize = 1 << 7 // 128B
|
||||||
|
|
||||||
|
// DoublingBufferSizeLimit indicates when we stop doubling
|
||||||
|
// and just add instead
|
||||||
|
DoublingBufferSizeLimit = 1 << 17 // 128KiB
|
||||||
|
) |
||||||
|
|
||||||
|
// implemented interfaces
|
||||||
|
var ( |
||||||
|
_ io.RuneReader = (*Reader)(nil) |
||||||
|
_ io.RuneScanner = (*Reader)(nil) |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
// ErrInvalidUnreadRune indicates UnreadRune() was calls after an
|
||||||
|
// action other than a successful ReadRune()
|
||||||
|
ErrInvalidUnreadRune = errors.New("invalid UnreadRune() call") |
||||||
|
) |
||||||
|
|
||||||
|
// Reader is a RuneReader aimed at implementing text parsers
|
||||||
|
type Reader struct { |
||||||
|
src io.Reader |
||||||
|
|
||||||
|
buf []byte |
||||||
|
off int |
||||||
|
cursor int |
||||||
|
|
||||||
|
lastRuneSize int |
||||||
|
} |
||||||
|
|
||||||
|
// String returns what's already Read but not yet emitted or discarded
|
||||||
|
func (b *Reader) String() string { |
||||||
|
return string(b.buf[b.off:b.cursor]) |
||||||
|
} |
||||||
|
|
||||||
|
// Emit returns what's already being Read and discards it afterwards
|
||||||
|
func (b *Reader) Emit() string { |
||||||
|
s := b.String() |
||||||
|
b.Discard() |
||||||
|
return s |
||||||
|
} |
||||||
|
|
||||||
|
// Discard removes from the buffer everything that has been Read
|
||||||
|
func (b *Reader) Discard() { |
||||||
|
switch { |
||||||
|
case b.ready() == 0: |
||||||
|
// reset
|
||||||
|
b.buf = b.buf[:0] |
||||||
|
b.cursor = 0 |
||||||
|
b.off = 0 |
||||||
|
default: |
||||||
|
// step
|
||||||
|
b.off = b.cursor |
||||||
|
} |
||||||
|
|
||||||
|
// and prevent UnreadRune()
|
||||||
|
b.lastRuneSize = -1 |
||||||
|
} |
||||||
|
|
||||||
|
// ready tells how many bytes are ready to decode
|
||||||
|
func (b *Reader) ready() int { |
||||||
|
return len(b.buf) - b.cursor |
||||||
|
} |
||||||
|
|
||||||
|
// available tells how many free bytes remain at the end of the buffer
|
||||||
|
func (b *Reader) available() int { |
||||||
|
return cap(b.buf) - len(b.buf) |
||||||
|
} |
||||||
|
|
||||||
|
func (b *Reader) needsBytes(n int) error { |
||||||
|
for { |
||||||
|
if b.ready() >= n { |
||||||
|
// ready
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// make room
|
||||||
|
b.prepareBuffer(n - b.ready()) |
||||||
|
|
||||||
|
// and read more
|
||||||
|
_, err := b.fill() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (b *Reader) rebuffer(size int) { |
||||||
|
var src, dst []byte |
||||||
|
|
||||||
|
if size > cap(b.buf) { |
||||||
|
// new buffer
|
||||||
|
dst = make([]byte, size) |
||||||
|
} else { |
||||||
|
// same buffer
|
||||||
|
dst = b.buf |
||||||
|
} |
||||||
|
|
||||||
|
src = b.buf[b.off:] |
||||||
|
dst = dst[:len(src)] |
||||||
|
|
||||||
|
copy(dst, src) |
||||||
|
|
||||||
|
b.cursor -= b.off |
||||||
|
b.buf = dst |
||||||
|
b.off = 0 |
||||||
|
} |
||||||
|
|
||||||
|
func (b *Reader) prepareBuffer(n int) { |
||||||
|
if n > b.available() { |
||||||
|
needed := len(b.buf) + n - b.off |
||||||
|
size := cap(b.buf) |
||||||
|
|
||||||
|
for size < needed { |
||||||
|
switch { |
||||||
|
case size < DoublingBufferSizeLimit: |
||||||
|
size *= 2 |
||||||
|
default: |
||||||
|
size += DoublingBufferSizeLimit |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
b.rebuffer(size) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (b *Reader) fill() (int, error) { |
||||||
|
start := len(b.buf) |
||||||
|
n, err := b.src.Read(b.buf[start:cap(b.buf)]) |
||||||
|
if n > 0 { |
||||||
|
b.buf = b.buf[:start+n] |
||||||
|
} |
||||||
|
return n, err |
||||||
|
} |
||||||
|
|
||||||
|
// ReadRune reads the next rune
|
||||||
|
func (b *Reader) ReadRune() (rune, int, error) { |
||||||
|
// we need at least one byte to start
|
||||||
|
count := 1 |
||||||
|
for { |
||||||
|
err := b.needsBytes(count) |
||||||
|
if err != nil { |
||||||
|
b.lastRuneSize = -1 |
||||||
|
|
||||||
|
return 0, 0, err |
||||||
|
} |
||||||
|
|
||||||
|
if utf8.FullRune(b.buf[b.cursor:]) { |
||||||
|
// we have a full rune
|
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
// more
|
||||||
|
count = b.ready() + 1 |
||||||
|
} |
||||||
|
|
||||||
|
// decode rune
|
||||||
|
r, l := utf8.DecodeRune(b.buf[b.cursor:]) |
||||||
|
// step over
|
||||||
|
b.cursor += l |
||||||
|
// and remember for UnreadRune()
|
||||||
|
b.lastRuneSize = l |
||||||
|
|
||||||
|
return r, l, nil |
||||||
|
} |
||||||
|
|
||||||
|
// UnreadRune moves the cursor where it was before the last call to ReadRune
|
||||||
|
func (b *Reader) UnreadRune() error { |
||||||
|
if b.lastRuneSize > 0 { |
||||||
|
b.cursor -= b.lastRuneSize |
||||||
|
b.lastRuneSize = -1 |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
return ErrInvalidUnreadRune |
||||||
|
} |
||||||
|
|
||||||
|
// PeekRune returns information about the next rune without moving the
|
||||||
|
// cursor
|
||||||
|
func (b *Reader) PeekRune() (rune, int, error) { |
||||||
|
r, l, err := b.ReadRune() |
||||||
|
if err != nil { |
||||||
|
return r, l, err |
||||||
|
} |
||||||
|
err = b.UnreadRune() |
||||||
|
return r, l, err |
||||||
|
} |
||||||
|
|
||||||
|
// Accept consumes a rune from the source if it meets the condition.
|
||||||
|
// it returns true if the condition was met and false if it wasn't.
|
||||||
|
func (b *Reader) Accept(cond func(r rune) bool) bool { |
||||||
|
r, _, err := b.ReadRune() |
||||||
|
switch { |
||||||
|
case err != nil: |
||||||
|
return false |
||||||
|
case cond(r): |
||||||
|
return true |
||||||
|
default: |
||||||
|
_ = b.UnreadRune() |
||||||
|
return false |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// AcceptAll consumes runes from the source as long as they meet the
|
||||||
|
// condition. it returns true if the condition was met for at least one rune,
|
||||||
|
// and false if it wasn't.
|
||||||
|
func (b *Reader) AcceptAll(cond func(r rune) bool) bool { |
||||||
|
var accepted bool |
||||||
|
|
||||||
|
for { |
||||||
|
r, _, err := b.ReadRune() |
||||||
|
switch { |
||||||
|
case err != nil: |
||||||
|
return accepted |
||||||
|
case cond(r): |
||||||
|
accepted = true |
||||||
|
default: |
||||||
|
_ = b.UnreadRune() |
||||||
|
return accepted |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewReader creates a new runes [Reader] using the given [io.Reader]
|
||||||
|
func NewReader(r io.Reader) *Reader { |
||||||
|
if r == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
return &Reader{ |
||||||
|
src: r, |
||||||
|
buf: make([]byte, 0, ReadBufferSize), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewReaderBytes creates a new runes [Reader] using the given bytes
|
||||||
|
func NewReaderBytes(b []byte) *Reader { |
||||||
|
return NewReader(bytes.NewReader(b)) |
||||||
|
} |
||||||
|
|
||||||
|
// NewReaderString creates a new runes [Reader] using the given string
|
||||||
|
func NewReaderString(s string) *Reader { |
||||||
|
return NewReader(strings.NewReader(s)) |
||||||
|
} |
||||||
@ -0,0 +1,47 @@ |
|||||||
|
package lexer |
||||||
|
|
||||||
|
import ( |
||||||
|
"strings" |
||||||
|
"unicode" |
||||||
|
) |
||||||
|
|
||||||
|
// NewIsNot generates a rune condition checker that reverses the
|
||||||
|
// decision of the given checker.
|
||||||
|
func NewIsNot(cond func(rune) bool) func(rune) bool { |
||||||
|
return func(r rune) bool { |
||||||
|
return !cond(r) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewIsIn generates a rune condition checker that accepts runes
|
||||||
|
// contained on the provided string
|
||||||
|
func NewIsIn(s string) func(rune) bool { |
||||||
|
return func(r rune) bool { |
||||||
|
return strings.ContainsRune(s, r) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewIsInRunes generates a rune condition checker that accepts
|
||||||
|
// the runes specified
|
||||||
|
func NewIsInRunes(s ...rune) func(rune) bool { |
||||||
|
return NewIsIn(string(s)) |
||||||
|
} |
||||||
|
|
||||||
|
// NewIsOneOf generates a run condition checker that accepts runes
|
||||||
|
// accepted by any of the given checkers
|
||||||
|
func NewIsOneOf(s ...func(rune) bool) func(rune) bool { |
||||||
|
return func(r rune) bool { |
||||||
|
for _, cond := range s { |
||||||
|
if cond(r) { |
||||||
|
return true |
||||||
|
} |
||||||
|
} |
||||||
|
return false |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// IsSpace reports whether the rune is a space character as
|
||||||
|
// defined by Unicode's White Space property
|
||||||
|
func IsSpace(r rune) bool { |
||||||
|
return unicode.IsSpace(r) |
||||||
|
} |
||||||
@ -1,125 +0,0 @@ |
|||||||
package lexer |
|
||||||
|
|
||||||
import ( |
|
||||||
"errors" |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
) |
|
||||||
|
|
||||||
var ( |
|
||||||
EOF = io.EOF // EOF marker
|
|
||||||
) |
|
||||||
|
|
||||||
// Token type
|
|
||||||
type TokenType int |
|
||||||
|
|
||||||
const ( |
|
||||||
TokenError TokenType = iota |
|
||||||
) |
|
||||||
|
|
||||||
// Token Position
|
|
||||||
type TokenPosition struct { |
|
||||||
Line int |
|
||||||
Row int |
|
||||||
} |
|
||||||
|
|
||||||
func (pos *TokenPosition) Reset() { |
|
||||||
pos.Line = 1 |
|
||||||
pos.Row = 1 |
|
||||||
} |
|
||||||
|
|
||||||
func (pos *TokenPosition) Step(n int) { |
|
||||||
pos.Row += n |
|
||||||
} |
|
||||||
|
|
||||||
func (pos *TokenPosition) NewLine() { |
|
||||||
pos.Line += 1 |
|
||||||
pos.Row = 1 |
|
||||||
} |
|
||||||
|
|
||||||
// Token
|
|
||||||
type Token interface { |
|
||||||
Type() TokenType |
|
||||||
String() string |
|
||||||
Position() TokenPosition |
|
||||||
} |
|
||||||
|
|
||||||
type token struct { |
|
||||||
typ TokenType |
|
||||||
pos TokenPosition |
|
||||||
val string |
|
||||||
} |
|
||||||
|
|
||||||
func NewToken(typ TokenType, val []rune, pos TokenPosition) Token { |
|
||||||
return &token{ |
|
||||||
typ: typ, |
|
||||||
val: string(val), |
|
||||||
pos: pos, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t token) Type() TokenType { |
|
||||||
return t.typ |
|
||||||
} |
|
||||||
|
|
||||||
func (t token) Position() TokenPosition { |
|
||||||
return t.pos |
|
||||||
} |
|
||||||
|
|
||||||
func (t token) String() string { |
|
||||||
return t.val |
|
||||||
} |
|
||||||
|
|
||||||
// ErrorToken
|
|
||||||
type ErrorToken interface { |
|
||||||
Token |
|
||||||
Error() string |
|
||||||
Unwrap() error |
|
||||||
} |
|
||||||
|
|
||||||
type errorToken struct { |
|
||||||
token |
|
||||||
err error |
|
||||||
} |
|
||||||
|
|
||||||
func NewErrorToken(err error, pos TokenPosition) ErrorToken { |
|
||||||
return &errorToken{ |
|
||||||
token: token{ |
|
||||||
typ: TokenError, |
|
||||||
val: err.Error(), |
|
||||||
pos: pos, |
|
||||||
}, |
|
||||||
err: err, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t errorToken) Error() string { |
|
||||||
return t.err.Error() |
|
||||||
} |
|
||||||
|
|
||||||
func (t errorToken) Unwrap() error { |
|
||||||
return t.err |
|
||||||
} |
|
||||||
|
|
||||||
// SyntaxErrorToken
|
|
||||||
type SyntaxErrorToken struct { |
|
||||||
ErrorToken |
|
||||||
|
|
||||||
Cursor int |
|
||||||
Buffer string |
|
||||||
} |
|
||||||
|
|
||||||
func NewSyntaxErrorToken(msg string, pos TokenPosition, cur int, buffer []rune) *SyntaxErrorToken { |
|
||||||
s := fmt.Sprintf("Syntax Error at %v.%v+%v", pos.Line, pos.Row, cur) |
|
||||||
|
|
||||||
if len(msg) > 0 { |
|
||||||
s = fmt.Sprintf("%s: %s", s, msg) |
|
||||||
} |
|
||||||
|
|
||||||
return &SyntaxErrorToken{ |
|
||||||
ErrorToken: NewErrorToken(errors.New(s), pos), |
|
||||||
|
|
||||||
Cursor: cur, |
|
||||||
Buffer: string(buffer), |
|
||||||
} |
|
||||||
} |
|
||||||
@ -0,0 +1,64 @@ |
|||||||
|
package core |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"io" |
||||||
|
"io/fs" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
// ReadCloser adds a Close() to Readers without one
|
||||||
|
type ReadCloser struct { |
||||||
|
r io.Reader |
||||||
|
} |
||||||
|
|
||||||
|
// Read passes the Read() call to the underlying [io.Reader]
|
||||||
|
// and fail if it was Closed()
|
||||||
|
func (rc *ReadCloser) Read(b []byte) (int, error) { |
||||||
|
switch { |
||||||
|
case rc.r != nil: |
||||||
|
return rc.r.Read(b) |
||||||
|
default: |
||||||
|
return 0, fs.ErrClosed |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Close attempts to Close the underlying [io.Reader], or
|
||||||
|
// remove it if it doesn't support Close() and fail
|
||||||
|
// if closed twice
|
||||||
|
func (rc *ReadCloser) Close() error { |
||||||
|
switch { |
||||||
|
case rc.r != nil: |
||||||
|
rc.r = nil |
||||||
|
return nil |
||||||
|
default: |
||||||
|
return fs.ErrClosed |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewReadCloser wraps a [io.Reader] to satisfy
|
||||||
|
// [io.ReadCloser] if needed
|
||||||
|
func NewReadCloser(r io.Reader) io.ReadCloser { |
||||||
|
switch p := r.(type) { |
||||||
|
case io.ReadCloser: |
||||||
|
return p |
||||||
|
case nil: |
||||||
|
return nil |
||||||
|
default: |
||||||
|
return &ReadCloser{ |
||||||
|
r: r, |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewReadCloserBytes wraps a bytes slice to implement
|
||||||
|
// a [io.ReadCloser]
|
||||||
|
func NewReadCloserBytes(b []byte) io.ReadCloser { |
||||||
|
return NewReadCloser(bytes.NewReader(b)) |
||||||
|
} |
||||||
|
|
||||||
|
// NewReadCloserString wraps a string to implement
|
||||||
|
// a [io.ReadCloser]
|
||||||
|
func NewReadCloserString(s string) io.ReadCloser { |
||||||
|
return NewReadCloser(strings.NewReader(s)) |
||||||
|
} |
||||||
@ -1,135 +0,0 @@ |
|||||||
package runes |
|
||||||
|
|
||||||
import ( |
|
||||||
"bufio" |
|
||||||
"bytes" |
|
||||||
"io" |
|
||||||
"strings" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
// feeder is a generic implementation of the output interfaces of Feeder
|
|
||||||
type Feeder struct { |
|
||||||
sync.Mutex |
|
||||||
|
|
||||||
in io.RuneReader |
|
||||||
out []rune |
|
||||||
sz []int |
|
||||||
err error |
|
||||||
} |
|
||||||
|
|
||||||
// NewFeederBytes creates a new Feeder using an slice of bytes as input
|
|
||||||
func NewFeederBytes(b []byte) *Feeder { |
|
||||||
return NewFeeder(bytes.NewReader(b)) |
|
||||||
} |
|
||||||
|
|
||||||
// NewFeederString creates a new Feeder using a string as input
|
|
||||||
func NewFeederString(s string) *Feeder { |
|
||||||
return NewFeeder(strings.NewReader(s)) |
|
||||||
} |
|
||||||
|
|
||||||
// NewFeeder creates a new Feeder using a Reader as input
|
|
||||||
func NewFeeder(in io.Reader) *Feeder { |
|
||||||
rd, ok := in.(io.RuneReader) |
|
||||||
if !ok { |
|
||||||
rd = bufio.NewReader(in) |
|
||||||
} |
|
||||||
return &Feeder{in: rd} |
|
||||||
} |
|
||||||
|
|
||||||
// Skip drops n runes from the head of the buffer
|
|
||||||
func (f *Feeder) Skip(n int) (int, bool) { |
|
||||||
f.Lock() |
|
||||||
defer f.Unlock() |
|
||||||
|
|
||||||
if l := f.skip(n); l > 0 { |
|
||||||
return l, true |
|
||||||
} else { |
|
||||||
return 0, false |
|
||||||
} |
|
||||||
} |
|
||||||
func (f *Feeder) skip(n int) int { |
|
||||||
if l := len(f.out); l > n { |
|
||||||
f.out = f.out[n:] |
|
||||||
f.sz = f.sz[n:] |
|
||||||
return l - n |
|
||||||
} else { |
|
||||||
f.out = f.out[:0] |
|
||||||
f.sz = f.sz[:0] |
|
||||||
return 0 |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// ReadRune returns the next rune
|
|
||||||
func (f *Feeder) ReadRune() (r rune, size int, err error) { |
|
||||||
f.Lock() |
|
||||||
defer f.Unlock() |
|
||||||
|
|
||||||
if f.atLeast(1) { |
|
||||||
r = f.out[0] |
|
||||||
size = f.sz[0] |
|
||||||
|
|
||||||
f.skip(1) |
|
||||||
} |
|
||||||
|
|
||||||
err = f.Err() |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// AtLeast blocks until there are at least n runes on the buffer, or an error or EOF has occurred
|
|
||||||
func (f *Feeder) AtLeast(n int) (out []rune, err error) { |
|
||||||
f.Lock() |
|
||||||
defer f.Unlock() |
|
||||||
|
|
||||||
if !f.atLeast(n) { |
|
||||||
err = f.err |
|
||||||
} |
|
||||||
|
|
||||||
if len(f.out) > 0 { |
|
||||||
out = f.out |
|
||||||
} |
|
||||||
|
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
func (f *Feeder) atLeast(n int) bool { |
|
||||||
for len(f.out) < n { |
|
||||||
r, size, err := f.in.ReadRune() |
|
||||||
if err != nil && f.err == nil { |
|
||||||
// store first error
|
|
||||||
f.err = err |
|
||||||
} |
|
||||||
|
|
||||||
if size > 0 { |
|
||||||
f.out = append(f.out, r) |
|
||||||
f.sz = append(f.sz, size) |
|
||||||
} else if f.err != nil { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return len(f.out) >= n |
|
||||||
} |
|
||||||
|
|
||||||
// Currently buffered runes
|
|
||||||
func (f *Feeder) Runes() []rune { |
|
||||||
return f.out |
|
||||||
} |
|
||||||
|
|
||||||
// Count of currently buffered runes
|
|
||||||
func (f *Feeder) Buffered() int { |
|
||||||
return len(f.out) |
|
||||||
} |
|
||||||
|
|
||||||
// Feeder has reached EOF
|
|
||||||
func (f *Feeder) EOF() bool { |
|
||||||
return f.err == io.EOF |
|
||||||
} |
|
||||||
|
|
||||||
// Feeder encountered an error
|
|
||||||
func (f *Feeder) Err() error { |
|
||||||
if f.err == io.EOF { |
|
||||||
return nil |
|
||||||
} |
|
||||||
return f.err |
|
||||||
} |
|
||||||
@ -1,124 +0,0 @@ |
|||||||
package runes |
|
||||||
|
|
||||||
import ( |
|
||||||
"unicode" |
|
||||||
) |
|
||||||
|
|
||||||
// Probe was borrowed from https://github.com/JamesOwenHall/json2.Scanner
|
|
||||||
//
|
|
||||||
|
|
||||||
// Probe is a func that returns a subset of the input and a success bool.
|
|
||||||
type Probe func([]rune) ([]rune, bool) |
|
||||||
|
|
||||||
// If returns a probe that accepts the a rune if it satisfies the condition.
|
|
||||||
func If(condition func(rune) bool) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
if len(input) > 0 && condition(input[0]) { |
|
||||||
return input[0:1], true |
|
||||||
} |
|
||||||
|
|
||||||
return nil, false |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Rune returns a probe that accepts r.
|
|
||||||
func Rune(r rune) Probe { |
|
||||||
return If(func(b rune) bool { |
|
||||||
return r == b |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
// Space returns a probe that accepts whitespace as defined in the unicode
|
|
||||||
// package.
|
|
||||||
func Space() Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
if len(input) > 0 && unicode.IsSpace(input[0]) { |
|
||||||
return input[0:1], true |
|
||||||
} |
|
||||||
|
|
||||||
return nil, false |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// And returns a probe that accepts all probes in sequence.
|
|
||||||
func And(probes ...Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
remaining := input |
|
||||||
accumulated := []rune{} |
|
||||||
|
|
||||||
for _, s := range probes { |
|
||||||
if read, ok := s(remaining); !ok { |
|
||||||
return nil, false |
|
||||||
} else { |
|
||||||
accumulated = append(accumulated, read...) |
|
||||||
remaining = remaining[len(read):] |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return accumulated, true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Or returns a probe that accepts the first successful probe in probes.
|
|
||||||
func Or(probes ...Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
for _, s := range probes { |
|
||||||
if read, ok := s(input); ok { |
|
||||||
return read, true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return nil, false |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Maybe runs probe and returns true regardless of the output.
|
|
||||||
func Maybe(probe Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
read, _ := probe(input) |
|
||||||
return read, true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Any returns a probe that accepts any number of occurrences of probe,
|
|
||||||
// including zero.
|
|
||||||
func Any(probe Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
remaining := input |
|
||||||
accumulated := []rune{} |
|
||||||
|
|
||||||
for { |
|
||||||
if read, ok := probe(remaining); !ok { |
|
||||||
return accumulated, true |
|
||||||
} else { |
|
||||||
accumulated = append(accumulated, read...) |
|
||||||
remaining = remaining[len(read):] |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// N returns a probe that accepts probe exactly n times.
|
|
||||||
func N(n int, probe Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
probes := make([]Probe, n) |
|
||||||
for i := 0; i < n; i++ { |
|
||||||
probes[i] = probe |
|
||||||
} |
|
||||||
|
|
||||||
return And(probes...)(input) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// AtLeast returns a probe that accepts probe at least n times.
|
|
||||||
func AtLeast(n int, probe Probe) Probe { |
|
||||||
return func(input []rune) ([]rune, bool) { |
|
||||||
probes := make([]Probe, n, n+1) |
|
||||||
for i := range probes { |
|
||||||
probes[i] = probe |
|
||||||
} |
|
||||||
|
|
||||||
probes = append(probes, Any(probe)) |
|
||||||
return And(probes...)(input) |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,58 +0,0 @@ |
|||||||
package runes |
|
||||||
|
|
||||||
import ( |
|
||||||
"testing" |
|
||||||
) |
|
||||||
|
|
||||||
func TestProbe(t *testing.T) { |
|
||||||
type TestCase struct { |
|
||||||
probe Probe |
|
||||||
input string |
|
||||||
} |
|
||||||
|
|
||||||
tests := []TestCase{ |
|
||||||
{Rune('a'), "a"}, |
|
||||||
{Space(), " "}, |
|
||||||
{Space(), "\t"}, |
|
||||||
{Space(), "\n"}, |
|
||||||
{And(Rune('1'), Rune('2'), Space()), "12 "}, |
|
||||||
{Or(Rune('r'), Space(), Rune('x')), "r"}, |
|
||||||
{Or(Rune('r'), Space(), Rune('x')), " "}, |
|
||||||
{Or(Rune('r'), Space(), Rune('x')), "x"}, |
|
||||||
{Any(Rune('w')), ""}, |
|
||||||
{Any(Rune('w')), "w"}, |
|
||||||
{Any(Rune('w')), "ww"}, |
|
||||||
{Any(Rune('w')), "www"}, |
|
||||||
{N(6, Rune('w')), "wwwwww"}, |
|
||||||
{Maybe(Rune('w')), ""}, |
|
||||||
{Maybe(Rune('w')), "w"}, |
|
||||||
} |
|
||||||
|
|
||||||
for _, test := range tests { |
|
||||||
if read, ok := test.probe([]rune(test.input)); !ok { |
|
||||||
t.Errorf("Expected to read %s", string(test.input)) |
|
||||||
} else if string(read) != test.input { |
|
||||||
t.Errorf("Mismatch of input %s and read %s", test.input, string(read)) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestProbeFail(t *testing.T) { |
|
||||||
type TestCase struct { |
|
||||||
probe Probe |
|
||||||
input string |
|
||||||
} |
|
||||||
|
|
||||||
tests := []TestCase{ |
|
||||||
{Rune('a'), "b"}, |
|
||||||
{Space(), "a"}, |
|
||||||
{And(Rune('1'), Rune('2'), Space()), "12"}, |
|
||||||
{Or(Rune('r'), Space(), Rune('x')), "4"}, |
|
||||||
} |
|
||||||
|
|
||||||
for _, test := range tests { |
|
||||||
if read, ok := test.probe([]rune(test.input)); ok { |
|
||||||
t.Errorf("Unexpectedly read %s with input %s", string(read), test.input) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,5 +0,0 @@ |
|||||||
/* |
|
||||||
Package scanner implements the low level functionality |
|
||||||
of AsciiGoat lexers |
|
||||||
*/ |
|
||||||
package scanner |
|
||||||
@ -1,99 +0,0 @@ |
|||||||
package scanner |
|
||||||
|
|
||||||
import ( |
|
||||||
"unicode/utf8" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
// EOF is a dummy rune representing End-Of-File
|
|
||||||
EOF = -1 |
|
||||||
) |
|
||||||
|
|
||||||
// A Position in the input string and in the line-based document
|
|
||||||
type Position struct { |
|
||||||
Offset uint |
|
||||||
Line, Column uint |
|
||||||
} |
|
||||||
|
|
||||||
// An Scanner represent the low level layer for text parsers
|
|
||||||
type Scanner struct { |
|
||||||
name string |
|
||||||
input string |
|
||||||
|
|
||||||
base Position |
|
||||||
cursor Position |
|
||||||
runes uint |
|
||||||
} |
|
||||||
|
|
||||||
// NewScannerFromString instantiates a new Scanner to
|
|
||||||
// parse a given string
|
|
||||||
func NewScannerFromString(name, input string) *Scanner { |
|
||||||
return &Scanner{ |
|
||||||
name: name, |
|
||||||
input: input, |
|
||||||
base: Position{0, 1, 1}, |
|
||||||
cursor: Position{0, 1, 1}, |
|
||||||
runes: 0, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Length returns the number of bytes and runes in the Terminal that is been detected
|
|
||||||
func (l *Scanner) Length() (uint, uint) { |
|
||||||
return l.cursor.Offset - l.base.Offset, l.runes |
|
||||||
} |
|
||||||
|
|
||||||
// Empty tells if there are no runes accounted for the next Terminal yet
|
|
||||||
func (l *Scanner) Empty() bool { |
|
||||||
return l.runes == 0 |
|
||||||
} |
|
||||||
|
|
||||||
// StepForth moves the cursor forward
|
|
||||||
func (l *Scanner) StepForth(runes, bytes uint) { |
|
||||||
l.cursor.Offset += bytes |
|
||||||
l.cursor.Column += runes |
|
||||||
l.runes += runes |
|
||||||
} |
|
||||||
|
|
||||||
// StepBack moves the cursor backward
|
|
||||||
func (l *Scanner) StepBack(runes, bytes uint) { |
|
||||||
l.cursor.Offset -= bytes |
|
||||||
// FIXME: what if column goes < 1?
|
|
||||||
l.cursor.Column -= runes |
|
||||||
l.runes -= runes |
|
||||||
} |
|
||||||
|
|
||||||
// Reset moves the cursor back to the base
|
|
||||||
func (l *Scanner) Reset() { |
|
||||||
l.cursor = l.base |
|
||||||
l.runes = 0 |
|
||||||
} |
|
||||||
|
|
||||||
// Skip trashes everything up to the cursor
|
|
||||||
func (l *Scanner) Skip() { |
|
||||||
l.base = l.cursor |
|
||||||
l.runes = 0 |
|
||||||
} |
|
||||||
|
|
||||||
// NewLine accounts a line break in the position of the cursor
|
|
||||||
func (l *Scanner) NewLine() { |
|
||||||
l.cursor.Line++ |
|
||||||
l.cursor.Column = 1 |
|
||||||
} |
|
||||||
|
|
||||||
// Peek returns the next rune but not moving the cursor
|
|
||||||
func (l *Scanner) Peek() (rune, uint) { |
|
||||||
if l.cursor.Offset == uint(len(l.input)) { |
|
||||||
return EOF, 0 |
|
||||||
} |
|
||||||
r, bytes := utf8.DecodeRuneInString(l.input[l.cursor.Offset:]) |
|
||||||
return r, uint(bytes) |
|
||||||
} |
|
||||||
|
|
||||||
// Next returns the next rune but moving the cursor
|
|
||||||
func (l *Scanner) Next() (rune, uint) { |
|
||||||
r, bytes := l.Peek() |
|
||||||
if bytes > 0 { |
|
||||||
l.StepForth(1, bytes) |
|
||||||
} |
|
||||||
return r, bytes |
|
||||||
} |
|
||||||
@ -1,43 +0,0 @@ |
|||||||
package scanner |
|
||||||
|
|
||||||
import ( |
|
||||||
"unicode/utf8" |
|
||||||
) |
|
||||||
|
|
||||||
// A Terminal represents literal element within a document
|
|
||||||
type Terminal struct { |
|
||||||
val string |
|
||||||
bytes, runes uint |
|
||||||
line, col uint |
|
||||||
} |
|
||||||
|
|
||||||
// NewTerminalFull returns a new Terminal instance
|
|
||||||
func NewTerminalFull(val string, bytes, runes, line, col uint) *Terminal { |
|
||||||
return &Terminal{ |
|
||||||
val: val, |
|
||||||
bytes: bytes, |
|
||||||
runes: runes, |
|
||||||
line: line, |
|
||||||
col: col, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// NewTerminal creates a Terminal instance without knowing it's length
|
|
||||||
func NewTerminal(val string, line, col uint) *Terminal { |
|
||||||
bytes := uint(len(val)) |
|
||||||
runes := uint(utf8.RuneCountInString(val)) |
|
||||||
|
|
||||||
return NewTerminalFull(val, bytes, runes, line, col) |
|
||||||
} |
|
||||||
|
|
||||||
// Position retuns the position (line and column)
|
|
||||||
// of the Terminal in the source document
|
|
||||||
func (t *Terminal) Position() (uint, uint) { |
|
||||||
return t.line, t.col |
|
||||||
} |
|
||||||
|
|
||||||
// Value returns the string corresponding to
|
|
||||||
// this Terminal and it's size in bytes and runes
|
|
||||||
func (t *Terminal) Value() (string, uint, uint) { |
|
||||||
return t.val, t.bytes, t.runes |
|
||||||
} |
|
||||||
@ -0,0 +1,35 @@ |
|||||||
|
ignoreGeneratedHeader = false |
||||||
|
severity = "error" |
||||||
|
confidence = 0.8 |
||||||
|
errorCode = 1 |
||||||
|
warningCode = 0 |
||||||
|
enableAllRules = true |
||||||
|
|
||||||
|
[rule.function-length] |
||||||
|
arguments = [40,0] |
||||||
|
severity = "warning" |
||||||
|
[rule.function-result-limit] |
||||||
|
arguments = [3] |
||||||
|
[rule.argument-limit] |
||||||
|
arguments = [5] |
||||||
|
[rule.cognitive-complexity] |
||||||
|
arguments = [7] |
||||||
|
[rule.cyclomatic] |
||||||
|
arguments = [10] |
||||||
|
[rule.line-length-limit] |
||||||
|
arguments = [100] |
||||||
|
severity = "warning" |
||||||
|
[rule.comment-spacings] |
||||||
|
severity = "warning" |
||||||
|
[rule.empty-lines] |
||||||
|
severity = "warning" |
||||||
|
|
||||||
|
# Disabled rules |
||||||
|
[rule.max-public-structs] |
||||||
|
disabled = true |
||||||
|
[rule.file-header] |
||||||
|
disabled = true |
||||||
|
[rule.add-constant] |
||||||
|
disabled = true |
||||||
|
[rule.banned-characters] |
||||||
|
disabled = true |
||||||
Loading…
Reference in new issue