Parenthesizing part of sequence fails

[jminer]

Parenthesizing part of sequence fails

[PhilippeSigaud]

The last two examples should work, yes. Could you send me your file? Maybe I pushed a non working version on github?

About the silent fail, yes, you're right, I get this pb also while working on a grammar.

I'm in the middle of rewriting the parser, but the final goal is to get better errors. From there, grammar should test if Grammar.parse(input) failed or not. Sorry for the discomfiture.

[PhilippeSigaud]

Ok, I think I get it: a char class does not accept '-' as a normal char. When you wrote [+-], it looked for another char after the - and failed. Hence the whole failure.

I used ('+' / '-') when I tried to match numbers in that way (see pegged.examples.numbers), I never thought of using a class.

Hmm, what's the regex workaround for this?

[jminer]

Ah, yes, '-' is treated specially inside a class. I didn't think about using it literally there, but that does usually work with regexes. I just tried Java's regex, and it seems like if the '-' is the first or last char in the class, it treats it normally. Both [+-] and [-+] work with it.

Here's the reduced version: https://gist.github.com/2128672 and here's the Ruby grammar I started on: https://gist.github.com/2128764

I wrote my first grammar last week. Pegged is the first parser generator I've gotten working. Thanks for writing it. I played with ANTLR some a few years ago, but had troubles learning it.

Edit: I just tried Ruby's and Notepad2's regexes, and they seem to both work like Java's.

[PhilippeSigaud]

OK, but then how does one asl for ']' in a class? I would think that there must be an escape mechanism: -, ] and \ for -, ] and \ respectively. Along with - in first or last pos.

But that will make the char class grammar a mess...

[jminer]

I just tested with regexes, and they do have escapes like you mentioned. To use a \, [, or ] in a regex char class, you have to escape them: \\, \[, and \]. (I got errors when trying to use [ unescaped.) In regexes, you can also escape other special characters like + and * even though it is unneeded.

I don't care whether you implement this or not. It would be a little more convenient, but as you say, it adds complexity. One can always work around it by using ([a-z] / '[' / ']')* instead of [a-z\[\]]*.

[PhilippeSigaud]

OK, I just implemented escape sequences for -, [, ] and . Just use -, [ ...

Btw, ' and " also work in char classes (with correct D strings that is, I like to use ` as a string delimiter.

[PhilippeSigaud]

Oh and btw, [-+] works also, because it's parsed as Char Char and not Char '-' Char

[PhilippeSigaud]

Your examples now work, either with [-+] or with [+\-].

Keep me informed on the Ruby grammar!

[PhilippeSigaud]

Hmm, I re-introduced space sensitivity in Pegged which will impact your Ruby grammar.
See the main wiki page, but the idea is that <- is PEG-standard space-sensitive rule (no space consumed between sequence elements), whereas using just < as an arrow (a 'space arrow') will create a space consuming rule, at least for its main constituents.

That means that for the gist you showed me, instead of :

        Comment <- '#' > (!EOL > .)* > (EOL / EOI)

    Expr <- FloatLiteral / IntegerLiteral

    # OctLiteral comes before DecLiteral
    IntegerLiteral <~ HexLiteral / BinLiteral / OctLiteral / DecLiteral
    FloatLiteral <~ DecLiteral > '.' > DecLiteral > ([eE] > [+-]? > [0-9]+)?

do:

        Comment <- '#'  (!EOL > .)*   (EOL / EOI)

    Expr <- FloatLiteral / IntegerLiteral

    # OctLiteral comes before DecLiteral
    IntegerLiteral <~ HexLiteral / BinLiteral / OctLiteral / DecLiteral
    FloatLiteral <~ DecLiteral   '.'   DecLiteral   ([eE]  [-+]?  [0-9]+)?

Which hopefully results in a cleaner grammar.