😱 value | value but I can't parse this ❄️ value | value. Do you have an idea of why one emoji works and the other don't?link = { dest ~ ("|" ~ alias)? }
dest = { note ~ anchor? }
anchor = { (header | blockref) }
note = { ident }
alias = { ident_extended }
header = { "#" ~ !"^" ~ ident }
blockref = { "#^" ~ ident }
ident = _{ (LETTER | NUMBER | DASH_PUNCTUATION | CONNECTOR_PUNCTUATION | OTHER_SYMBOL |"$" | "(" | ")" )+ }
ident_extended = _{ (!("[[" | "]]" | CONTROL | LINE_SEPARATOR | PARAGRAPH_SEPARATOR ) ~ ANY)+ }
WHITESPACE = _{ " " }
I've been wanting to experiment with pest, but even with a simple example, I'm having inexplicable compile errors. Would someone be able to take a look? https://gist.github.com/ollien/4e1ba081e332b22423275d7b1564fffe
This looks similar to pest-parser/pest#427 but I don't think I have a name collision like they did in this issue
m, because there's no repetition marker and first is the first choice in find
"m" first and only if that fails does it try "mi"
1) Example grammar
WHITESPACE = _{ " " }
stmt_str = _{ "New Purchases" }
credit = { "+" | "-" }
dollar = _{ "$" }
amount = { ASCII_DIGIT{1, } ~ "." ~ ASCII_DIGIT{2} }
NewPurchases = { stmt_str ~ credit ~ dollar ~ amount }
2) the name `Rule` is defined multiple times
`Rule` must be defined only once in the type namespace of this modulerustcE0428
main.rs(19, 10): previous definition of the type `Rule` here
conflicting implementations of trait `std::clone::Clone` for type `Rule`
conflicting implementation for `Rule`rustcE0119 ...WHITESPACE = _{ " " }
ws = { " "+ }
stmt_str = _{ "New Purchases" }
credit = { "+" | "-" }
dollar = _{ "$" }
amount = @{ (ASCII_DIGIT{1, } | ",")+ ~ "." ~ ASCII_DIGIT{2} }
new_purchases = { stmt_str ~ credit ~ dollar ~ amount }
NewPurchases = { (!new_purchases ~ ANY)+ ~ new_purchases }
charge_date = { ASCII_DIGIT{2} ~ "/" ~ ASCII_DIGIT{2} }
post_date = { ASCII_DIGIT{2} ~ "/" ~ ASCII_DIGIT{2} }
ref_num = @{ ASCII_ALPHANUMERIC+ }
description = { (ASCII_ALPHANUMERIC | "-" | "." | "," | "*" | "/" | "'" | "#" | "&" | ws)+ }
payment = { "-"{0,1} }
charge = { charge_date ~ post_date ~ ref_num ~ description ~ dollar ~ amount ~ payment ~ NEWLINE{0,} }
charges = { charge+ }
Charges = { (!charges ~ ANY)+ ~ charges }
Total = { NewPurchases ~ Charges }
charges_repeat = { (!charges ~ ANY)+ ~ charges }
Charges = { charges_repeat+ }
Total = { StmtDate ~ BalancePrevious ~ Payments ~ CreditsOther ~ NewPurchases ~ NewCashAdvances ~ NewBalanceTransfers ~ FeesCharged ~ InterestCharged ~ BalanceNew ~ Charges }I've read through the book and looked at some code on Github on how to unwind the result Pairs to get to the strings I need. Currently I have a match statement to cycle through the Pairs from the Parser:
/// This is the results from Total above
for record in enclosed.into_inner()
match record.as_rule() {
Rule::StmtDate => {
println!(
"{:#?}",
&record.into_inner().next().unwrap().into_inner().as_str()
);
}
Rule::BalancePrevious => println!("{:#?}", &record.as_rule()),
Rule::Payments => println!("{:#?}", &record.as_rule()),
...The examples I found on Github have similar code for digging down into the structure:
Some(pair.into_inner().into_iter().next().unwrap().as_str().to_string()) for instance.
Are there any helper functions that would allow you to pull out the contents of any Rule in the structure of Pairs that you get for complicated grammars? I imagine I could write a function to do that but I'd rather borrow one :) Also, if I mangled any terminology, I am a hardware guy learning Rust to get back into programming microcontrollers. I'm learning by converting some Python scripts I wrote.
How would you get the inner contents of a string? I stole this from the JSON grammar,
string = @{ "\"" ~ inner ~ "\"" }
inner = @{ (!("\"" | "\\") ~ ANY)* ~ (escape ~ inner)? }
escape = @{ "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | unicode) }
unicode = @{ "u" ~ ASCII_HEX_DIGIT{4} }but doing something like
Rule::string => Expr::Str(pair.as_str().to_string()),would obviously take the whole thing, including the wrapping "s and escaped escape chars, whereas trying to take the inner like
Rule::string => Expr::Str(pair.into_inner().next().unwrap().as_str().to_string()),fails as there are no inner (I assume because @ rules aren't named?).. removing the @ gets me closer, but then whitespace isn't read by the inner so I'm essentially back to square one.. are you supposed to like "unpack" the dquote wrapped string contents or something?
usecase is
param1 param2
param1 :param2should be the same thing, but
param1 :should be param1 and an empty string
Hi! I'm trying an extremely simple parser for AoC, but struggle to declare the simplest grammar using grammar_inline? Anyone who could help me out?
#[derive(Parser)]
#[grammar_inline = "
instruction = _{ forward | down | up }
forward = { "forward" }
down = { "down" }
up = { "up" }
"]
struct MyParser;Produces the following error: suffixes on a string literal are invalid, pointing to the end of my string in forward = { "forward" }... Which I took directly from the book here: "other_rule" https://pest.rs/book/grammars/syntax.html
grammar_inline, I'll switch to file-based grammars for now.
