Crate zypo_parser

About

zypo-parser is the primary parser implementation for the zypo-rs reference compiler. This package uses the LALRPOP library, a yacc-like LR(1) parser combiner for Rust. This crate also contains the AST (abstract-syntax-tree) for Zypo and all public AST structures, enums and associated functions are avalible at the base-level of this crate.

Please beware as this package is heavily work-in-progress and is developed alongside the main Zypo compiler as a sub-package. If you are looking for the base zypo-rs compiler, you may find it here.

Examples

Shortcut for parsing an AST or panicing if there is an error in any of the given input:

use zypo_parser::{
    Function,
    VarType,
    Parameter,
    ast_result
}; // All but ast_result are from the AST. ast_result is the shortcut func

fn main() {
    let input = "fun shortcut_test_func(my_param: int) {}";
    let expected = vec![
        Function {
            ident: "shortcut_test_func".to_string(),
            params: vec![
                Parameter { ident: "my_param".to_string(), ty: VarType::Int }
            ],
            body: vec![],
            return_type: VarType::Void
        }
    ];

    assert_eq!(ast_result(input), expected);
}

More controllable but lower-level LALRPOP bind for manually handling the generated parsing errors:

use zypo_parser::{
    Function,
    VarType,
    parser
}; // Function and VarType are from the AST, parser is generated by LALRPOP

fn main() {
    let input = "fun test_func() {}";
    let expected = vec![
        Function {
            ident: "test_func".to_string(),
            params: vec![],
            body: vec![],
            return_type: VarType::Void
        }
    ];

    assert_eq!(parser::GrammarParser::new().parse(input).unwrap(), expected);
}

Modules

• parser

Structs

• Function
  A function statement, the basis for the whole language. An example of a function statement would be the following inside of Zypo itself:
• Parameter
  A eration of a parameter. This would originally look like my_id: str when being parsed.
• Variable
  Variable that includes a parameter but extends with a recursive ExpressionNode.
• WhileLoop
  A while loop. This goes down into WhileLoop and would look something like this in Zypo:

Enums

• BinOp
  A binary operation type. Having a seperate enum for this avoids repitition and allows for some optimisations downstream.
• Constant
  Similar to the VarType enum but with defined data in each possible option.
• ExpressionNode
  The main expression enum, allowing for grouping of all expressions inside of the AST.
• StatementNode
  The main statement enum, allowing for grouping of statements inside of the AST.
• VarType
  Variable types for zypo-rs.

Functions

• ast_result
  Gets the abstract syntax tree generated from the parser of zypo-rs. This function will panic is parsing fails and is intended for developers aiming to implament the parser into code generation.