Merge pull request #12 from birkenfeld/either

Convert Eithers into Results.

Author: birkenfeld

src/analysis/decl_analysis.rs

@@ -59,12 +59,12 @@ pub fn tParamDecl(_0: CDecl) -> m<ParamDecl> {
     }
 }
 
-pub fn computeParamStorage(_0: NodeInfo, _1: StorageSpec) -> Either<BadSpecifierError, Storage> {
+pub fn computeParamStorage(_0: NodeInfo, _1: StorageSpec) -> Result<Storage, BadSpecifierError> {
     match (_0, _1) {
-        (_, NoStorageSpec) => Right((Auto(false))),
-        (_, RegSpec) => Right((Auto(true))),
+        (_, NoStorageSpec) => Ok((Auto(false))),
+        (_, RegSpec) => Ok((Auto(true))),
         (node, spec) => {
-            Left(badSpecifierError(node,
+            Err(badSpecifierError(node,
                                    __op_addadd("Bad storage specified for parameter: "
                                                    .to_string(),
                                                show(spec))))

src/analysis/trav_monad.rs

@@ -233,8 +233,8 @@ pub fn isDeclaration(_0: IdentDecl) -> bool {
     }
 }
 
-pub fn checkCompatibleTypes(_: Type, _: Type) -> Either<TypeMismatch, ()> {
-    Right(())
+pub fn checkCompatibleTypes(_: Type, _: Type) -> Result<(), TypeMismatch> {
+    Ok(())
 }
 
 pub fn handleObjectDef(local: bool, ident: Ident, obj_def: ObjDef) -> m<()> {
@@ -359,10 +359,10 @@ pub fn astError<a>(node: NodeInfo, msg: String) -> m<a> {
     throwTravError(invalidAST(node, msg))
 }
 
-pub fn throwOnLeft<a>(_0: Either<e, a>) -> m<a> {
+pub fn throwOnLeft<a>(_0: Result<a, e>) -> m<a> {
     match (_0) {
-        Left(err) => throwTravError(err),
-        Right(v) => v,
+        Err(err) => throwTravError(err),
+        Ok(v) => v,
     }
 }
 
@@ -371,9 +371,9 @@ pub fn warn(err: e) -> m<()> {
 }
 
 pub struct Trav<s, a> {
-    unTrav: fn(TravState<s>) -> Either<CError, (a, TravState<s>)>,
+    unTrav: fn(TravState<s>) -> Result<(a, TravState<s>), CError>,
 }
-fn unTrav(a: Trav) -> fn(TravState<s>) -> Either<CError, (a, TravState<s>)> {
+fn unTrav(a: Trav) -> fn(TravState<s>) -> Result<(a, TravState<s>), CError> {
     a.unTrav
 }
 
@@ -393,21 +393,21 @@ pub fn put(s: TravState<s>) -> Trav<s, ()> {
     Trav((|_| Right(((), s))))
 }
 
-pub fn runTrav<a>(state: s, traversal: Trav<s, a>) -> Either<Vec<CError>, (a, TravState<s>)> {
+pub fn runTrav<a>(state: s, traversal: Trav<s, a>) -> Result<(a, TravState<s>), Vec<CError>> {
 
     let action = /*do*/ {
             withDefTable((__TODO_const(((), builtins))));
             traversal
         };
 
     match unTrav(action, (initTravState(state))) {
-        Left(trav_err) => Left(vec![trav_err]),
-        Right((v, ts)) if hadHardErrors((travErrors(ts))) => Left((travErrors(ts))),
-        Right((v, ts)) => Right((v, ts)),
+        Err(trav_err) => Err(vec![trav_err]),
+        Ok((v, ts)) if hadHardErrors((travErrors(ts))) => Err((travErrors(ts))),
+        Ok((v, ts)) => Ok((v, ts)),
     }
 }
 
-pub fn runTrav_<a>(t: Trav<(), a>) -> Either<Vec<CError>, (a, Vec<CError>)> {
+pub fn runTrav_<a>(t: Trav<(), a>) -> Result<(a, Vec<CError>), Vec<CError>> {
     fmap(fst,
          runTrav((),
                  /*do*/

src/analysis/type_check.rs

@@ -32,11 +32,13 @@ use analysis::type_utils::*;
 use analysis::trav_monad::*;
 use data::ident::*;
 
+pub type TcResult<T> = Result<T, String>;
+
 pub fn pType() -> String {
     render(pretty)
 }
 
-pub fn typeErrorOnLeft<a>(_0: NodeInfo, _1: Either<String, a>) -> m<a> {
+pub fn typeErrorOnLeft<a>(_0: NodeInfo, _1: TcResult<a>) -> m<a> {
     match (_0, _1) {
         (ni, Left(err)) => typeError(ni, err),
         (_, Right(v)) => v,
@@ -47,7 +49,7 @@ pub fn typeError<a>() -> m<a> {
     astError
 }
 
-pub fn notFound<a>(i: Ident) -> Either<String, a> {
+pub fn notFound<a>(i: Ident) -> TcResult<a> {
     Left(__op_addadd("not found: ".to_string(), identToString(i)))
 }
 
@@ -71,7 +73,7 @@ pub fn conditionalType_q(ni: NodeInfo, t1: Type, t2: Type) -> m<Type> {
     typeErrorOnLeft(ni, conditionalType(t1, t2))
 }
 
-pub fn checkScalar(t: Type) -> Either<String, ()> {
+pub fn checkScalar(t: Type) -> TcResult<()> {
     match canonicalType(t) {
         DirectType(_, _, _) => (),
         PtrType(_, _, _) => (),
@@ -120,11 +122,11 @@ pub fn constType(_0: CConst) -> m<Type> {
     }
 }
 
-pub fn compatible(t1: Type, t2: Type) -> Either<String, ()> {
+pub fn compatible(t1: Type, t2: Type) -> TcResult<()> {
     void(compositeType(t1, t2))
 }
 
-pub fn compositeType(_0: Type, _1: Type) -> Either<String, Type> {
+pub fn compositeType(_0: Type, _1: Type) -> TcResult<Type> {
     match (_0, _1) {
         (t1, DirectType(TyBuiltin(TyAny), _, _)) => t1,
         (DirectType(TyBuiltin(TyAny), _, _), t2) => t2,
@@ -254,7 +256,7 @@ pub fn compositeType(_0: Type, _1: Type) -> Either<String, Type> {
     }
 }
 
-pub fn compositeSize(_0: ArraySize, _1: ArraySize) -> Either<String, ArraySize> {
+pub fn compositeSize(_0: ArraySize, _1: ArraySize) -> TcResult<ArraySize> {
     match (_0, _1) {
         (UnknownArraySize(_), s2) => s2,
         (s1, UnknownArraySize(_)) => s1,
@@ -276,7 +278,7 @@ pub fn mergeAttrs() -> Attributes {
     (__op_addadd)
 }
 
-pub fn compositeParamDecl(_0: ParamDecl, _1: ParamDecl) -> Either<String, ParamDecl> {
+pub fn compositeParamDecl(_0: ParamDecl, _1: ParamDecl) -> TcResult<ParamDecl> {
     match (_0, _1) {
         (ParamDecl(vd1, ni1), ParamDecl(vd2, _)) => compositeParamDecl_q(ParamDecl, vd1, vd2, ni1),
         (AbstractParamDecl(vd1, _), ParamDecl(vd2, ni2)) => {
@@ -295,7 +297,7 @@ pub fn compositeParamDecl_q(f: fn(VarDecl) -> fn(NodeInfo) -> ParamDecl,
                             VarDecl(n1, attrs1, t1): VarDecl,
                             VarDecl(n2, attrs2, t2): VarDecl,
                             dni: NodeInfo)
-                            -> Either<String, ParamDecl> {
+                            -> TcResult<ParamDecl> {
 
     let t1_q = canonicalType(t1);
 
@@ -311,7 +313,7 @@ pub fn compositeParamDecl_q(f: fn(VarDecl) -> fn(NodeInfo) -> ParamDecl,
 
 pub fn compositeVarDecl(VarDecl(n1, attrs1, t1): VarDecl,
                         VarDecl(_, attrs2, t2): VarDecl)
-                        -> Either<String, VarDecl> {
+                        -> TcResult<VarDecl> {
     /*do*/
     {
         let t = compositeType(t1, t2);
@@ -326,14 +328,14 @@ pub fn compositeDeclAttrs(DeclAttrs(inl, stor, attrs1): DeclAttrs,
     DeclAttrs(inl, stor, (mergeAttrs(attrs1, attrs2)))
 }
 
-pub fn castCompatible(t1: Type, t2: Type) -> Either<String, ()> {
+pub fn castCompatible(t1: Type, t2: Type) -> TcResult<()> {
     match (canonicalType(t1), canonicalType(t2)) {
         (DirectType(TyVoid, _, _), _) => (),
         (_, _) => __op_rshift(checkScalar(t1), checkScalar(t2)),
     }
 }
 
-pub fn assignCompatible(_0: CAssignOp, _1: Type, _2: Type) -> Either<String, ()> {
+pub fn assignCompatible(_0: CAssignOp, _1: Type, _2: Type) -> TcResult<()> {
     match (_0, _1, _2) {
         (CAssignOp, t1, t2) => {
             match (canonicalType(t1), canonicalType(t2)) {
@@ -369,7 +371,7 @@ pub fn assignCompatible(_0: CAssignOp, _1: Type, _2: Type) -> Either<String, ()>
     }
 }
 
-pub fn binopType(op: CBinaryOp, t1: Type, t2: Type) -> Either<String, Type> {
+pub fn binopType(op: CBinaryOp, t1: Type, t2: Type) -> TcResult<Type> {
     match (op, canonicalType(t1), canonicalType(t2)) {
         (_, t1_q, t2_q) if isLogicOp(op) => {
             __op_rshift(checkScalar(t1_q), __op_rshift(checkScalar(t2_q), boolType))
@@ -443,7 +445,7 @@ pub fn binopType(op: CBinaryOp, t1: Type, t2: Type) -> Either<String, Type> {
     }
 }
 
-pub fn conditionalType(t1: Type, t2: Type) -> Either<String, Type> {
+pub fn conditionalType(t1: Type, t2: Type) -> TcResult<Type> {
     match (canonicalType(t1), canonicalType(t2)) {
         (PtrType(DirectType(TyVoid, _, _), _, _), t2_q) if isPointerType(t2_q) => t2,
         (t1_q, PtrType(DirectType(TyVoid, _, _), _, _)) if isPointerType(t1_q) => t1,
@@ -468,7 +470,7 @@ pub fn conditionalType(t1: Type, t2: Type) -> Either<String, Type> {
     }
 }
 
-pub fn derefType(_0: Type) -> Either<String, Type> {
+pub fn derefType(_0: Type) -> TcResult<Type> {
     match (_0) {
         PtrType(t, _, _) => t,
         ArrayType(t, _, _, _) => t,
@@ -482,7 +484,7 @@ pub fn derefType(_0: Type) -> Either<String, Type> {
     }
 }
 
-pub fn varAddrType(d: IdentDecl) -> Either<String, Type> {
+pub fn varAddrType(d: IdentDecl) -> TcResult<Type> {
 
     let t = declType(d);
 

src/lib.rs

@@ -2,18 +2,18 @@
 //!
 //! ```rust,no_run
 //! extern crate parser_c;
-//! 
+//!
 //! use parser_c::parse;
-//! 
+//!
 //! const INPUT: &'static str = r#"
-//! 
+//!
 //! int main() {
 //!     printf("hello world!");
 //!     return 0;
 //! }
-//! 
+//!
 //! "#;
-//! 
+//!
 //! fn main() {
 //!     match parse(INPUT, "simple.c") {
 //!         Err(err) => {
@@ -31,13 +31,15 @@
 #![feature(proc_macro)]
 #![feature(slice_patterns, box_syntax, box_patterns, fnbox)]
 #![allow(unused_parens)]
+// Cut down on number of warnings until we manage it.
+#![allow(non_snake_case, non_camel_case_types, unused_imports, unused_variables, dead_code)]
 #![recursion_limit="500"]
 
 extern crate num;
 #[macro_use] extern crate matches;
-#[macro_use] extern crate num_derive;
+extern crate num_derive;
 extern crate parser_c_macro;
-#[macro_use] extern crate lazy_static;
+extern crate lazy_static;
 
 // pub mod analysis;
 #[macro_use] pub mod support;
@@ -66,38 +68,28 @@ fn parseCFile<C: Preprocessor>(cpp: C,
                                    tmp_dir_opt: Option<FilePath>,
                                    args: Vec<String>,
                                    input_file: FilePath)
-                                   -> Either<ParseError, CTranslUnit> {
+                                   -> Result<CTranslUnit, ParseError> {
 
     let handleCppError = |_0| match (_0) {
-        Left(exitCode) => __error!(__op_addadd("Preprocessor failed with ".to_string(), show(exitCode))),
-        Right(ok) => ok,
+        Err(exitCode) => __error!(format!("Preprocessor failed with {}", exitCode)),
+        Ok(ok) => ok,
     };
 
-    /*do*/
-    {
-        let input_stream = if !isPreprocessed(input_file.clone().into()) {
-            {
-                let cpp_args = __assign!((rawCppArgs(args, input_file.clone())), {
-                    cppTmpDir: tmp_dir_opt
-                });
-
-                handleCppError(runPreprocessor(cpp, cpp_args))
-            }
-        } else {
-            readInputStream(input_file.clone())
-        };
-
-        parseC(input_stream, (initPos(input_file)))
-    }
-}
+    let input_stream = if !isPreprocessed(input_file.clone().into()) {
+        let cpp_args = __assign!((rawCppArgs(args, input_file.clone())), {
+            cppTmpDir: tmp_dir_opt
+        });
 
-fn parseCFilePre(file: FilePath) -> Either<ParseError, CTranslUnit> {
-    /*do*/
-    {
-        let input_stream = readInputStream(file.clone());
+        handleCppError(runPreprocessor(cpp, cpp_args))} else {
+        readInputStream(input_file.clone())
+    };
+
+    parseC(input_stream, initPos(input_file))
+}
 
-        parseC(input_stream, (initPos(file)))
-    }
+fn parseCFilePre(file: FilePath) -> Result<CTranslUnit, ParseError> {
+    let input_stream = readInputStream(file.clone());
+    parseC(input_stream, initPos(file))
 }
 
 /// Basic public API. Accepts C source and a filename.
@@ -114,15 +106,6 @@ pub fn parse(input: &str, filename: &str) -> Result<CTranslUnit, ParseError> {
     thread::Builder::new().stack_size(32 * 1024 * 1024).spawn(move || {
         let input_stream = inputStreamFromString(input);
 
-        let todo = parseC(input_stream, (initPos(FilePath::from(filename))));
-
-        match todo {
-            Left(err) => {
-                Err(err)
-            }
-            Right(ast) => {
-                Ok(ast)
-            }
-        }
+        parseC(input_stream, (initPos(FilePath::from(filename))))
     }).unwrap().join().unwrap()
-}
+}

src/parser/lexer.rs

@@ -33254,7 +33254,7 @@ pub fn alex_actions() -> Vec<Box<Fn(Position, isize, InputStream) -> P<CToken>>>
         ])
 }
 
-pub fn readCOctal(s: String) -> Either<String, CInteger> {
+pub fn readCOctal(s: String) -> Result<CInteger, String> {
     if s.chars().nth(0).unwrap() == '0' {
         if s.len() > 1 && isDigit(s.chars().nth(1).unwrap()) {
             readCInteger(OctalRepr, s[1..].to_string())
@@ -33616,16 +33616,19 @@ pub fn token_fail(errmsg: String, pos: Position, _: isize, _: InputStream) -> P<
     failP(pos, vec!["Lexical Error !".to_string(), errmsg])
 }
 
-pub fn token<a>(mkTok: Box<Fn(PosLength, a) -> CToken>, fromStr: Box<Fn(String) -> a>, pos: Position, len: isize, __str: InputStream) -> P<CToken> {
+pub fn token<a>(mkTok: Box<Fn(PosLength, a) -> CToken>,
+                fromStr: Box<Fn(String) -> a>, pos: Position, len: isize, __str: InputStream) -> P<CToken> {
     __return((mkTok((pos, len), (fromStr(takeChars_str(len, __str))))))
 }
 
-pub fn token_plus<a>(mkTok: Box<Fn(PosLength, a) -> CToken>, fromStr: Box<Fn(String) -> Either<String, a>>, pos: Position, len: isize, __str: InputStream) -> P<CToken> {
+pub fn token_plus<a>(mkTok: Box<Fn(PosLength, a) -> CToken>,
+                     fromStr: Box<Fn(String) -> Result<a, String>>,
+                     pos: Position, len: isize, __str: InputStream) -> P<CToken> {
     match fromStr((takeChars_str(len, __str))) {
-        Left(err) => {
+        Err(err) => {
             failP(pos, vec!["Lexical error ! ".to_string(), err])
         },
-        Right(ok) => {
+        Ok(ok) => {
             __return(mkTok((pos, len), ok))
         },
     }

src/parser/mod.rs

@@ -28,9 +28,6 @@ use parser::parser_monad::ParseError;
 use data::position::Position;
 use data::input_stream::InputStream;
 
-pub fn execParser_<a: 'static>(parser: P<a>, input: InputStream, pos: Position) -> Either<ParseError, a> {
-    match execParser(parser, input, pos, builtinTypeNames(), newNameSupply()) {
-        Left(s) => Left(s),
-        Right((v, _)) => Right(v)
-    }
+pub fn execParser_<a: 'static>(parser: P<a>, input: InputStream, pos: Position) -> Result<a, ParseError> {
+    execParser(parser, input, pos, builtinTypeNames(), newNameSupply()).map(|(v, _)| v)
 }

src/parser/parser.rs

@@ -41759,7 +41759,7 @@ pub fn appendDeclrAttrs(_0: Vec<CAttribute<NodeInfo>>, _1: CDeclrR) -> CDeclrR {
                             CFunDeclr(parameters, __op_addadd(cattrs, newAttrs), at),
                     }
                 };
-                
+
                 CDeclrR(ident, (Reversed((__op_concat(appendAttrs(x), xs)))), asmname, cattrs, at)
             }
         },
@@ -41891,7 +41891,7 @@ pub fn happyError<a: 'static>() -> P<a> {
     parseError()
 }
 
-pub fn parseC(input: InputStream, initialPosition: Position) -> Either<ParseError, CTranslationUnit<NodeInfo>> {
+pub fn parseC(input: InputStream, initialPosition: Position) -> Result<CTranslationUnit<NodeInfo>, ParseError> {
     execParser(translUnitP(), input, initialPosition, builtinTypeNames(), (namesStartingFrom(0)))
         .map(|x| x.0)
 }