HTG_YT

parser.rs

Sep 6th, 2020
2,003
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.     pub fn peek(&mut self, n: usize) -> Result<Lexeme> {
  2.         return self.get_lexeme(self.offset + n);
  3.     }
  4.  
  5.     pub fn take(&mut self) -> Result<Lexeme> {
  6.         self.offset += 1;
  7.  
  8.         return self.get_lexeme(self.offset - 1);
  9.     }
  10.  
  11.     pub fn predict(&mut self, wants: Vec<LexemeType>) -> Result<()> {
  12.         for (i, v) in wants.iter().enumerate() {
  13.             let lexeme = self.peek(i)?;
  14.  
  15.             if !self.matched(lexeme.lexeme_type(), v) {
  16.                 return Err(ParserError::new(ParserErrorVariant::UnexpectedLexeme(lexeme, wants, "predict".to_string())));
  17.             }
  18.         }
  19.  
  20.         return Ok(());
  21.     }
  22.  
  23.     pub fn consume(&mut self, wants: Vec<LexemeType>) -> Result<()> {
  24.         let length = wants.len();
  25.  
  26.         self.predict(wants)?;
  27.  
  28.         for _ in 1..=length {
  29.             self.take()?;
  30.         }
  31.  
  32.         return Ok(());
  33.     }
  34.  
  35.     pub fn parse_class(&mut self, tag: Option<Tag>) -> Result<Class> {
  36.         let class_keyword = self.peek(0)?;
  37.         self.consume(vec![LexemeType::Class])?;
  38.  
  39.         let class_name = self.parse_identifier()?;
  40.         let mut parents = vec![];
  41.  
  42.         if self.consume(vec![LexemeType::IsSubTypeOf]).is_ok() {
  43.             while self.peek(0)?.lexeme_type() != &LexemeType::LeftAngleBracket {
  44.                 parents.push(self.parse_identifier()?);
  45.  
  46.                 if self.consume(vec![LexemeType::Comma]).is_err() {
  47.                     break;
  48.                 }
  49.                 else {}
  50.             }
  51.         }
  52.  
  53.         let type_parameters = if self.predict(vec![LexemeType::LeftAngleBracket]).is_ok() {
  54.             self.parse_type_parameters()?
  55.         }
  56.         else {
  57.             vec![]
  58.         };
  59.  
  60.         self.consume(vec![LexemeType::OpenBraces]);
  61.  
  62.         let members = self.parse_class_members()?;
  63.  
  64.         self.consume(vec![LexemeType::CloseBraces]);
  65.  
  66.         Ok(Class::new(
  67.             class_keyword.lexeme_location().clone(),
  68.             tag,
  69.             parents,
  70.             class_name,
  71.             type_parameters,
  72.             members,
  73.         ))
  74.     }
  75.  
  76.     pub fn parse_class_members(&mut self) -> Result<Vec<ClassMember>> {
  77.         let mut members = vec![];
  78.  
  79.         while self.peek(0)?.lexeme_type() != &LexemeType::CloseBraces {
  80.             if self.predict(vec![LexemeType::Identifier, LexemeType::Identifier]).is_ok() {
  81.                 let field = self.parse_class_field()?;
  82.  
  83.                 members.push(ClassMember::Field(field));
  84.             }
  85.             else {
  86.                 let tag = self.parse_tag()?;
  87.  
  88.                 if self.consume(vec![LexemeType::Accessor]).is_ok() {
  89.                     members.push(ClassMember::StaticMethod(self.parse_method(tag)?));
  90.                 }
  91.                 else {
  92.                     let method = self.parse_method(tag)?;
  93.  
  94.                     members.push(ClassMember::Method(method));
  95.                 }
  96.             }
  97.         }
  98.  
  99.         Ok(members)
  100.     }
  101.    
  102.     pub fn parse_class_field(&mut self) -> Result<Field> {
  103.         let location = self.peek(0)?.lexeme_location();
  104.  
  105.         let typ = self.parse_type()?;
  106.         let field_name = self.parse_access_identifier()?;
  107.  
  108.         if self.consume(vec![LexemeType::Equal]).is_ok() {
  109.             let expr = self.parse_expression(None, None)?;
  110.             self.consume(vec![LexemeType::Semicolon]);
  111.  
  112.             Ok(Field::new(location, field_name, typ, Some(expr)))
  113.         }
  114.         else {
  115.             self.consume(vec![LexemeType::Semicolon]);
  116.  
  117.             Ok(Field::new(location, field_name, typ, None))
  118.         }
  119.     }
  120.  
  121.     pub fn parse_method(&mut self, tag: Option<Tag>) -> Result<Method> {
  122.         let location = self.peek(0)?.lexeme_location();
  123.  
  124.         let return_type = self.parse_type()?;
  125.         let method_name = self.parse_identifier()?;
  126.  
  127.         let lexeme = self.peek(0)?;
  128.  
  129.         if lexeme.lexeme_type() == &LexemeType::OpenParenthesis {
  130.             let parameters = self.parse_parameters()?;
  131.  
  132.             if self.predict(vec![LexemeType::Semicolon]).is_ok() {
  133.                 self.take()?;
  134.  
  135.                 Ok(Method::new_declaration(location, tag, method_name, parameters, return_type))
  136.             }
  137.             else if self.predict_one_of(vec![LexemeType::OpenBraces, LexemeType::Equal]).is_ok() {
  138.                 let body = self.parse_body()?;
  139.  
  140.                 Ok(Method::new(location, tag, method_name, parameters, return_type, body))
  141.             }
  142.             else {
  143.                 Err(ParserError::new(
  144.                     ParserErrorVariant::UnexpectedLexeme(self.peek(0)?,
  145.                                                          vec![LexemeType::OpenBraces, LexemeType::Semicolon, LexemeType::Equal],
  146.                                                          "parse_method".to_string())
  147.                 ))
  148.             }
  149.         }
  150.         else {
  151.             Err(ParserError::new(
  152.                 ParserErrorVariant::UnexpectedLexeme(lexeme, vec![LexemeType::OpenParenthesis], "parse_method".to_string())
  153.             ))
  154.         }
  155.     }
  156.  
  157.     fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
  158.         self.consume(vec![LexemeType::OpenParenthesis])?;
  159.  
  160.         let mut params = vec![];
  161.  
  162.         while self.peek(0)?.lexeme_type() != &LexemeType::CloseParenthesis {
  163.             // self.take()?;
  164.             let typ = self.parse_type()?;
  165.  
  166.             self.predict(vec![LexemeType::Identifier])?;
  167.             let param_name = self.take()?.lexeme_value();
  168.  
  169.             params.push(Parameter::new(param_name, typ));
  170.  
  171.             let lexeme = self.peek(0)?;
  172.  
  173.             match lexeme.lexeme_type() {
  174.                 LexemeType::Comma => {
  175.                     self.take()?;
  176.                     ()
  177.                 },
  178.                 LexemeType::CloseParenthesis => (),
  179.                 _ => {
  180.                     return Err(ParserError::new(
  181.                         ParserErrorVariant::UnexpectedLexeme(lexeme,
  182.                                                              vec![LexemeType::Comma, LexemeType::CloseParenthesis],
  183.                                                              "parse_parameters".to_string())
  184.                     ));
  185.                 }
  186.             }
  187.         }
  188.  
  189.         self.consume(vec![LexemeType::CloseParenthesis])?;
  190.  
  191.         return Ok(params);
  192.     }
  193.  
  194.     fn parse_identifier(&mut self) -> Result<String> {
  195.         self.predict(vec![LexemeType::Identifier]);
  196.  
  197.         return Ok(self.take()?.lexeme_value());
  198.     }
  199.  
  200.     pub fn parse_access_identifier(&mut self) -> Result<String> {
  201.         let mut chain = vec![];
  202.  
  203.         self.predict(vec![LexemeType::Identifier])?;
  204.  
  205.         chain.push(self.take()?.lexeme_value());
  206.  
  207.         while self.peek(0)?.lexeme_type() == &LexemeType::Accessor {
  208.             self.consume(vec![LexemeType::Accessor]);
  209.             self.consume(vec![LexemeType::Identifier]);
  210.  
  211.             chain.push(self.take()?.lexeme_value());
  212.         }
  213.  
  214.         return Ok(chain.join("::"));
  215.     }
  216.  
  217.     pub fn parse_type(&mut self) -> Result<ParsedType> {
  218.         self.predict(vec![LexemeType::Identifier])?;
  219.  
  220.         let type_name = self.parse_access_identifier()?;
  221.  
  222.         return if self.predict(vec![LexemeType::LeftAngleBracket]).is_ok() {
  223.             let list = self.parse_many(
  224.                 LexemeType::LeftAngleBracket,
  225.                 LexemeType::RightAngleBracket,
  226.                 LexemeType::Comma,
  227.                 |parser| parser.parse_type(),
  228.             )?;
  229.  
  230.             Ok(ParsedType::generic_type(type_name, list))
  231.         } else {
  232.             Ok(ParsedType::type_name(type_name))
  233.         }
  234.     }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×