Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Go support #272

Closed
meme opened this issue Mar 22, 2020 · 14 comments
Closed

Go support #272

meme opened this issue Mar 22, 2020 · 14 comments

Comments

@meme
Copy link

meme commented Mar 22, 2020

Is there any planned support for Go?

Since it is quite similar syntactically to C, I have just modified all that is necessary to use the simple example from Go to illustrate what I envision:

/*!re2c re2c:flags:i = 1; */

/*!max:re2c*/
/*!re2c
    digit  = [0-9];
    number = digit+;
*/

package main

type Cursor struct {
	data []byte
	state int
}

type YYCTYPE byte
type YYMARKERTYPE *Cursor

func YYPEEK(marker YYMARKERTYPE) YYCTYPE {
	return YYCTYPE(marker.data[marker.state])
}

func YYSKIP(marker YYMARKERTYPE) {
	marker.state++
}

func Lex(YYCURSOR YYMARKERTYPE) int {
	/*!re2c
	re2c:define:YYCTYPE = YYCTYPE;
	re2c:yyfill:enable = 0;

	* { return 1 }

	number {
		fmt.Println("number\n")
		return 0
	}
	*/
}

func main() {
	state := &Cursor{
		data:  []byte("1024 ;]"),
		state: 0,
	}

	fmt.Println(Lex(state))
	fmt.Println(Lex(state))
}
re2c --input custom -W example.r2
/* Generated by re2c 1.3 on Sun Mar 22 12:43:56 2020 */

package main

import "fmt"

type Cursor struct {
	data  []byte
	state int
}

type YYCTYPE byte
type YYMARKERTYPE *Cursor

func YYPEEK(marker YYMARKERTYPE) YYCTYPE {
	return YYCTYPE(marker.data[marker.state])
}

func YYSKIP(marker YYMARKERTYPE) {
	marker.state++
}

func Lex(YYCURSOR YYMARKERTYPE) int {

	{
		var yych YYCTYPE
		yych = YYPEEK(YYCURSOR)
		switch yych {
		case '0':
			fallthrough
		case '1':
			fallthrough
		case '2':
			fallthrough
		case '3':
			fallthrough
		case '4':
			fallthrough
		case '5':
			fallthrough
		case '6':
			fallthrough
		case '7':
			fallthrough
		case '8':
			fallthrough
		case '9':
			goto yy4
		default:
			goto yy2
		}
	yy2:
		YYSKIP(YYCURSOR)
		{
			return 1
		}
	yy4:
		YYSKIP(YYCURSOR)
		yych = YYPEEK(YYCURSOR)
		switch yych {
		case '0':
			fallthrough
		case '1':
			fallthrough
		case '2':
			fallthrough
		case '3':
			fallthrough
		case '4':
			fallthrough
		case '5':
			fallthrough
		case '6':
			fallthrough
		case '7':
			fallthrough
		case '8':
			fallthrough
		case '9':
			goto yy4
		default:
			goto yy6
		}
	yy6:
		{
			fmt.Println("number\n")
			return 0
		}
	}

}

func main() {
	state := &Cursor{
		data:  []byte("1024 ;]"),
		state: 0,
	}

	fmt.Println(Lex(state))
	fmt.Println(Lex(state))
}

The patch is as follows (modifications only to what was deemed necessary):

git diff
diff --git a/src/codegen/emit_action.cc b/src/codegen/emit_action.cc
index 3d51707b..be5ec626 100644
--- a/src/codegen/emit_action.cc
+++ b/src/codegen/emit_action.cc
@@ -327,7 +327,7 @@ void gen_goto(code_lines_t &code, const State *from, const State *to
 
     if (to) {
         code.push_back("goto " + opts->labelPrefix
-            + to_string(to->label) + ";\n");
+            + to_string(to->label) + "\n");
     }
 }
 
diff --git a/src/codegen/emit_dfa.cc b/src/codegen/emit_dfa.cc
index b829b534..e41a2b74 100644
--- a/src/codegen/emit_dfa.cc
+++ b/src/codegen/emit_dfa.cc
@@ -229,7 +229,7 @@ void DFA::emit(Output & output, uint32_t& ind, bool isLastCond, bool& bPrologBra
             {
                 if (opts->bEmitYYCh)
                 {
-                    output.wind(ind).wstring(opts->yyctype).ws(" ").wstring(opts->yych).ws(";\n");
+                    output.wind(ind).ws("var ").wstring(opts->yych).ws(" ").wstring(opts->yyctype).ws("\n");
                 }
                 output.wdelay_yyaccept_init (ind);
             }
diff --git a/src/codegen/go_emit.cc b/src/codegen/go_emit.cc
index c608b506..88f5792c 100644
--- a/src/codegen/go_emit.cc
+++ b/src/codegen/go_emit.cc
@@ -61,7 +61,7 @@ void Case::emit (Output & o, uint32_t ind) const
             bool last_case = i == ranges.size () - 1 && b == ranges[i].second - 1;
             if (!last_case)
             {
-                o.ws("\n");
+                o.ws(" fallthrough\n");
             }
         }
     }
@@ -69,7 +69,7 @@ void Case::emit (Output & o, uint32_t ind) const
 
 void Cases::emit(Output &o, uint32_t ind, const DFA &dfa, const State *from) const
 {
-    o.wind(ind).ws("switch (").wstring(o.block().opts->yych).ws(") {\n");
+    o.wind(ind).ws("switch ").wstring(o.block().opts->yych).ws(" {\n");
 
     for (uint32_t i = 1; i < cases_size; ++i) {
         const Case &c = cases[i];
diff --git a/src/codegen/input_api.cc b/src/codegen/input_api.cc
index 6760711d..a4ae5ce9 100644
--- a/src/codegen/input_api.cc
+++ b/src/codegen/input_api.cc
@@ -12,7 +12,7 @@ std::string output_expr_peek(const opt_t *opts)
 {
     return opts->input_api == INPUT_DEFAULT
         ? "*" + opts->yycursor
-        : opts->yypeek + " ()";
+        : opts->yypeek + "(" + opts->yycursor + ")";
 }
 
 std::string output_restore(uint32_t ind, const opt_t *opts)
@@ -47,7 +47,7 @@ void output_peek(std::ostream &o, uint32_t ind, const opt_t *opts)
 {
     o << indent(ind, opts->indString) << opts->yych << " = " << yych_conv(opts);
     if (opts->input_api == INPUT_CUSTOM) {
-        o << opts->yypeek << " ()";
+        o << opts->yypeek << "(" + opts->yycursor + ")";
     } else {
         o << "*" << opts->yycursor;
     }
@@ -58,7 +58,7 @@ void output_skip(std::ostream &o, uint32_t ind, const opt_t *opts)
 {
     o << indent(ind, opts->indString);
     if (opts->input_api == INPUT_CUSTOM) {
-        o << opts->yyskip << " ()";
+        o << opts->yyskip << "(" + opts->yycursor + ")";
     } else {
         o << "++" << opts->yycursor;
     }

I am wondering if you would be open to further work on the Go output, to be used with the -go compiler flag, for example.

@skvadrik
Copy link
Owner

skvadrik commented Mar 22, 2020

I'm certainly interested in adding Go support (although no work in that direction has been done yet). Thanks for the patch, I will have a closer look in a few days.

@skvadrik
Copy link
Owner

skvadrik commented Mar 24, 2020

For this example, it is almost possible to use re2c in its current form.

The only necessary modification is the addition of fallthrough. The changes to YYPEEK and YYSKIP are not needed because they can be closures (see the code below). The change to yych is not needed because re2c has a configuration re2c:yych:emit = 0;. The modified example looks like this:

/*!re2c re2c:flags:i = 1; */

package main

import "fmt"

type YYCTYPE byte
type Cursor struct {
        data  []YYCTYPE
        offset int
}

func peek(cursor *Cursor) func() YYCTYPE {
        c := cursor
        return func() YYCTYPE {
                return c.data[c.offset]
        }
}

func skip(cursor *Cursor) func() {
        c := cursor
        return func() {
                c.offset++
        }
}

func Lex(YYCURSOR *Cursor) int {
        YYPEEK := peek(YYCURSOR)
        YYSKIP := skip(YYCURSOR)
        var yych YYCTYPE

        /*!re2c
        re2c:yych:emit = 0;
        re2c:yyfill:enable = 0;

        digit  = [0-9];
        number = digit+;

        * { return 1 }

        number {
                fmt.Println("number\n")
                return 0
        }
        */
}

func main() {
        cursor := &Cursor{
                data:  []YYCTYPE("1024 ;]"),
                offset: 0,
        }

        fmt.Println(Lex(cursor))
        fmt.Println(Lex(cursor))
}

Run like this (the invocation of sed adds fallthrough):

re2c 1.re -W -o 1.go --input custom && \
    sed -i -E "s/^(\tcase '[0-9A-F]+':)$/\1\tfallthrough/g" 1.go && \
    go build 1.go && \
    ./1
number

0
1

@skvadrik
Copy link
Owner

skvadrik commented Mar 24, 2020

More generally, the difficulty with adding Go (or any other language) support to re2c is in anticipating all possible scenarios in which re2c can be used. The example above only uses a small subset of re2c features (e.g. it's not using YYFILL). So I need to experiment with other features.

But I'm surprised that so little change is needed to make this example work. :)

@meme
Copy link
Author

meme commented Mar 24, 2020

What are the next steps, does the current set of examples cover the feature set of re2c? If so, would it make sense to translate them all to Go and use those as a test bench for the Go compiler back-end?

Further, it seems that the codegen subsystem of the project is not factored for multiple targets beyond both TARGET_CODE and TARGET_DOT, so I ask: do you foresee the addition of more targets to re2c? Then it might be worth while organizing that to facilitate more back-ends and working on the Go back-end using that refactored system.

Lastly, there's one more idea I want to pitch: ideally, I'd like to see Go projects that use re2c use the go generate functionality, something like:

//go:generate re2c -o lexer.go lexer.re

It would still require re2c to be installed, but I think it has the opportunity to fit really nicely into the Go ecosystem.

@skvadrik
Copy link
Owner

skvadrik commented Mar 24, 2020

What are the next steps, does the current set of examples cover the feature set of re2c? If so, would it make sense to translate them all to Go and use those as a test bench for the Go compiler back-end?

Yes, something like that. In many cases re2c has a few alternative ways of doing things, like using default or generic API, using or not using EOF rule, etc. For a start, it suffices to choose one that is easier to adapt, and the alternative options should be be forbidden for the Go backend.

Further, it seems that the codegen subsystem of the project is not factored for multiple targets beyond both TARGET_CODE and TARGET_DOT, so I ask: do you foresee the addition of more targets to re2c?

Yes, it's been on my wish list for a while. I did some preliminary work, but the codegen subsystem is still in a mess. It needs restructuring to separate the construction of a C program from its rendering (conversion to text). The current representation is a list of program fragments, some of which are rendered immediately, and some are placeholders for data that is accumulated over the whole program and can only be rendered at the end of codegen phase. Restructuring the code is not a strict prerequisite for Go support: it can be done in a step by step manner, starting with some rudimentary support and gradually making it better. As long as it's not released, it's not part of the API and can be changed.

ideally, I'd like to see Go projects that use re2c use the go generate functionality

Sounds good. Does Go use compiler plugins for 3rd party tools like re2c?

@skvadrik
Copy link
Owner

skvadrik commented Mar 25, 2020

I started an experimental branch golang-backend and added the above example (slightly modified) as a test: b7facb2.

@meme
Copy link
Author

meme commented Mar 25, 2020

  1. Agreed, but I'll have to leave that to you because I am much less comfortable with the more advanced features of re2c
  2. I also think it is worth just hacking it in and then gradually making it better
  3. Apologies if I was not clear, go generate runs the argument as a command during go build, so no modification to Go is required, you simply need re2c in your path, and then anyone that go gets or go builds the project will be good to go

Experimental branch looks good. What can I do to help, or are you planning on implementing the necessary changes for the feature request?

@skvadrik
Copy link
Owner

skvadrik commented Mar 25, 2020

Agreed, but I'll have to leave that to you because I am much less comfortable with the more advanced features of re2c

Sure, no problem with that. I'm interested in doing this. (I just try to keep the discussion in the open. )

Apologies if I was not clear, go generate runs the argument as a command during go build [...]

Ah, that's how it works. I think it would make sense to have a tool re2go (which will be just re2c with Go backend enabled by default).

What can I do to help, or are you planning on implementing the necessary changes for the feature request?

I am. You can help by trying to use the golang-backend branch on your real-world example and commenting on what's missing. But! In case you wanted to do a bit of re2c hacking and implement Go support yourself (at least in its basic form), I can step aside and review your pull requests. Just let me know.

@meme
Copy link
Author

meme commented Mar 25, 2020

Sounds good to me! I'll opt to help by using the Go branch in the project I had intended to use re2c for. Thanks for your interest in the request.

@meme
Copy link
Author

meme commented May 2, 2020

Now that Go support has landed in master, should this be closed?

@skvadrik
Copy link
Owner

skvadrik commented May 2, 2020

@meme I merged the experimental branch because it contained useful work that should be on master, and because I didn't want it to diverge too far. But i didn't finish working on Go support yet. I have done the most difficult preliminary work (full restructuring of the code generation subsystem), but a lot of follow-up work still remains. There are only a few Go tests yet and no documentation. Lets keep the bug open for now.

@skvadrik
Copy link
Owner

skvadrik commented Jul 14, 2020

Go support is fully working in master now. I will release 2.0 soon and update documentation on the website.

@meme
Copy link
Author

meme commented Jul 14, 2020

Incredible! Thank you for your work. Will take a look at Go integration, please let me know if the docs need attention w.r.t. using //go:generate & other Go-isms

@skvadrik
Copy link
Owner

skvadrik commented Jul 19, 2020

@meme Thanks! The Go examples are here if you'd like to take a look. The source files have .re extension and the output files have .go extension, which is currently a requirement of the re2c testing script. But with a trivial renaming and patching of the go:generate comment they can be processed with go generate and go test.

netbsd-srcmastr pushed a commit to NetBSD/pkgsrc that referenced this issue Sep 20, 2020
2.0.3 (2020-08-22)
~~~~~~~~~~~~~~~~~~

- Fix issues when building re2c as a CMake subproject
  (`#302 <https://github.com/skvadrik/re2c/pull/302>`_:

- Final corrections in the SIMPA article "RE2C: A lexer generator based on
  lookahead-TDFA", https://doi.org/10.1016/j.simpa.2020.100027

2.0.2 (2020-08-08)
~~~~~~~~~~~~~~~~~~

- Enable re2go building by default.

- Package CMake files into release tarball.

2.0.1 (2020-07-29)
~~~~~~~~~~~~~~~~~~

- Updated version for CMake build system (forgotten in release 2.0).

- Added a short article about re2c for the Software Impacts journal.

2.0 (2020-07-20)
~~~~~~~~~~~~~~~~

- Added new code generation backend for Go and a new ``re2go`` program
  (`#272 <https://github.com/skvadrik/re2c/issues/272>`_: Go support).
  Added option ``--lang <c | go>``.

- Added CMake build system as an alternative to Autotools
  (`#275 <https://github.com/skvadrik/re2c/pull/275>`_:
  Add a CMake build system (thanks to ligfx),
  `#244 <https://github.com/skvadrik/re2c/issues/244>`_: Switching to CMake).

- Changes in generic API:

  + Removed primitives ``YYSTAGPD`` and ``YYMTAGPD``.
  + Added primitives ``YYSHIFT``, ``YYSHIFTSTAG``, ``YYSHIFTMTAG``
    that allow to express fixed tags in terms of generic API.
  + Added configurations ``re2c:api:style`` and ``re2c:api:sigil``.
  + Added named placeholders in interpolated configuration strings.

- Changes in reuse mode (``-r, --reuse`` option):

  + Do not reset API-related configurations in each `use:re2c` block
    (`#291 <https://github.com/skvadrik/re2c/issues/291>`_:
    Defines in rules block are not propagated to use blocks).
  + Use block-local options instead of last block options.
  + Do not accumulate options from rules/reuse blocks in whole-program options.
  + Generate non-overlapping YYFILL labels for reuse blocks.
  + Generate start label for each reuse block in storable state mode.

- Changes in start-conditions mode (``-c, --start-conditions`` option):

  + Allow to use normal (non-conditional) blocks in `-c` mode
    (`#263 <https://github.com/skvadrik/re2c/issues/263>`_:
    allow mixing conditional and non-conditional blocks with -c,
    `#296 <https://github.com/skvadrik/re2c/issues/296>`_:
    Conditions required for all lexers when using '-c' option).
  + Generate condition switch in every re2c block
    (`#295 <https://github.com/skvadrik/re2c/issues/295>`_:
    Condition switch generated for only one lexer per file).

- Changes in the generated labels:

  + Use ``yyeof`` label prefix instead of ``yyeofrule``.
  + Use ``yyfill`` label prefix instead of ``yyFillLabel``.
  + Decouple start label and initial label (affects label numbering).

- Removed undocumented configuration ``re2c🎏o``, ``re2c🎏output``.

- Changes in ``re2c🎏t``, ``re2c🎏type-header`` configuration:
  filename is now relative to the output file directory.

- Added option ``--case-ranges`` and configuration ``re2c🎏case-ranges``.

- Extended fixed tags optimization for the case of fixed-counter repetition.

- Fixed bugs related to EOF rule:

  + `#276 <https://github.com/skvadrik/re2c/issues/276>`_:
    Example 01_fill.re in docs is broken
  + `#280 <https://github.com/skvadrik/re2c/issues/280>`_:
    EOF rules with multiple blocks
  + `#284 <https://github.com/skvadrik/re2c/issues/284>`_:
    mismatched YYBACKUP and YYRESTORE
    (Add missing fallback states with EOF rule)

- Fixed miscellaneous bugs:

  + `#286 <https://github.com/skvadrik/re2c/issues/286>`_:
    Incorrect submatch values with fixed-length trailing context.
  + `#297 <https://github.com/skvadrik/re2c/issues/297>`_:
    configure error on ubuntu 18.04 / cmake 3.10

- Changed bootstrap process (require explicit configuration flags and a path to
  re2c executable to regenerate the lexers).

- Added internal options ``--posix-prectable <naive | complex>``.

- Added debug option ``--dump-dfa-tree``.

- Major revision of the paper "Efficient POSIX submatch extraction on NFA".

----
1.3x
----

1.3 (2019-12-14)
~~~~~~~~~~~~~~~~

- Added option: ``--stadfa``.

- Added warning: ``-Wsentinel-in-midrule``.

- Added generic API primitives:

  + ``YYSTAGPD``
  + ``YYMTAGPD``

- Added configurations:

  + ``re2c:sentinel = 0;``
  + ``re2c:define:YYSTAGPD = "YYSTAGPD";``
  + ``re2c:define:YYMTAGPD = "YYMTAGPD";``

- Worked on reproducible builds
  (`#258 <https://github.com/skvadrik/re2c/pull/258>`_:
  Make the build reproducible).

----
1.2x
----

1.2.1 (2019-08-11)
~~~~~~~~~~~~~~~~~~

- Fixed bug `#253 <https://github.com/skvadrik/re2c/issues/253>`_:
  re2c should install unicode_categories.re somewhere.

- Fixed bug `#254 <https://github.com/skvadrik/re2c/issues/254>`_:
  Turn off re2c:eof = 0.

1.2 (2019-08-02)
~~~~~~~~~~~~~~~~

- Added EOF rule ``$`` and configuration ``re2c:eof``.

- Added ``/*!include:re2c ... */`` directive and ``-I`` option.

- Added ``/*!header:re2c:on*/`` and ``/*!header:re2c:off*/`` directives.

- Added ``--input-encoding <ascii | utf8>`` option.

  + `#237 <https://github.com/skvadrik/re2c/issues/237>`_:
    Handle non-ASCII encoded characters in regular expressions
  + `#250 <https://github.com/skvadrik/re2c/issues/250>`_
    UTF8 enoding

- Added include file with a list of definitions for Unicode character classes.

  + `#235 <https://github.com/skvadrik/re2c/issues/235>`_:
    Unicode character classes

- Added ``--location-format <gnu | msvc>`` option.

  + `#195 <https://github.com/skvadrik/re2c/issues/195>`_:
    Please consider using Gnu format for error messages

- Added ``--verbose`` option that prints "success" message if re2c exits
  without errors.

- Added configurations for options:

  + ``-o --output`` (specify output file)
  + ``-t --type-header`` (specify header file)

- Removed configurations for internal/debug options.

- Extended ``-r`` option: allow to mix multiple ``/*!rules:re2c*/``,
  ``/*!use:re2c*/`` and ``/*!re2c*/`` blocks.

  + `#55 <https://github.com/skvadrik/re2c/issues/55>`_:
    allow standard re2c blocks in reuse mode

- Fixed ``-F --flex-support`` option: parsing and operator precedence.

  + `#229 <https://github.com/skvadrik/re2c/issues/229>`_:
    re2c option -F (flex syntax) broken
  + `#242 <https://github.com/skvadrik/re2c/issues/242>`_:
    Operator precedence with --flex-syntax is broken

- Changed difference operator ``/`` to apply before encoding expansion of
  operands.

  + `#236 <https://github.com/skvadrik/re2c/issues/236>`_:
    Support range difference with variable-length encodings

- Changed output generation of output file to be atomic.

  + `#245 <https://github.com/skvadrik/re2c/issues/245>`_:
    re2c output is not atomic

- Authored research paper "Efficient POSIX Submatch Extraction on NFA"
  together with Dr Angelo Borsotti.

- Added experimental libre2c library (``--enable-libs`` configure option) with
  the following algorithms:

  + TDFA with leftmost-greedy disambiguation
  + TDFA with POSIX disambiguation (Okui-Suzuki algorithm)
  + TNFA with leftmost-greedy disambiguation
  + TNFA with POSIX disambiguation (Okui-Suzuki algorithm)
  + TNFA with lazy POSIX disambiguation (Okui-Suzuki algorithm)
  + TNFA with POSIX disambiguation (Kuklewicz algorithm)
  + TNFA with POSIX disambiguation (Cox algorithm)

- Added debug subsystem (``--enable-debug`` configure option) and new debug
  options:

  + ``-dump-cfg`` (dump control flow graph of tag variables)
  + ``-dump-interf`` (dump interference table of tag variables)
  + ``-dump-closure-stats`` (dump epsilon-closure statistics)

- Added internal options:

  + ``--posix-closure <gor1 | gtop>`` (switch between shortest-path algorithms
    used for the construction of POSIX closure)

- Fixed a number of crashes found by American Fuzzy Lop fuzzer:

  + `#226 <https://github.com/skvadrik/re2c/issues/226>`_,
    `#227 <https://github.com/skvadrik/re2c/issues/227>`_,
    `#228 <https://github.com/skvadrik/re2c/issues/228>`_,
    `#231 <https://github.com/skvadrik/re2c/issues/231>`_,
    `#232 <https://github.com/skvadrik/re2c/issues/232>`_,
    `#233 <https://github.com/skvadrik/re2c/issues/233>`_,
    `#234 <https://github.com/skvadrik/re2c/issues/234>`_,
    `#238 <https://github.com/skvadrik/re2c/issues/238>`_

- Fixed handling of newlines:

  + correctly parse multi-character newlines CR LF in ``#line`` directives
  + consistently convert all newlines in the generated file to Unix-style LF

- Changed default tarball format from .gz to .xz.

  + `#221 <https://github.com/skvadrik/re2c/issues/221>`_:
    big source tarball

- Fixed a number of other bugs and resolved issues:

  + `#2 <https://github.com/skvadrik/re2c/issues/2>`_: abort
  + `#6 <https://github.com/skvadrik/re2c/issues/6>`_: segfault
  + `#10 <https://github.com/skvadrik/re2c/issues/10>`_:
    lessons/002_upn_calculator/calc_002 doesn't produce a useful example program
  + `#44 <https://github.com/skvadrik/re2c/issues/44>`_:
    Access violation when translating the attached file
  + `#49 <https://github.com/skvadrik/re2c/issues/49>`_:
    wildcard state \000 rules makes lexer behave weard
  + `#98 <https://github.com/skvadrik/re2c/issues/98>`_:
    Transparent handling of #line directives in input files
  + `#104 <https://github.com/skvadrik/re2c/issues/104>`_:
    Improve const-correctness
  + `#105 <https://github.com/skvadrik/re2c/issues/105>`_:
    Conversion of pointer parameters into references
  + `#114 <https://github.com/skvadrik/re2c/issues/114>`_:
    Possibility of fixing bug 2535084
  + `#120 <https://github.com/skvadrik/re2c/issues/120>`_:
    condition consisting of default rule only is ignored
  + `#167 <https://github.com/skvadrik/re2c/issues/167>`_:
    Add word boundary support
  + `#168 <https://github.com/skvadrik/re2c/issues/168>`_:
    Wikipedia's article on re2c
  + `#180 <https://github.com/skvadrik/re2c/issues/180>`_:
    Comment syntax?
  + `#182 <https://github.com/skvadrik/re2c/issues/182>`_:
    yych being set by YYPEEK () and then not used
  + `#196 <https://github.com/skvadrik/re2c/issues/196>`_:
    Implicit type conversion warnings
  + `#198 <https://github.com/skvadrik/re2c/issues/198>`_:
    no match for ‘operator!=’ in ‘i != std::vector<_Tp, _Alloc>::rend() [with _Tp = re2c::bitmap_t, _Alloc = std::allocator<re2c::bitmap_t>]()’
  + `#210 <https://github.com/skvadrik/re2c/issues/210>`_:
    How to build re2c in windows?
  + `#215 <https://github.com/skvadrik/re2c/issues/215>`_:
    A memory read overrun issue in s_to_n32_unsafe.cc
  + `#220 <https://github.com/skvadrik/re2c/issues/220>`_:
    src/dfa/dfa.h: simplify constructor to avoid g++-3.4 bug
  + `#223 <https://github.com/skvadrik/re2c/issues/223>`_:
    Fix typo
  + `#224 <https://github.com/skvadrik/re2c/issues/224>`_:
    src/dfa/closure_posix.cc: pack() tweaks
  + `#225 <https://github.com/skvadrik/re2c/issues/225>`_:
    Documentation link is broken in libre2c/README
  + `#230 <https://github.com/skvadrik/re2c/issues/230>`_:
    Changes for upcoming Travis' infra migration
  + `#239 <https://github.com/skvadrik/re2c/issues/239>`_:
    Push model example has wrong re2c invocation, breaks guide
  + `#241 <https://github.com/skvadrik/re2c/issues/241>`_:
    Guidance on how to use re2c for full-duplex command & response protocol
  + `#243 <https://github.com/skvadrik/re2c/issues/243>`_:
    A code generated for period (.) requires 4 bytes
  + `#246 <https://github.com/skvadrik/re2c/issues/246>`_:
    Please add a license to this repo
  + `#247 <https://github.com/skvadrik/re2c/issues/247>`_:
    Build failure on current Cygwin, probably caused by force-fed c++98 mode
  + `#248 <https://github.com/skvadrik/re2c/issues/248>`_:
    distcheck still looks for README
  + `#251 <https://github.com/skvadrik/re2c/issues/251>`_:
    Including what you use is find, but not without inclusion guards

- Updated documentation and website.
@skvadrik skvadrik mentioned this issue Oct 29, 2021
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

2 participants