How do I debug this thing?

[dabrahams]

So, trying a real grammar on real input, I get:

Syntax error in file 'unknown', line 1, column 0

What's the next step? I'd like to know what the parser is recognizing, if anything.

[dabrahams]

OK, by oversimplifying my grammar I was able to find my mistake. Now it's parsing… something, but I don't know whether it's got the structure I expect. I managed to create this global rule:

_: {
            println!("---------------");
            let bytes: &[u8] = unsafe {
                std::slice::from_raw_parts(
                $n.start_loc.s as *const u8, $n.end.offset_from($n.start_loc.s).try_into().unwrap())
            };
            let s = std::str::from_utf8(bytes).expect("invalid utf8").to_string();
            println!("{}", s);
        };

So I can see some things being recognized, but I don't know what they're being recognized as. Looking into the generated C file, I see d_symbols_gram. Maybe I can pull the name of the LHS nonterminal from there?

There seems to be a lot of information about actions and what you can do there missing from the manual, e.g., start_loc et. al. aren't really documented anywhere; I had to lift them out of examples. Or is there some documentation I've overlooked?

[dabrahams]

So I managed to suss out this default action which shows me which nonterminals are recognized:

fn to_str<'a>(p: *const c_char) -> &'a str {
    let cstr = unsafe { CStr::from_ptr(p) };
    // Get a copy-on-write Cow<'_, str>, then extract the
    // allocated String (or allocate a fresh one if needed).
    cstr.to_str().expect("invalid c string")
}

fn default_action(n: &mut D_ParseNode) {
    let s: &str = unsafe {
        let p = parser_tables_gram.symbols.add(n.symbol.try_into().unwrap());
        to_str(p.read().name)
    };
    println!("------- {} -------", s);
    let bytes: &[u8] = unsafe {
        std::slice::from_raw_parts(
            n.start_loc.s as *const u8, n.end.offset_from(n.start_loc.s).try_into().unwrap())
    };
    let s = std::str::from_utf8(bytes).expect("invalid utf8").to_string();
    println!("{}", s);
}

Now the question is, how do I control it? My grammar (in the absence of priorities) is fairly ambiguous, and it's not recognizing the right things. It's built so that newlines are significant and other whitespace is, well, whitespace:, and the way I try to control the ambiguity is by deprioritizing this rule:

any_word: "[^ \t\n\r]+" $term -10 {};

the idea being that there should be a preference for recognizing lines with fewer of these any_word tokens. But it doesn't seem to be working that way. It seems like the priorities of tokens only have some kind of local effect and don't affect the priorities of nodes higher in the parse tree?

I also don't see how to control the priorities of productions other than those that have the form of binary operator productions; I don't have any kind of associativity. Hints appreciated!

Thanks,
Dave