OpenSourceProjects
/
go-parsekit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
22 Commits 1 Branch 0 Tags 460 KiB
Go 99.9%
Go to file
Maurice Makaay 980c18099e A small change to the computation interpreter to get rid of one useless level of recursion. 2019-05-28 07:26:50 +00:00
.gitignore Initial commit 2019-05-21 14:45:32 +00:00
LICENSE Initial commit 2019-05-21 14:45:32 +00:00
README.md Initial import of the parsekit module. 2019-05-21 14:49:44 +00:00
example_basiccalculator1_test.go A small change to the computation interpreter to get rid of one useless level of recursion. 2019-05-28 07:26:50 +00:00
example_basiccalculator2_test.go A small change to the computation interpreter to get rid of one useless level of recursion. 2019-05-28 07:26:50 +00:00
example_dutchpostcode_test.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
example_hellomatcher_test.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
example_helloparser1_test.go Added a new example, yet another hello world. 2019-05-26 10:15:34 +00:00
example_helloparser2_test.go Added a new example, yet another hello world. 2019-05-26 10:15:34 +00:00
examples_test.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
go.mod Trying to fix module paths (I have no idea what I'm doing :-) The idea is to make parsekit into a separate module in another repo. 2019-05-21 15:05:37 +00:00
parsehandler.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsehandler_emit.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsehandler_expects.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsehandler_on.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsehandler_route.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsekit.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
parsekit_test.go A big round of getting-ya-terminology-straight. 2019-05-26 09:25:34 +00:00
stringbuf.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
stringbuf_test.go Initial import of the parsekit module. 2019-05-21 14:49:44 +00:00
tokenhandler.go A big round of getting-ya-terminology-straight. 2019-05-26 09:25:34 +00:00
tokenhandlers_builtin.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00
tokenhandlers_builtin_test.go Pfff, okay, so today I found a rather nice way of writing a parser that can hold some internal state, while stell holding on to the basic principle of having a function signature the applies to every parse handler in the system. By using methods instead of stand-alone functions, it is possible to let the accompanying struct hold on to the required state. Implemented this principle for the two calculator example projects. The rest is quite broken now, sorry :-p 2019-05-27 23:24:07 +00:00

README.md

go-parsekit

A toolkit that facilitates writing text parsers, based on a flexible combination of parser/combinator technology and a parser state machine.