nomsu/nomsu.peg

file:
    shebang?
    (ignored_line %nl)*
    (block / action / expression)?
    (%nl ignored_line)*
    (!. / (({} (.* -> "Parse error")) => error))

shebang: "#!" [^%nl]* (!. / %nl)

statement: (action / expression) (eol / (({} ([^%nl]* -> "Error while parsing line")) => error))
inline_statement: inline_action / inline_expression

inline_block (Block):
    {| inline_statement (%ws* ";" %ws*  inline_statement)+ |} -> Tuple
block (Block):
    {| statement (nodent (statement / (({} ([^%nl]* -> "Error while parsing block line")) => error)))+ |} -> Tuple

inline_nomsu (Nomsu): "\" noindex_inline_expression
indented_nomsu (Nomsu):
    "\" (noindex_inline_expression / (":" %ws* (inline_block / inline_action / inline_expression) eol) / indented_expression)

index_chain (IndexChain):
    {|
        noindex_inline_expression ("." (text_word / noindex_inline_expression))+
    |} -> Tuple

noindex_inline_expression:
    number / variable / inline_text / inline_list / inline_dict / inline_nomsu
    / ( "("
            %ws* (inline_block / inline_action / inline_expression) %ws*
        (")"
            / (({} ((!. / &%nl) -> 'Expected to find a ) before the end of the line')) => error)
            / (({} ([^%nl]* -> 'Error while parsing subexpression')) => error)
        )
      )

inline_expression:
    index_chain / noindex_inline_expression 
indented_expression:
    indented_text / indented_nomsu / indented_list / indented_dict
    / ("(..)"? indent
        (block / action / expression)
        (dedent / (({} (non_dedent_error -> "Error while parsing indented expression")) => error))
      )
expression:
    inline_expression / (":" %ws* (inline_block / inline_action / inline_expression) eol) / indented_expression

-- Function calls need at least one word in them
inline_action (Action):
    {| (inline_expression %ws*)* word (%ws* (inline_expression / word))*
        (%ws* ":" %ws* (inline_block / inline_action / inline_expression))?|} -> Tuple
action (Action):
    {| (expression (dotdot? %ws*))* word ((dotdot? %ws*) (expression / word))* |} -> Tuple

word (Word): { %operator / (!number plain_word) }

text_word (Text): {| {%operator / (!number plain_word)} |} -> Tuple

inline_text (Text):
    !('".."' eol)
    '"' ({|
        ({~ (('\"' -> '"') / ('\\' -> '\') / %escaped_char / [^%nl\"])+ ~}
        / inline_text_interpolation)*
    |} -> Tuple) ('"' / (({} ([^%nl]*->'Failed to find a closing " mark on the same line')) => error))

-- Have to use "%indent" instead of "indent" etc. to avoid messing up text lines that start with "#"
indented_text (Text):
    '".."' eol %nl ({|
        {~ (%nl*) (%indent -> "") ~}
        ({~
            (("\\" -> "\") / (("\" nodent "..") -> "")/ (%nl+ {~ %nodent -> "" ~}) / [^%nl\] / (!text_interpolation "\"))+
        ~} / text_interpolation)*
    |} -> Tuple) (((!.) &%dedent) / (&(%nl %dedent)) / (({} (non_dedent_error -> "Error while parsing Text")) => error))
inline_text_interpolation:
    "\" (
        variable / inline_list / inline_dict / inline_text
        / ("("
            %ws* (inline_block / inline_action / inline_expression) %ws*
        (")"
            / (({} (&%nl -> 'Expected to find a ")" before the end of the line')) => error)
            / (({} ([^%nl]* -> 'Error while parsing text interpolation')) => error))
        )
    )
text_interpolation:
    inline_text_interpolation /
    ("\" indented_expression nodent "..")

number (Number): (("-"? (([0-9]+ "." [0-9]+) / ("." [0-9]+) / ([0-9]+)))-> tonumber)

-- Variables can be nameless (i.e. just %) and can't contain operators like apostrophe
-- which is a hack to allow %'s to parse as "%" and "' s" separately
variable (Var): "%" { plain_word? }

inline_list (List):
    !('[..]')
    "[" %ws* ({| (inline_list_item (comma inline_list_item)* comma?)? |} -> Tuple) %ws*
    ("]" / (({} ([^%nl]*->"Failed to find a closing ] on the same line")) => error))
indented_list (List):
    "[..]" indent ({|
        list_line (nodent list_line)*
    |} -> Tuple)
    (dedent / (({} (non_dedent_error -> "Error while parsing list")) => error))
list_line:
     ((action / expression) !comma)
     / (inline_list_item (comma list_line?)?)
inline_list_item: inline_block / inline_action / inline_expression

inline_dict (Dict):
    !('{..}')
    "{" %ws* ({| (inline_dict_item (comma inline_dict_item)*)? |} -> Tuple) %ws*
    ("}"
      / (({} (%ws* comma? (!. / &%nl)->"Failed to find a closing } on the same line")) => error)
      / (({} ([^%nl]*->"Error while parsing dictionary")) => error))
indented_dict (Dict):
    "{..}" indent ({|
        dict_line (nodent dict_line)*
    |} -> Tuple)
    (dedent / (({} (non_dedent_error -> "Error while parsing dict")) => error))
dict_line:
    ((dict_key %ws* ":" %ws* (action / expression)) -> DictEntry !comma)
    / (inline_dict_item (comma dict_line?)?)
inline_dict_item:
    ((dict_key %ws* (":" %ws* (inline_block / inline_action / inline_expression)?)?)-> DictEntry)
dict_key:
    text_word / inline_expression

block_comment: "#.." [^%nl]* (%nl+ %indent [^%nl]* (%nl+ %nodent [^%nl]*)* %dedent)?
line_comment: "#" [^%nl]*

eol: %ws* line_comment? (!. / &%nl)
ignored_line: (%nodent (block_comment / line_comment)) / (%ws* (!. / &%nl))
indent: eol (%nl ignored_line)* %nl %indent ((block_comment/line_comment) (%nl ignored_line)* nodent)?
nodent: eol (%nl ignored_line)* %nl %nodent
dedent: eol (%nl ignored_line)* (((!.) &%dedent) / (&(%nl %dedent)))
non_dedent_error: (!dedent .)* eol (%nl ignored_line)* (!. / &%nl)
comma: %ws* "," %ws*
dotdot: nodent ".."
plain_word: ([a-zA-Z0-9_] / %utf8_char)+