1 files changed, 49 insertions, 49 deletions

diff --git a/crimtag/src/parser.rs b/deepcrow/src/parser.rs
index 4f7ff6a..fbfc44e 100644
--- a/crimtag/src/parser.rs
+++ b/deepcrow/src/parser.rs
@@ -36,9 +36,9 @@ impl<'a> Context<'a> {
     }
 
     /*
-    pub fn check_unwrapped<T: Fn( &SymbolType, &SymbolType ) -> bool>(&self, context: &str, f: T) -> CrimResult<bool> {
+    pub fn check_unwrapped<T: Fn( &SymbolType, &SymbolType ) -> bool>(&self, context: &str, f: T) -> Result<bool> {
         if self.cur().is_none() || self.peek().is_none() {
-            Err(CrimError::eos( context ))
+            Err(DeepCrowError::eos( context ))
         } else  {
             Ok(f( self.cur().unwrap().symbol(), self.peek().unwrap().symbol()))
         }
@@ -51,21 +51,21 @@ impl<'a> Context<'a> {
 }
 
 trait SymbolHelper {
-    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> CrimResult<bool>;
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> Result<bool>;
     #[allow(dead_code)]
-    fn is_valid_tag_name(&self) -> CrimResult<bool>;
+    fn is_valid_tag_name(&self) -> Result<bool>;
 }
 
 impl<'a> SymbolHelper for Option<Symbol<'a>> {
-    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> CrimResult<bool> {
+    fn is<T: Fn( &SymbolType ) -> bool>(&self, context: &str, f: T ) -> Result<bool> {
         if let Some(st) = self {
             Ok(f( &st.symbol() ))
         } else {
-            Err(CrimError::eos( context ))
+            Err(DeepCrowError::eos( context ))
         }
     }
     
-    fn is_valid_tag_name(&self) -> CrimResult<bool> {
+    fn is_valid_tag_name(&self) -> Result<bool> {
         if let Some(st) = self {
             Ok(match st.symbol() {
                 SymbolType::Token(_) |
@@ -79,7 +79,7 @@ impl<'a> SymbolHelper for Option<Symbol<'a>> {
                 _ => false
             })
         } else {
-            Err(CrimError::parse(
+            Err(DeepCrowError::parse(
                 Position::none(),
                 "Unexpeceted end of stream.".to_string()
                 ))
@@ -183,17 +183,17 @@ impl Parser {
         }
     }
 
-    fn lex_error<T>(&self, error: &Symbol) -> CrimResult<T> {
+    fn lex_error<T>(&self, error: &Symbol) -> Result<T> {
         if let SymbolType::Error{what} = error.symbol() {
-            Err(CrimError::parse( *error.start(),
+            Err(DeepCrowError::parse( *error.start(),
                 format!("What: {:?}", *what)
             ))
         } else {
-            Err(CrimError::parse( Position::none(), "Not an error?".into()))
+            Err(DeepCrowError::parse( Position::none(), "Not an error?".into()))
         }
     }
 
-    pub fn parse(&self, src: &str, source: usize ) -> CrimResult<Vec<View>> {
+    pub fn parse(&self, src: &str, source: usize ) -> Result<Vec<View>> {
         let ll = Lexer::new( src );
         let mut ctx = Context::new( ll, source );
 
@@ -201,7 +201,7 @@ impl Parser {
         self.p_input( &mut ctx )
     }
 
-    fn p_input(&self, ctx: &mut Context ) -> CrimResult<Vec<View>> {
+    fn p_input(&self, ctx: &mut Context ) -> Result<Vec<View>> {
         let mut tags = Vec::new();
         loop {
             if ctx.cur().is_none() {
@@ -218,7 +218,7 @@ impl Parser {
                     self.lex_error( &ctx.cur().unwrap() )?;
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         format!("Unexpected symbol {:?} found looking for tags.", ctx.cur().unwrap().symbol() )
                     ));
@@ -235,7 +235,7 @@ impl Parser {
                 let BuildResult::View(view) = tag.build( ctx )? {
                     views.push( view );
             } else {
-                return Err(CrimError::parse(
+                return Err(DeepCrowError::parse(
                     start_pos,
                     format!("Expected view at root, found {:?}", name )
                     ));
@@ -244,7 +244,7 @@ impl Parser {
         Ok(views)
     }
 
-    fn parse_tag<'a>(&self, ctx: &mut Context<'a>) -> CrimResult<TagBuilder<'a>> {
+    fn parse_tag<'a>(&self, ctx: &mut Context<'a>) -> Result<TagBuilder<'a>> {
         let start_sym = ctx.cur().unwrap();
         let mut tb = TagBuilder::new(&start_sym);
 
@@ -258,14 +258,14 @@ impl Parser {
                     tb.set_name( name_sym );
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         "Unexpected symbol".to_string()
                     ));
                 }
             }
         } else {
-            return Err(CrimError::eos("tag type"));
+            return Err(DeepCrowError::eos("tag type"));
         }
 
         if tb.can_have_params() || tb.can_have_expr() {
@@ -281,7 +281,7 @@ impl Parser {
                     tb.set_end( &end_sym )?;
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *end_sym.start(),
                         format!("Unexpected symbol {:?} looking for end of tag.", end_sym.symbol())
                         ));
@@ -294,14 +294,14 @@ impl Parser {
         Ok(tb)
     }
 
-    fn parse_tag_set<'a>(&self, ctx: &mut Context<'a>, mut base: TagBuilder<'a>) -> CrimResult<TagBuilder<'a>> {
+    fn parse_tag_set<'a>(&self, ctx: &mut Context<'a>, mut base: TagBuilder<'a>) -> Result<TagBuilder<'a>> {
         if base.is_unary() {
             return Ok(base);
         }
 
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos(format!("close tag for {:?}", base.name()).as_str()));
+                return Err(DeepCrowError::eos(format!("close tag for {:?}", base.name()).as_str()));
             }
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Text(s) => {
@@ -326,7 +326,7 @@ impl Parser {
                                tb.is_name(base.name().unwrap().symbol()) {
                                    return Ok(base);
                             } else {
-                                return Err(CrimError::parse(
+                                return Err(DeepCrowError::parse(
                                     *tb.name().unwrap().start(),
                                     format!("Found {:?} looking for close of {:?}", tb.name().unwrap().symbol(), base.name().unwrap().symbol())
                                 ));
@@ -336,7 +336,7 @@ impl Parser {
                             base.add_child(Entry::TagBuilder(tb));
                         }
                         TagType::Unknown => {
-                            return Err(CrimError::broken(base.start_pos(), "Found unknown tag when looking for something else."));
+                            return Err(DeepCrowError::broken(base.start_pos(), "Found unknown tag when looking for something else."));
                         }
                     }
                 }
@@ -344,7 +344,7 @@ impl Parser {
                     return self.lex_error( &ctx.cur().unwrap() );
                 }
                 _ => {
-                    return Err(CrimError::parse(
+                    return Err(DeepCrowError::parse(
                         *ctx.cur().unwrap().start(),
                         format!("Unexpected token: {:?}", ctx.cur().unwrap().symbol()),
                     ));
@@ -353,10 +353,10 @@ impl Parser {
         }
     }
 
-    fn parse_tag_params(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> CrimResult<()> {
+    fn parse_tag_params(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<()> {
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos("tag parameters"));
+                return Err(DeepCrowError::eos("tag parameters"));
             }
             match ctx.cur().unwrap().symbol() {
                 SymbolType::Literal(s) => {
@@ -377,7 +377,7 @@ impl Parser {
         Ok(())
     }
 
-    fn parse_identifier(&self, ctx: &mut Context ) -> CrimResult<ParamValue> {
+    fn parse_identifier(&self, ctx: &mut Context ) -> Result<ParamValue> {
         let mut id = Identifier::new();
 
         if ctx.cur().is("identifier",|s| matches!( s, SymbolType::Sharp))? {
@@ -390,7 +390,7 @@ impl Parser {
                     id.push( IdentifierValue::Name(s.to_string()) );
                 }
             } else {
-                return Err(CrimError::parse( ctx.cur().unwrap().start().clone(), format!("Expeceted identifier, found {:?}", ctx.cur().unwrap().symbol() ) ) );
+                return Err(DeepCrowError::parse( ctx.cur().unwrap().start().clone(), format!("Expeceted identifier, found {:?}", ctx.cur().unwrap().symbol() ) ) );
             }
 
             if !ctx.next().is("identifier seperator",|s| *s == SymbolType::Period )? {
@@ -402,10 +402,10 @@ impl Parser {
         Ok(ParamValue::Identifier(id))
     }
     
-    fn parse_tag_props(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> CrimResult<()> {
+    fn parse_tag_props(&self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<()> {
         loop {
             if ctx.cur().is_none() {
-                return Err(CrimError::eos("tag properties"));
+                return Err(DeepCrowError::eos("tag properties"));
             }
             if let SymbolType::Token(s) = ctx.cur().unwrap().symbol() {
                 if ctx.peek().is_some_and(|s|s.check_type(|t| matches!(t,SymbolType::Equals))) {
@@ -414,7 +414,7 @@ impl Parser {
                         let SymbolType::Literal(lv) = sym.symbol() {
                         tb.add_prop( s.to_string(), lv.to_string() );
                     } else {
-                        return Err(CrimError::parse(Position::none(),"Expected quoted literal string".to_string()));
+                        return Err(DeepCrowError::parse(Position::none(),"Expected quoted literal string".to_string()));
                     }
                 } else {
                     break;
@@ -447,8 +447,8 @@ type EntryList<'a> = Vec<Entry<'a>>;
 
 trait EntryListConverter {
     fn has_outputs(&self) -> bool;
-    fn to_outputs(&mut self, ctx: &mut Context ) -> CrimResult<Vec<Output>>;
-    fn to_tokens(&mut self, ctx: &mut Context) -> CrimResult<Vec<Token>>;
+    fn to_outputs(&mut self, ctx: &mut Context ) -> Result<Vec<Output>>;
+    fn to_tokens(&mut self, ctx: &mut Context) -> Result<Vec<Token>>;
 }
 
 impl<'a> EntryListConverter for EntryList<'a> {
@@ -463,7 +463,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
             )
     }
 
-    fn to_outputs(&mut self, ctx: &mut Context) -> CrimResult<Vec<Output>> {
+    fn to_outputs(&mut self, ctx: &mut Context) -> Result<Vec<Output>> {
         let mut outputs = Vec::new();
             
         if self.has_outputs() {
@@ -489,7 +489,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
         Ok(outputs)
     }
 
-    fn to_tokens(&mut self, ctx: &mut Context) -> CrimResult<Vec<Token>> {
+    fn to_tokens(&mut self, ctx: &mut Context) -> Result<Vec<Token>> {
         let mut tokens : Vec<Token> = Vec::new();
         for e in self.drain(..) {
             match e {
@@ -500,7 +500,7 @@ impl<'a> EntryListConverter for EntryList<'a> {
                     if let BuildResult::Token(token) = tb.build(ctx)? {
                         tokens.push( token );
                     } else {
-                        return Err(CrimError::broken( Position::none(), "Non-token result built."));
+                        return Err(DeepCrowError::broken( Position::none(), "Non-token result built."));
                     }
                 }
             }
@@ -545,14 +545,14 @@ impl<'a> TagBuilder<'a> {
         }
     }
 
-    pub fn set_end(&mut self, end: &Symbol) -> CrimResult<()> {
+    pub fn set_end(&mut self, end: &Symbol) -> Result<()> {
         if *self.start.symbol() == SymbolType::StartFlat {
             if *end.symbol() == SymbolType::EndFlat {
                 self.tag_type = TagType::Unary;
             } else if *end.symbol() == SymbolType::EndPoint {
                 self.tag_type = TagType::MultinaryOpen;
             } else {
-                return Err(CrimError::broken( *end.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *end.start(), "Invalid bracket token type."));
             }
         } else if *self.start.symbol() == SymbolType::StartPoint {
             if *end.symbol() == SymbolType::EndFlat {
@@ -560,10 +560,10 @@ impl<'a> TagBuilder<'a> {
             } else if *end.symbol() == SymbolType::EndPoint {
                 self.tag_type = TagType::MultinaryMid;
             } else {
-                return Err(CrimError::broken( *end.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *end.start(), "Invalid bracket token type."));
             }
         } else {
-                return Err(CrimError::broken( *self.start.start(), "Invalid bracket token type."));
+                return Err(DeepCrowError::broken( *self.start.start(), "Invalid bracket token type."));
         }
         Ok(())
     }
@@ -659,14 +659,14 @@ impl<'a> TagBuilder<'a> {
         self.tag_type
     }
 
-    pub fn build(mut self, ctx: &mut Context ) -> CrimResult<BuildResult> {
+    pub fn build(mut self, ctx: &mut Context ) -> Result<BuildResult> {
         if let Some(sym) = self.name {
             match sym.symbol() {
                 SymbolType::View => {
                     let name = if let ParamValue::Literal(s) = self.params.swap_remove(0) {
                         s.to_string()
                     } else {
-                        return Err(CrimError::parse(Position::none(), "Expected string literal for view name.".to_string()));
+                        return Err(DeepCrowError::parse(Position::none(), "Expected string literal for view name.".to_string()));
                     };
                     Ok(BuildResult::View(View {
                         name: name,
@@ -680,7 +680,7 @@ impl<'a> TagBuilder<'a> {
                     let name = if let ParamValue::Literal(s) = self.params.swap_remove(0) {
                         s.to_string()
                     } else {
-                        return Err(CrimError::parse(Position::none(), "Expected string literal for output name.".into()));
+                        return Err(DeepCrowError::parse(Position::none(), "Expected string literal for output name.".into()));
                     };
                     Ok(BuildResult::Output(Output {
                         name: name,
@@ -692,7 +692,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for loop variable name.".into())
                             );
@@ -706,7 +706,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for show variable name.".into())
                             );
@@ -718,7 +718,7 @@ impl<'a> TagBuilder<'a> {
                         = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for if variable name.".into())
                             );
@@ -744,7 +744,7 @@ impl<'a> TagBuilder<'a> {
                     let id = if let ParamValue::Identifier(id) = self.params.swap_remove(0) {
                         id
                     } else {
-                        return Err(CrimError::parse(
+                        return Err(DeepCrowError::parse(
                             Position::none(),
                             "Identifier for elif variable name.".into())
                             );
@@ -775,11 +775,11 @@ impl<'a> TagBuilder<'a> {
                     Ok(BuildResult::Token(Token::If(Identifier::new(), self.children.to_tokens(ctx)?, self.chain.to_tokens(ctx)?)))
                 }
                 _ => {
-                    Err(CrimError::parse( self.start_pos(), "Bad tag type".into()))
+                    Err(DeepCrowError::parse( self.start_pos(), "Bad tag type".into()))
                 }
             }
         } else {
-            Err(CrimError::parse(self.start_pos(), "Bad tag type".into()))
+            Err(DeepCrowError::parse(self.start_pos(), "Bad tag type".into()))
         }
     }
 }