Parser forgets to check every alteration sometimes.

[simon-glitch]

I have this code for a Rule:

  Property_Value
    = Value_Expression
    | Value_Function
    | Value_String

And the parser is not checking Value_Function nor Value_String.

Value_Expression leads it to the end of the string and the parser forgets that it could use Value_Function or Value_String instead of Value_Function nor Value_Expression. I have a part of Value_Expression that includes end. Am I supposed to avoid using end or something?

Here is the full Grammar file (in case it is helpful; yes, I know it is long):

Base {
  // make sure built-in rules are defined correctly
  letter
    := lower | upper | "_"
  letters
    = letter+
  lower
    := "a" .. "z"
  upper
    := "A" .. "Z"
  rawDigit
    = "0".."9"
  digit
    := rawDigit | "_"
  rawHexDigit
    = rawDigit | ("A" .. "F") | ("a" .. "f")
  hexDigit
    := digit | ("A" .. "F") | ("a" .. "f")
  alnum
    := letter | digit
  // I could've just done Line_break, but line_break works in lexical contexts as well, so ... im using it like this.
  line_break
    = (spaces ("\n" | ";") spaces)
}





Arithmetic <: Base {
  Script_Exp
    = //ListOf<Script_Line_Exp, line_break> -- multiline
    | Script_Line_Exp line_break? -- singleline
    | line_break
  Script_Line_Exp
    = ident assignment Exp -- assignment
    | ident "(" Parameters_In_Paren ")" -- function_call
    | Exp
  assignment
    = ("+" | "+" | "-" | "*" | "/" | "+" | "+")? "="
  Assignment_Exp
    = "$"? Assignment_sub_Exp
  Assignment_sub_Exp
    = ident spaces " is " Exp -- is
    | ident spaces assignment Exp -- equal
    | ident spaces " is(" Exp ")" -- is_paren
  Parameters_In_Paren
    = ListOf<Exp, ",">
  
  Exp
    // first line is an optimization for one when an "expression" is just a singleton
    = Logic_And_Exp -- calculation

  Logic_And_Exp
    = Logic_And_Exp ("&&"  | " and " ) Logic_Or_Exp  -- logical_and
    | Logic_And_Exp ("!&&" | " nand ") Logic_Or_Exp  -- logical_nand
    | Logic_Or_Exp
  Logic_Or_Exp
    = Logic_Or_Exp ("||"  | " or " ) Bitwise_Exp  -- logical_or
    | Logic_Or_Exp ("!||" | " nor ") Bitwise_Exp  -- logical_nor
    | Logic_Or_Exp ("^||" | " xor ") Bitwise_Exp  -- logical_xor
    | Bitwise_Exp
  
  Bitwise_Exp
    = Bitwise_Exp "&"  Add_Exp  -- and
    | Bitwise_Exp "!&" Add_Exp  -- nand
    | Bitwise_Exp "|"  Add_Exp  -- or
    | Bitwise_Exp "!|" Add_Exp  -- nor
    | Bitwise_Exp "^|" Add_Exp  -- xor
    | Add_Exp
  
  Add_Exp
    = Add_Exp "+" Mul_Exp  -- plus
    | Add_Exp "-" Mul_Exp  -- minus
    | Mul_Exp

  Mul_Exp
    = Mul_Exp "*" Exp_Exp  -- times
    | Mul_Exp "/" Exp_Exp  -- divide
    | Exp_Exp

  Exp_Exp
    = Exp_Exp ("^" | "**") Pri_Exp  -- power
    | Pri_Exp

  A_Pri_Exp<A_Exp>
    = number
    | ident
    | "(" A_Exp ")"  -- paren
    | "[" A_Exp "]"  -- array
    | "{" A_Exp "}"  -- object
    | ("!" | "no ") Pri_Exp  -- logical_not
    | "~" Pri_Exp  -- bitwise_not
    // these unaries can be stacked; that might be a bad thing, but i am not sure; well see, i guess;
    | "++" Pri_Exp -- increment
    | "--" Pri_Exp -- decrement
    | "+" Pri_Exp  -- pos
    | "-" Pri_Exp  -- neg
    | Any_Exp
  Pri_Exp
    = A_Pri_Exp<Exp>
  // doesn't use the nesting brackets from Pri_Exp
  Single_Exp
    = A_Pri_Exp<end>

  Any_Exp
    = date_Exp
    | reg_Exp
    | color_Exp
    | Unit_Exp
    | selector_Exp
    | html_Element_Exp
    | Pri_Exp "++" -- increment
    | Pri_Exp "--" -- decrement

  // date formatting
  date_Exp
    = date_sub_Exp era_Exp?
  era_Exp
    = ("B"? "CE") -- ce
    | "BC"
    | "AD"
    | ("B."? "C.E.") -- ce_dots
    | "B.C."
    | "A.D."
  date_sub_Exp
    = a_date_Exp<"/"> -- true_slashes
    | a_date_Exp<"."> -- true_dots
    | "/" loose_month_Exp
      "/" loose_day_Exp
      "/" loose_year_Exp -- slashes
    | "." loose_year_Exp
      "." loose_month_Exp
      "." loose_day_Exp -- dots
  loose_day_Exp
    = decimal_int decimal_int? -- day
  loose_month_Exp
    = decimal_int decimal_int? -- month_number
    | month_name -- month_name
  loose_year_Exp
    = decimal_int decimal_int (decimal_int decimal_int)? -- year

  a_date_Exp<a_sep>
    = (true_year_Exp  a_sep true_month_Exp a_sep true_day_Exp  )
    | (true_year_Exp  a_sep true_day_Exp   a_sep true_month_Exp)
    | (true_month_Exp a_sep true_year_Exp  a_sep true_day_Exp  )
    | (true_month_Exp a_sep true_day_Exp   a_sep true_year_Exp )
    | (true_day_Exp   a_sep true_year_Exp  a_sep true_month_Exp)
    | (true_day_Exp   a_sep true_month_Exp a_sep true_year_Exp )
  true_year_Exp
    = decimal_int decimal_int decimal_int decimal_int -- year
  true_month_Exp
    = month_name -- month
  true_day_Exp
    = decimal_int decimal_int? -- day
  month_name
    = caseInsensitive<"jan"> caseInsensitive<"uary">?
    | caseInsensitive<"feb"> caseInsensitive<"uary">?
    | caseInsensitive<"mar"> caseInsensitive<"ch">?
    | caseInsensitive<"apr"> caseInsensitive<"il">?
    | caseInsensitive<"may"> caseInsensitive<"">?
    | caseInsensitive<"jun"> caseInsensitive<"e">?
    | caseInsensitive<"jul"> caseInsensitive<"y">?
    | caseInsensitive<"aug"> caseInsensitive<"ust">?
    | caseInsensitive<"sep"> caseInsensitive<"tember">?
    | caseInsensitive<"oct"> caseInsensitive<"ober">?
    | caseInsensitive<"nov"> caseInsensitive<"ember">?
    | caseInsensitive<"dec"> caseInsensitive<"ember">?
  
  
  // regular expression formatting
  reg_Exp
    = "/" regexp_body "/" regexp_flags
  // javascript only supports these flags, currently
  // just match the original flag 6 times
  regexp_flags
    = regexp_flag? regexp_flag? regexp_flag? regexp_flag? regexp_flag? regexp_flag?
  regexp_flag
    = ("g"|"i"|"m"|"s"|"u"|"y")
  regexp_body
    = (regexp_sub_body (regexp_quantifier?))
  regexp_sub_body
    = regexp_alts
    | "(" regexp_body? ")" -- parens
  regexp_alts
    = "[" regexp_dict_body "]" -- dict
    | listOf<regexp_stuff, "|"> -- pipe
    | regexp_stuff+ -- not_alternating

  regexp_dict_body
    = (~"]") ("\\\\" | "\\]" | (~("\\\\" | "\\]")) any)
  
  regexp_stuff
    = regexp_non_special+
    | regexp_non_special regexp_body -- left_stuff
    | regexp_body regexp_non_special -- right_stuff

  // im using a matching grammar to descibe a matching grammar!
  // this is REALLY bending my brain!!!
  regexp_quantifier
    = ("+" | "*" | "?" | regexp_quantity) "?"?
  regexp_quantity
    = "{" listOf<regexp_sub_quantity, ","> "}"
  regexp_sub_quantity
    = digit+ "+"?
  // this is not hard to understand at all; it is trivial, right?!
  regexp_non_special
    = (~("{" | "[" | "(" | "\\" | "?" | "$" | "")) any -- normal_character
    | "\\\\"
    | "\\" digit+ -- group_reference // or escaped character, depending on how many groups there are
    | (~(regexp_quantity)) "{" -- improper_quantifier
    | "[" ~(regexp_dict_body "]") -- improper_dict
    | "(" ~(((~")") any)+ ")") -- improper_group
    | "\\" ~((~"_") digit) any -- escaped_character

  // colors
  color_Exp
    = "#" rawHexDigit rawHexDigit rawHexDigit (rawHexDigit rawHexDigit rawHexDigit)?
  // units (measuerment, currency)
  Unit_Exp
    = Exp ident
  // IGM selectors
  selector_Exp
    = ident ":" selector_Exp -- recursion
    | ident
  // HTML element?
  html_Element_Exp
    = "<" ident ">" ((~("</")) any)* "</" ident ">"
  // more formats!
  ident  (an identifier)
    = letter alnum*

  // any valid JavaScript number
  number  (a number)
    = decimal_number
    | binary_number
    | octal_number
    | hex_number
  a_fixed_point<aDigit>
    = aDigit+ ("." aDigit+) -- two_ints
    | "." aDigit+ -- intless
  a_int<aDigit>
    = ("-")? aDigit+
  a_numvalue<aDigit>
    = a_fixed_point<aDigit>
    | a_int<aDigit>
  a_float<aDigit>
    = a_numvalue<aDigit> ("e" | "E") ("+")? a_int<aDigit>
  a_number<aDigit>
    = a_float<aDigit> -- float
    | a_fixed_point<aDigit> -- a_fixed_point
    | a_int<aDigit> -- int
  decimal_number
    = a_number<digit>
  decimal_int
    = a_int<digit>
  binary_number
    = "0b" a_number<("0" | "1" | "_")>
  octal_number
    = "0o" a_number<(("0" .. "7") | "_")>
  hex_number
    = "0x" a_number<hexDigit>
  raw_hex_int
    = a_int<hexDigit>
  // alt name for hex
  hexadecimal_number
    = hex_number
}






Game <: Arithmetic {
  // now on to game's rules
  Section
    = Section_Name line_break Section_Contents
  Section_Name
    = ((~line_break) any)+
  Section_Contents
    = (Section_Components line_break)? Section_Things?
  Section_Components
    = Property (line_break Property)*
  Section_Things
    = Thing (line_break Thing)*
  Thing
    = Thing_Name (line_break Property)*
  Thing_Name
    = "*" main_name ("|" alt_name)*
  main_name
    = letter+
  alt_name
    = letter+
  
  Property
    = Property_Name ":" (Property_Value | Value_String)
  Property_Name
    = listOf<letters, spaces>
  Property_Value
    = Value_Expression
    | Value_Function
    | Value_String
  
  Value_Function
    = Action? (line_break Action)*
  Value_Expression
    = preposition_keyword Exp -- command_component
    | Exp -- single_value
  Value_String
    = ((~line_break) any)+
  Action
    = command Action_Parameters
  Action_Parameters
  = Parameters
    | "(" Parameters_In_Paren ")" -- in_paren
    | assignment
  // Parameters_In_Paren
  //   = ListOf<Exp, ","> -- comma_separated
  //   | ListOf<Exp, ";"> -- semicolon_separated
  Parameters
    = ListOf<Value_Expression, space>
  command
    = "do " ident -- do
    | command_keyword
    | ident
  command_keyword
    = ("yield" | "gain" | "earn" | "win" | "grant") -- yield
    | "lose" -- lose
    | ("increase" | "lower" | "multiply") -- assignment
    | "show"
    | "hide"
    | "light"
    | "dim"
    | "anim"
    | "log"
    | "clear"
    | "toast"
  preposition_keyword
    = "of"
    | "by"
    | "with"
}

[simon-glitch]

Ah, i think i found the issue.

The parser gets too greedy. For example, "a"* "a" can never match any input, because the parser will eat up all of the as with "a"* and have nothing left for the second "a". So, i have to use negative look aheads, like ("a" ~end)* "a" to force the parser to back track on itself. Im gonna have a fun day tomorrow.

[pdubroy]

Yes, Ohm works in a way that's fundamentally different than some other tools you might have used in the past. It's based a formalism called parsing expression grammars.

The main differences are exactly as you describe:

• prioritized choice means that if the first alternative succeeds, it will not try the others.
• The repetition operators (+, *) are greedy.

The latter is mentioned on the Patterns & Pitfalls page, but I see now that the tutorial doesn't mention these things! It's probably worth adding.

[simon-glitch]

Yup. I had to add in a lot of lookaheads, and I had to reconsider the way many things were structured. But I finally got it working!