From 8fd7d34e79aed1367a14113692a444c70ac61623 Mon Sep 17 00:00:00 2001 From: Hawk Weisman Date: Wed, 21 Jan 2015 13:38:30 -0500 Subject: [PATCH] Add syntax highlighting to README --- README.md | 78 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 40 insertions(+), 38 deletions(-) diff --git a/README.md b/README.md index 0c04dfd..5a7e42c 100644 --- a/README.md +++ b/README.md @@ -15,51 +15,53 @@ it's not actually useable without copying large chunks of the code into your cra ## Example Here is an example of a simple parser which can be used to evaluate mathematical expressions. +```rust - use rparse::*; // but see https://github.com/mozilla/rust/issues/3781 +use rparse::*; // but see https://github.com/mozilla/rust/issues/3781 - fn expr_parser() -> Parser - { - let int_literal = decimal_number().err("number").s0(); - - // Parenthesized expressions require a forward reference to the expr parser - // so we initialize a function pointer to something of the right type, create - // a parser using the parser expr_ptr points to, and fixup expr_ptr later. - let expr_ptr = @mut ret(0i); - let expr_ref = forward_ref(expr_ptr); +fn expr_parser() -> Parser +{ + let int_literal = decimal_number().err("number").s0(); - // sub_expr := [-+]? '(' expr ')' - // The err function provides better error messages if the factor parser fails - // on the very first character. - let sub_expr = or_v(@~[ - seq4_ret2("+".s0(), "(".s0(), expr_ref, ")".s0()), - seq4_ret2("-".s0(), "(".s0(), expr_ref, ")".s0()).thene(|v| ret(-v) ), - seq3_ret1( "(".s0(), expr_ref, ")".s0())]).err("sub-expression"); + // Parenthesized expressions require a forward reference to the expr parser + // so we initialize a function pointer to something of the right type, create + // a parser using the parser expr_ptr points to, and fixup expr_ptr later. + let expr_ptr = @mut ret(0i); + let expr_ref = forward_ref(expr_ptr); - // factor := integer | sub_expr - let factor = int_literal.or(sub_expr); + // sub_expr := [-+]? '(' expr ')' + // The err function provides better error messages if the factor parser fails + // on the very first character. + let sub_expr = or_v(@~[ + seq4_ret2("+".s0(), "(".s0(), expr_ref, ")".s0()), + seq4_ret2("-".s0(), "(".s0(), expr_ref, ")".s0()).thene(|v| ret(-v) ), + seq3_ret1( "(".s0(), expr_ref, ")".s0())]).err("sub-expression"); - // term := factor ([*/] factor)* - let term = do factor.chainl1("*".s0().or("/".s0())) - |lhs, op, rhs| {if op == @~"*" {lhs*rhs} else {lhs/rhs}}; + // factor := integer | sub_expr + let factor = int_literal.or(sub_expr); - // expr := term ([+-] term)* - let expr = term.chainl1("+".s0().or("-".s0()), - |lhs, op, rhs| {if op == @~"+" {lhs + rhs} else {lhs - rhs}}).err("expression"); - *expr_ptr = expr; + // term := factor ([*/] factor)* + let term = do factor.chainl1("*".s0().or("/".s0())) + |lhs, op, rhs| {if op == @~"*" {lhs*rhs} else {lhs/rhs}}; - // start := s0 expr EOT - let s = ret(0).s0(); - expr.everything(s) - } - + // expr := term ([+-] term)* + let expr = term.chainl1("+".s0().or("-".s0()), + |lhs, op, rhs| {if op == @~"+" {lhs + rhs} else {lhs - rhs}}).err("expression"); + *expr_ptr = expr; + + // start := s0 expr EOT + let s = ret(0).s0(); + expr.everything(s) +} +``` Usage looks like this: - - fn test_usage() +```rust +fn test_usage() +{ + match expr_parser().parse(@~"test", ~"2+3*5") { - match expr_parser().parse(@~"test", ~"2+3*5") - { - result::Ok(value) => assert value == 17, - result::Err(_) => assert false, - } + result::Ok(value) => assert value == 17, + result::Err(_) => assert false, } +} +```