mech_core/
nodes.rs

1use crate::*; 
2#[cfg(feature = "no_std")]
3use core::cmp::Ordering;
4#[cfg(not(feature = "no_std"))] 
5use std::cmp::Ordering;
6
7#[cfg(feature = "serde")]
8pub fn compress_and_encode<T: serde::Serialize>(tree: &T) -> Result<String, Box<dyn std::error::Error>> {
9  let serialized_code = bincode::serde::encode_to_vec(tree,bincode::config::standard())?;
10  let mut compressed = Vec::new();
11  brotli::CompressorWriter::new(&mut compressed, 9, 4096, 22)
12      .write(&serialized_code)?;
13  Ok(base64::encode(compressed))
14}
15
16#[cfg(feature = "serde")]
17pub fn decode_and_decompress<T: serde::de::DeserializeOwned>(encoded: &str) -> Result<T, Box<dyn std::error::Error>> {
18  let decoded = base64::decode(encoded)?;
19  
20  let mut decompressed = Vec::new();
21  brotli::Decompressor::new(Cursor::new(decoded), 4096)
22      .read_to_end(&mut decompressed)?;
23  
24  let (decoded,red) = bincode::serde::decode_from_slice(&decompressed,bincode::config::standard())?;
25
26  Ok(decoded)
27}
28#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
29#[derive(Clone, Copy, PartialEq, Eq, Hash, Ord)]
30pub struct SourceLocation {
31  pub row: usize,
32  pub col: usize,
33}
34
35impl PartialOrd for SourceLocation {
36  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
37    if self.row < other.row {
38      Some(Ordering::Less)
39    } else if self.row > other.row {
40      Some(Ordering::Greater)
41    } else {
42      self.col.partial_cmp(&other.col)
43    }
44  }
45}
46
47impl fmt::Debug for SourceLocation {
48  #[inline]
49  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
50    write!(f, "{}:{}", self.row, self.col);
51    Ok(())
52  }
53}
54
55#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
56#[derive(Clone, Hash, PartialEq, Eq)]
57pub struct SourceRange {
58  pub start: SourceLocation,
59  pub end:   SourceLocation,
60}
61
62/// Coordinates in SourceRange are 1-indexed, i.e. they directly translate
63/// human's view to line and column numbers.  Having value 0 means the 
64/// range is not initialized.
65impl Default for SourceRange {
66  fn default() -> Self {
67    SourceRange {
68      start: SourceLocation { row: 0, col: 0 },
69      end:   SourceLocation { row: 0, col: 0 },
70    }
71  }
72}
73
74impl fmt::Debug for SourceRange {
75  #[inline]
76  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
77    write!(f, "[{:?}, {:?})", self.start, self.end);
78    Ok(())
79  }
80}
81
82pub fn merge_src_range(r1: SourceRange, r2: SourceRange) -> SourceRange {
83  SourceRange {
84    start: r1.start.min(r2.start),
85    end:   r2.end.max(r2.end),
86  }
87}
88
89pub trait Recoverable: Sized {
90  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self;
91}
92
93#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
94#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
95pub enum TokenKind {
96  AbstractSigil, Alpha, Ampersand, Any, Apostrophe, AssignOperator, Asterisk, AsyncTransitionOperator, At,
97  Backslash, Bar, BoxDrawing,
98  Caret, CarriageReturn, CarriageReturnNewLine, Colon, CodeBlock, Comma,
99  Dash, DefineOperator, Digit, Dollar,
100  Emoji, EmphasisSigil, Empty, Equal, EquationSigil, Error, ErrorSigil, EscapedChar, Exclamation, 
101  False, FloatLeft, FloatRight, FootnotePrefix,
102  GenOperator, Grave, GraveCodeBlockSigil,
103  HashTag, HighlightSigil, HttpPrefix,
104  IdeaSigil, Identifier, ImgPrefix, InfoSigil, InlineCode, 
105  LeftAngle, LeftBrace, LeftBracket, LeftParenthesis,
106  #[cfg(feature = "mika")]
107  Mika(Mika), 
108  MikaSection, MikaSectionOpen, MikaSectionClose,
109  Newline, Not, Number,
110  OutputOperator,
111  Percent, Period, Plus, PromptSigil,
112  Question, QuestionSigil, Quote, QuoteSigil,
113  RightAngle, RightBrace, RightBracket, RightParenthesis,
114  SectionSigil, Semicolon, Space, Slash, String, StrikeSigil, StrongSigil, SuccessSigil, SynthOperator,
115  Tab, Text, Tilde, TildeCodeBlockSigil, Title, TransitionOperator, True,
116  UnderlineSigil, Underscore,
117  WarningSigil,
118}
119
120#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
121#[derive(Clone, Hash, PartialEq, Eq)]
122pub struct Token { 
123  pub kind: TokenKind, 
124  pub chars: Vec<char>, 
125  pub src_range: SourceRange 
126}
127
128impl fmt::Debug for Token {
129  #[inline]
130  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
131    write!(f, "{:?}:{:?}:{:?}", self.kind, String::from_iter(self.chars.iter().cloned()), self.src_range);
132    Ok(())
133  }
134}
135
136impl Default for Token {
137  fn default() -> Self {
138    Token{
139      kind: TokenKind::Empty,
140      chars: vec![],
141      src_range: SourceRange::default(),
142    }
143  }
144}
145
146impl Token {
147
148  pub fn new(kind: TokenKind, src_range: SourceRange, chars: Vec<char>) -> Token {
149    Token{kind, chars, src_range}
150  }
151
152  pub fn to_string(&self) -> String {
153    self.chars.iter().collect()
154  }
155
156  pub fn merge_tokens(tokens: &mut Vec<Token>) -> Option<Token> {
157    if tokens.len() == 0 {
158      None
159    } else if tokens.len() == 1 {
160      Some(tokens[0].clone())
161    } else {
162      let first = tokens[0].src_range.clone();
163      let kind = tokens[0].kind.clone();
164      let last = tokens.last().unwrap().src_range.clone();
165      let src_range = merge_src_range(first, last);
166      let chars: Vec<char> = tokens.iter_mut().fold(vec![],|mut m, ref mut t| {m.append(&mut t.chars.clone()); m});
167      let merged_token = Token{kind, chars, src_range};
168      Some(merged_token)
169    }
170  }
171}
172
173#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
174#[derive(Clone, Debug, Hash, PartialEq, Eq)]
175pub struct TableOfContents {
176    pub title: Option<Title>,
177    pub sections: Vec<Section>,
178}
179
180#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
181#[derive(Clone, Debug, Hash, PartialEq, Eq)]
182pub struct Program {
183  pub title: Option<Title>,
184  pub body: Body,
185}
186
187impl Program {
188  pub fn tokens(&self) -> Vec<Token> {
189    /*let mut title_tokens = match self.title.tokens() {
190      Some(tkns) => tkns,
191      None => vec![],
192    };*/
193    let body_tokens = self.body.tokens();
194    body_tokens
195  }
196
197  pub fn table_of_contents(&self) -> TableOfContents {
198    let mut sections = vec![];
199    for s in &self.body.sections {
200      sections.push(s.table_of_contents());
201    }
202    TableOfContents {
203      title: self.title.clone(),
204      sections,
205    }
206  }
207
208}
209
210#[cfg(feature = "pretty_print")]
211impl PrettyPrint for Program {
212fn pretty_print(&self) -> String {
213    #[cfg(feature = "serde")]
214    let json_string = serde_json::to_string_pretty(self).unwrap();
215    #[cfg(not(feature = "serde"))]
216    let json_string = "Error: Enable Serde to prettt print trees.".to_string();
217
218    let depth = |line: &str|->usize{line.chars().take_while(|&c| c == ' ').count()};
219    let mut result = String::new();
220    let lines: Vec<&str> = json_string.lines().collect();
221    result.push_str("Program\n");
222    for (index, line) in lines.iter().enumerate() {
223      let trm = line.trim();
224      if trm == "}" || 
225         trm == "},"|| 
226         trm == "{" || 
227         trm == "[" || 
228         trm == "],"|| 
229         trm == "]" {
230        continue;
231      }
232  
233      // Count leading spaces to determine depth
234      let d = depth(line);
235      // Construct the tree-like prefix
236      let mut prefix = String::new();
237      for _ in 0..d {
238        prefix.push_str(" ");
239      }
240      if index == lines.len() {
241        prefix.push_str("└ ");
242      } else {
243        if depth(lines[index + 1]) != d {
244          prefix.push_str("└ ");
245        } else {
246          prefix.push_str("├ ");
247        }
248      }
249      let trm = line.trim();
250      let trm = trm.trim_end_matches('{')
251                    .trim_start_matches('"')
252                    .trim_end_matches(':')
253                    .trim_end_matches('"')
254                    .trim_end_matches('[');
255      prefix.push_str(trm);
256  
257      // Append formatted line to result
258      result.push_str(&prefix);
259      result.push('\n');
260      result = result.replace("\":", "");
261    }
262    let mut indexed_str = IndexedString::new(&result);
263    'rows: for i in 0..indexed_str.rows {
264      let rowz = &indexed_str.index_map[i];
265      for j in 0..rowz.len() {
266        let c = match indexed_str.get(i,j) {
267          Some(c) => c,
268          None => continue,
269        };
270        if c == '└' {
271          for k in i+1..indexed_str.rows {
272            match indexed_str.get(k,j) {
273              Some(c2) => {
274                if c2 == '└' {
275                  indexed_str.set(i,j,'├');
276                  for l in i+1..k {
277                    match indexed_str.get(l,j) {
278                      Some(' ') => {indexed_str.set(l,j,'│');},
279                      Some('└') => {indexed_str.set(l,j,'├');},
280                      _ => (),
281                    }
282                  }
283                } else if c2 == ' ' {
284                  continue;
285                } else {
286                  continue 'rows;
287                }
288              },
289              None => continue,
290            }
291  
292          }
293        } else if c == ' ' || c == '│' {
294          continue;
295        } else {
296          continue 'rows;
297        }
298      }
299    }
300    indexed_str.to_string()
301  }
302}
303
304#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
305#[derive(Clone, Debug, Hash, PartialEq, Eq)]
306pub struct Title {
307  pub text: Token,
308  pub byline: Option<Paragraph>,
309}
310
311impl Title {
312
313  pub fn to_string(&self) -> String {
314    self.text.to_string()
315  }
316
317}
318
319#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
320#[derive(Clone, Debug, Hash, PartialEq, Eq)]
321pub struct Body {
322  pub sections: Vec<Section>,
323}
324
325impl Body {
326  pub fn tokens(&self) -> Vec<Token> {
327    let mut out = vec![];
328    for s in &self.sections {
329      let mut tkns = s.tokens();
330      out.append(&mut tkns);
331    }
332    out
333  }
334}
335
336#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
337#[derive(Clone, Debug, Hash, PartialEq, Eq)]
338pub enum ColumnAlignment {
339  Left,
340  Center,
341  Right,
342}
343
344#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
345#[derive(Clone, Debug, Hash, PartialEq, Eq)]
346pub struct MarkdownTable {
347  pub header: Vec<Paragraph>,
348  pub rows: Vec<Vec<Paragraph>>,
349  pub alignment: Vec<ColumnAlignment>,
350}
351
352#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
353#[derive(Clone, Debug, Hash, PartialEq, Eq)]
354pub struct Subtitle {
355  pub text: Paragraph,
356  pub level: u8,
357}
358
359impl Subtitle {
360  pub fn to_string(&self) -> String {
361    self.text.to_string()
362  }
363}
364
365#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
366#[derive(Clone, Debug, Hash, PartialEq, Eq)]
367pub struct Section {
368  pub subtitle: Option<Subtitle>,
369  pub elements: Vec<SectionElement>,
370}
371
372impl Section {
373
374  pub fn table_of_contents(&self) -> Section {
375    let elements: Vec<_> = self.elements.iter()
376      .filter(|e| matches!(e, SectionElement::Subtitle(_)))
377      .cloned()
378      .collect();
379    Section {
380      subtitle: self.subtitle.clone(),
381      elements,
382    }
383  }
384
385  pub fn tokens(&self) -> Vec<Token> {
386    let mut out = vec![];
387    for s in &self.elements {
388      let mut tkns = s.tokens();
389      out.append(&mut tkns);
390    }
391    out
392  }
393}
394
395#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
396#[derive(Clone, Debug, Hash, PartialEq, Eq)]
397pub struct Grammar {
398  pub rules: Vec<Rule>,
399}
400
401#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
402#[derive(Clone, Debug, Hash, PartialEq, Eq)]
403pub struct GrammarIdentifier {
404  pub name: Token,
405}
406
407impl GrammarIdentifier {
408  pub fn tokens(&self) -> Vec<Token> {
409    vec![self.name.clone()]
410  }
411
412  pub fn to_string(&self) -> String {
413    self.name.to_string()
414  }
415}
416
417#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
418#[derive(Clone, Debug, Hash, PartialEq, Eq)]
419pub struct Rule {
420  pub name: GrammarIdentifier,
421  pub expr: GrammarExpression,
422}
423
424#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
425#[derive(Clone, Debug, Hash, PartialEq, Eq)]
426pub enum GrammarExpression {
427  Choice(Vec<GrammarExpression>),
428  Definition(GrammarIdentifier),
429  Group(Box<GrammarExpression>),
430  List(Box<GrammarExpression>, Box<GrammarExpression>),
431  Not(Box<GrammarExpression>),
432  Optional(Box<GrammarExpression>),
433  Peek(Box<GrammarExpression>),
434  Repeat0(Box<GrammarExpression>),
435  Repeat1(Box<GrammarExpression>),
436  Range(Token,Token),
437  Sequence(Vec<GrammarExpression>),
438  Terminal(Token),
439}
440
441impl GrammarExpression {
442  pub fn tokens(&self) -> Vec<Token> {
443    match self {
444      GrammarExpression::Choice(exprs) => {
445        let mut tokens = vec![];
446        for expr in exprs {
447          tokens.append(&mut expr.tokens());
448        }
449        tokens
450      }
451      GrammarExpression::Definition(id) => id.tokens(),
452      GrammarExpression::Group(expr) => expr.tokens(),
453      GrammarExpression::List(expr1, expr2) => {
454        let mut tokens = expr1.tokens();
455        tokens.append(&mut expr2.tokens());
456        tokens
457      }
458      GrammarExpression::Not(expr) => expr.tokens(),
459      GrammarExpression::Optional(expr) => expr.tokens(),
460      GrammarExpression::Peek(expr) => expr.tokens(),
461      GrammarExpression::Repeat0(expr) => expr.tokens(),
462      GrammarExpression::Repeat1(expr) => expr.tokens(),
463      GrammarExpression::Range(t1, t2) => vec![t1.clone(), t2.clone()],
464      GrammarExpression::Sequence(exprs) => {
465        let mut tokens = vec![];
466        for expr in exprs {
467          tokens.append(&mut expr.tokens());
468        }
469        tokens
470      }
471      GrammarExpression::Terminal(t) => vec![t.clone()],
472    }
473  }
474
475
476}
477
478#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
479#[derive(Clone, Debug, Hash, PartialEq, Eq)]
480pub struct Citation {
481  pub id: Token,
482  pub text: Paragraph,
483}
484
485impl Citation {
486  pub fn to_string(&self) -> String {
487    format!("[{}]: {}", self.id.to_string(), self.text.to_string())
488  }
489}
490
491// Stores code block configuration
492#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
493#[derive(Clone, Debug, Hash, PartialEq, Eq)]
494pub struct BlockConfig {
495  pub namespace_str: String,
496  pub namespace: u64,
497  pub disabled: bool,
498  pub hidden: bool,
499}
500
501pub type Footnote = (Token, Vec<Paragraph>);
502
503#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
504#[derive(Clone, Debug, Hash, PartialEq, Eq)]
505pub enum FloatDirection {
506  Left,
507  Right,
508}
509
510#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
511#[derive(Clone, Debug, Hash, PartialEq, Eq)]
512pub struct FencedMechCode {
513  pub code: Vec<(MechCode,Option<Comment>)>,
514  pub config: BlockConfig,
515  pub options: Option<OptionMap>,
516}
517
518#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
519#[derive(Clone, Debug, Hash, PartialEq, Eq)]
520pub enum SectionElement {
521  Abstract(Vec<Paragraph>),
522  QuoteBlock(Vec<Paragraph>),
523  InfoBlock(Vec<Paragraph>),
524  SuccessBlock(Vec<Paragraph>),
525  IdeaBlock(Vec<Paragraph>),
526  WarningBlock(Vec<Paragraph>),
527  ErrorBlock(Vec<Paragraph>),
528  QuestionBlock(Vec<Paragraph>),
529  Citation(Citation),
530  CodeBlock(Token),
531  Comment(Comment),
532  Diagram(Token),
533  Equation(Token),
534  FencedMechCode(FencedMechCode),
535  Float((Box<SectionElement>, FloatDirection)),
536  Footnote(Footnote),
537  Grammar(Grammar),
538  Image(Image),
539  List(MDList),
540  MechCode(Vec<(MechCode,Option<Comment>)>),
541  #[cfg(feature = "mika")]
542  Mika((Mika, Option<MikaSection>)),
543  Paragraph(Paragraph),
544  Subtitle(Subtitle),
545  Table(MarkdownTable),
546  Prompt(Box<SectionElement>),
547  ThematicBreak,
548  Error(Token, SourceRange),
549}
550
551impl Recoverable for SectionElement {
552  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
553    SectionElement::Error(skipped_tokens, range)
554  }
555}
556
557impl SectionElement {
558
559  pub fn tokens(&self) -> Vec<Token> {
560    match self {
561      SectionElement::Prompt(prompt) => prompt.tokens(),
562      #[cfg(feature = "mika")]
563      SectionElement::Mika((mika, mika_section)) => {
564        let mut tokens = vec![];
565        tokens.append(&mut mika.tokens());
566        if let Some(mika_section) = mika_section {
567          for mika_section_element in &mika_section.elements.elements {
568            tokens.append(&mut mika_section_element.tokens());
569          }
570        }
571        tokens
572      },
573      SectionElement::FencedMechCode(c) => {
574        let mut tokens = vec![];
575        for (c, _) in &c.code {
576          tokens.append(&mut c.tokens());
577        }
578        tokens
579      }
580      SectionElement::MechCode(codes) => {
581        let mut tokens = vec![];
582        for (code, _) in codes {
583          tokens.append(&mut code.tokens());
584        }
585        tokens
586      }
587      SectionElement::Abstract(paragraphs)
588      | SectionElement::QuoteBlock(paragraphs)
589      | SectionElement::InfoBlock(paragraphs)
590      | SectionElement::SuccessBlock(paragraphs)
591      | SectionElement::IdeaBlock(paragraphs)
592      | SectionElement::WarningBlock(paragraphs)
593      | SectionElement::ErrorBlock(paragraphs)
594      | SectionElement::QuestionBlock(paragraphs) => {
595        let mut tokens = vec![];
596        for paragraph in paragraphs {
597          tokens.append(&mut paragraph.tokens());
598        }
599        tokens
600      }
601      SectionElement::Citation(citation) => citation.text.tokens(),
602      SectionElement::CodeBlock(token)
603      | SectionElement::Diagram(token)
604      | SectionElement::Equation(token) => vec![token.clone()],
605      SectionElement::Comment(comment) => comment.tokens(),
606      SectionElement::Float((element, _)) => element.tokens(),
607      SectionElement::Footnote((_, paragraphs)) => {
608        let mut tokens = vec![];
609        for paragraph in paragraphs {
610          tokens.append(&mut paragraph.tokens());
611        }
612        tokens
613      }
614        SectionElement::Grammar(grammar) => {
615        let mut tokens = vec![];
616        for rule in &grammar.rules {
617          tokens.append(&mut rule.name.tokens());
618          tokens.append(&mut rule.expr.tokens());
619        }
620        tokens
621      }
622      SectionElement::Image(image) => {
623        let mut tokens = vec![image.src.clone()];
624        if let Some(caption) = &image.caption {
625          tokens.append(&mut caption.tokens());
626        }
627        tokens
628      }
629      SectionElement::List(list) => match list {
630      MDList::Unordered(items) => {
631        let mut tokens = vec![];
632        for ((_, paragraph), sublist) in items {
633        tokens.append(&mut paragraph.tokens());
634        if let Some(sublist) = sublist {
635          tokens.append(&mut sublist.tokens());
636        }
637        }
638        tokens
639      }
640      MDList::Ordered(ordered_list) => {
641        let mut tokens = ordered_list.start.tokens();
642        for ((_, paragraph), sublist) in &ordered_list.items {
643        tokens.append(&mut paragraph.tokens());
644        if let Some(sublist) = sublist {
645          tokens.append(&mut sublist.tokens());
646        }
647        }
648        tokens
649      }
650      MDList::Check(items) => {
651        let mut tokens = vec![];
652        for ((_, paragraph), sublist) in items {
653        tokens.append(&mut paragraph.tokens());
654        if let Some(sublist) = sublist {
655          tokens.append(&mut sublist.tokens());
656        }
657        }
658        tokens
659      }
660      },
661      SectionElement::Paragraph(paragraph) => paragraph.tokens(),
662      SectionElement::Subtitle(subtitle) => subtitle.text.tokens(),
663      SectionElement::Table(table) => {
664        let mut tokens = vec![];
665        for header in &table.header {
666          tokens.append(&mut header.tokens());
667        }
668        for row in &table.rows {
669          for column in row {
670          tokens.append(&mut column.tokens());
671          }
672        }
673        tokens
674      }
675      SectionElement::ThematicBreak => vec![],
676      SectionElement::Error(token, _) => vec![token.clone()],
677    }
678  }
679}
680
681
682#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
683#[derive(Clone, Debug, Hash, PartialEq, Eq)]
684pub struct OptionMap {
685  pub elements: Vec<(Identifier, MechString)>,
686}
687
688
689#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
690#[derive(Clone, Debug, Hash, PartialEq, Eq)]
691pub struct Image {
692  pub src: Token,
693  pub caption: Option<Paragraph>,
694  pub style: Option<OptionMap>,
695}
696
697impl Image {
698  pub fn to_string(&self) -> String {
699    let caption = match &self.caption {
700      Some(c) => c.to_string(),
701      None => "".to_string(),
702    };
703    format!("![{}]({})", caption, self.src.to_string())
704  }
705}
706
707pub type UnorderedList = Vec<((Option<Token>,Paragraph),Option<MDList>)>;
708pub type CheckList = Vec<((bool,Paragraph),Option<MDList>)>;
709
710#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
711#[derive(Clone, Debug, Hash, PartialEq, Eq)]
712pub struct OrderedList {
713  pub start: Number,
714  pub items: Vec<((Number,Paragraph),Option<MDList>)>,
715}
716
717#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
718#[derive(Clone, Debug, Hash, PartialEq, Eq)]
719pub enum MDList {
720  Unordered(UnorderedList),
721  Ordered(OrderedList),
722  Check(CheckList)
723}
724
725impl MDList {
726
727  pub fn tokens(&self) -> Vec<Token> {
728    match self {
729      MDList::Unordered(items) => {
730        let mut tokens = vec![];
731        for ((_, paragraph), sublist) in items {
732          tokens.append(&mut paragraph.tokens());
733          if let Some(sublist) = sublist {
734            tokens.append(&mut sublist.tokens());
735          }
736        }
737        tokens
738      }
739      MDList::Ordered(ordered_list) => {
740        let mut tokens = ordered_list.start.tokens();
741        for ((_, paragraph), sublist) in &ordered_list.items {
742          tokens.append(&mut paragraph.tokens());
743          if let Some(sublist) = sublist {
744            tokens.append(&mut sublist.tokens());
745          }
746        }
747        tokens
748      }
749      MDList::Check(items) => {
750        let mut tokens = vec![];
751        for ((_, paragraph), sublist) in items {
752          tokens.append(&mut paragraph.tokens());
753          if let Some(sublist) = sublist {
754            tokens.append(&mut sublist.tokens());
755          }
756        }
757        tokens
758      }
759    }
760  }
761
762}
763
764#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
765#[derive(Clone, Debug, Hash, PartialEq, Eq)]
766pub enum MechCode {
767  Comment(Comment),
768  Expression(Expression),
769  FsmImplementation(FsmImplementation),
770  FsmSpecification(FsmSpecification),
771  FunctionDefine(FunctionDefine),
772  Statement(Statement),
773  Error(Token, SourceRange),
774}
775
776impl Recoverable for MechCode {
777  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
778    MechCode::Error(skipped_tokens, range)
779  }
780}
781
782impl MechCode {
783  pub fn tokens(&self) -> Vec<Token> {
784    match self {
785      MechCode::Expression(x) => x.tokens(),
786      MechCode::Statement(x) => x.tokens(),
787      MechCode::Comment(x) => x.tokens(),
788      MechCode::FsmSpecification(x) => x.tokens(),
789      MechCode::FsmImplementation(x) => x.tokens(),
790      MechCode::FunctionDefine(_) => vec![],
791      MechCode::Error(t,_) => vec![t.clone()],
792    }
793  }
794}
795
796#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
797#[derive(Clone, Debug, Hash, PartialEq, Eq)]
798pub struct FunctionDefine {
799  pub name: Identifier,
800  pub input: Vec<FunctionArgument>,
801  pub output: Vec<FunctionArgument>,
802  pub statements: Vec<Statement>,
803  pub match_arms: Vec<FunctionMatchArm>,
804}
805
806#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
807#[derive(Clone, Debug, Hash, PartialEq, Eq)]
808pub struct FunctionMatchArm {
809  pub pattern: Pattern,
810  pub expression: Expression,
811}
812
813#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
814#[derive(Clone, Debug, Hash, PartialEq, Eq)]
815pub struct MatchArm {
816  pub pattern: Pattern,
817  pub guard: Option<Expression>,
818  pub expression: Expression,
819}
820
821#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
822#[derive(Clone, Debug, Hash, PartialEq, Eq)]
823pub struct FunctionArgument {
824  pub name: Identifier,
825  pub kind: KindAnnotation,
826}
827
828impl FunctionArgument {
829  pub fn tokens(&self) -> Vec<Token> {
830    let mut tokens = self.name.tokens();
831    tokens.append(&mut self.kind.tokens());
832    tokens
833  }
834}
835
836#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
837#[derive(Clone, Debug, Hash, PartialEq, Eq)]
838pub struct FsmImplementation {
839  pub name: Identifier,
840  pub input: Vec<Var>,
841  pub start: Pattern,
842  pub arms: Vec<FsmArm>,
843}
844
845impl FsmImplementation {
846  pub fn tokens(&self) -> Vec<Token> {
847    let mut tokens = self.name.tokens();
848    for input in &self.input {
849      tokens.append(&mut input.tokens());
850    }
851    tokens.append(&mut self.start.tokens());
852    for arm in &self.arms {
853      tokens.append(&mut arm.tokens());
854    }
855    tokens
856  }
857}
858
859#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
860#[derive(Clone, Debug, Hash, PartialEq, Eq)]
861pub enum FsmArm {
862  Guard(Pattern,Vec<Guard>),
863  Transition(Pattern,Vec<Transition>),
864  Comment(Comment),
865}
866
867impl FsmArm {
868  pub fn tokens(&self) -> Vec<Token> {
869    match self {
870      FsmArm::Guard(pattern, guards) => {
871        let mut tokens = pattern.tokens();
872        for guard in guards {
873          tokens.append(&mut guard.tokens());
874        }
875        tokens
876      }
877      FsmArm::Transition(pattern, transitions) => {
878        let mut tokens = pattern.tokens();
879        for transition in transitions {
880          tokens.append(&mut transition.tokens());
881        }
882        tokens
883      }
884      FsmArm::Comment(comment) => comment.tokens(),
885    }
886  }
887}
888
889#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
890#[derive(Clone, Debug, Hash, PartialEq, Eq)]
891pub struct Guard { 
892  pub condition: Pattern,
893  pub transitions: Vec<Transition>,
894}
895
896impl Guard {
897  pub fn tokens(&self) -> Vec<Token> {
898    let mut tokens = self.condition.tokens();
899    for transition in &self.transitions {
900      tokens.append(&mut transition.tokens());
901    }
902    tokens
903  }
904}
905
906#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
907#[derive(Clone, Debug, Hash, PartialEq, Eq)]
908pub enum Transition {
909  Async(Pattern),
910  CodeBlock(Vec<(MechCode, Option<Comment>)>),
911  Next(Pattern),
912  Output(Pattern),
913  Statement(Statement),
914}
915
916impl Transition {
917  pub fn tokens(&self) -> Vec<Token> {
918    match self {
919      Transition::Async(pattern) => pattern.tokens(),
920      Transition::CodeBlock(code) => code.iter().flat_map(|(mech_code, comment)| {
921        let mut tokens = mech_code.tokens();
922        if let Some(comment) = comment {
923          tokens.append(&mut comment.tokens());
924        }
925        tokens
926      }).collect(),
927      Transition::Next(pattern) => pattern.tokens(),
928      Transition::Output(pattern) => pattern.tokens(),
929      Transition::Statement(statement) => statement.tokens(),
930    }
931  }
932}
933
934#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
935#[derive(Clone, Debug, Hash, PartialEq, Eq)]
936pub enum Pattern {
937  Expression(Expression),
938  TupleStruct(PatternTupleStruct),
939  Tuple(PatternTuple),
940  Array(PatternArray),
941  Wildcard,
942}
943
944impl Pattern {
945  pub fn tokens(&self) -> Vec<Token> {
946    match self {
947      Pattern::Expression(e) => e.tokens(),
948      Pattern::TupleStruct(ts) => ts.tokens(),
949      Pattern::Tuple(t) => t.tokens(),
950      Pattern::Array(a) => a.tokens(),
951      Pattern::Wildcard => vec![],
952    }
953  }
954}
955
956#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
957#[derive(Clone, Debug, Hash, PartialEq, Eq)]
958pub struct PatternArray {
959  pub prefix: Vec<Pattern>,
960  pub spread: Option<PatternArraySpread>,
961  pub suffix: Vec<Pattern>,
962}
963
964impl PatternArray {
965  pub fn tokens(&self) -> Vec<Token> {
966    let mut tokens = vec![];
967    for p in &self.prefix {
968      tokens.append(&mut p.tokens());
969    }
970    if let Some(spread) = &self.spread {
971      if let Some(binding) = &spread.binding {
972        tokens.append(&mut binding.tokens());
973      }
974    }
975    for p in &self.suffix {
976      tokens.append(&mut p.tokens());
977    }
978    tokens
979  }
980}
981
982#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
983#[derive(Clone, Debug, Hash, PartialEq, Eq)]
984pub struct PatternArraySpread {
985  pub binding: Option<Box<Pattern>>,
986}
987
988#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
989#[derive(Clone, Debug, Hash, PartialEq, Eq)]
990pub struct PatternTupleStruct {
991  pub name: Identifier,
992  pub patterns: Vec<Pattern>,
993}
994
995impl PatternTupleStruct {
996  pub fn tokens(&self) -> Vec<Token> {
997    let mut tokens = self.name.tokens();
998    for p in &self.patterns {
999      tokens.append(&mut p.tokens());
1000    }
1001    tokens
1002  }
1003}
1004
1005#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1006#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1007pub struct PatternTuple(pub Vec<Pattern>);
1008
1009impl PatternTuple {
1010  pub fn tokens(&self) -> Vec<Token> {
1011    let mut tokens = vec![];
1012    for p in &self.0 {
1013        tokens.append(&mut p.tokens());
1014    }
1015    tokens
1016  }
1017}
1018
1019#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1020#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1021pub struct FsmSpecification {
1022  pub name: Identifier,
1023  pub input: Vec<Var>,
1024  pub output: Option<KindAnnotation>,
1025  pub states: Vec<StateDefinition>,
1026}
1027
1028impl FsmSpecification {
1029  pub fn tokens(&self) -> Vec<Token> {
1030    let mut tokens = self.name.tokens();
1031    for var in &self.input {
1032      tokens.append(&mut var.tokens());
1033    }
1034    if let Some(output) = &self.output {
1035      tokens.append(&mut output.tokens());
1036    }
1037    for state in &self.states {
1038      tokens.append(&mut state.tokens());
1039    }
1040    tokens
1041  }
1042}
1043
1044#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1045#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1046pub struct StateDefinition {
1047  pub name: Identifier,
1048  pub state_variables: Option<Vec<Var>>,
1049}
1050
1051impl StateDefinition {
1052  pub fn tokens(&self) -> Vec<Token> {
1053    let mut tokens = self.name.tokens();
1054    if let Some(vars) = &self.state_variables {
1055      for var in vars {
1056        tokens.append(&mut var.tokens());
1057      }
1058    }
1059    tokens
1060  }
1061}
1062
1063#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1064#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1065pub enum Statement {
1066  EnumDefine(EnumDefine),
1067  FsmDeclare(FsmDeclare),
1068  KindDefine(KindDefine),
1069  OpAssign(OpAssign),
1070  VariableAssign(VariableAssign),
1071  VariableDefine(VariableDefine),
1072  TupleDestructure(TupleDestructure),
1073  SplitTable,     // todo
1074  FlattenTable,   // todo
1075}
1076
1077impl Statement {
1078  pub fn tokens(&self) -> Vec<Token> {
1079    match self {
1080      Statement::EnumDefine(x) => x.tokens(),
1081      Statement::FsmDeclare(x) => x.tokens(),
1082      Statement::KindDefine(x) => x.tokens(),
1083      Statement::OpAssign(x) => x.tokens(),
1084      Statement::VariableAssign(x) => x.tokens(),
1085      Statement::VariableDefine(x) => x.tokens(),
1086      Statement::TupleDestructure(x) => x.tokens(),
1087      Statement::SplitTable => vec![], // todo
1088      Statement::FlattenTable => vec![], // todo
1089    }
1090  }
1091}
1092
1093#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1094#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1095pub struct TupleDestructure {
1096  pub vars: Vec<Identifier>,
1097  pub expression: Expression,
1098}
1099
1100impl TupleDestructure {
1101  pub fn tokens(&self) -> Vec<Token> {
1102    let mut tokens = vec![];
1103    for var in &self.vars {
1104      tokens.append(&mut var.tokens());
1105    }
1106    tokens.append(&mut self.expression.tokens());
1107    tokens
1108  }
1109}
1110
1111#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1112#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1113pub struct FsmPipe {
1114  pub start: FsmInstance,
1115  pub transitions: Vec<Transition>
1116}
1117
1118impl FsmPipe {
1119  pub fn tokens(&self) -> Vec<Token> {
1120    let mut tokens = self.start.tokens();
1121    for transition in &self.transitions {
1122      tokens.append(&mut transition.tokens());
1123    }
1124    tokens
1125  }
1126}
1127
1128#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1129#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1130pub enum PipeElement {
1131  Expression(Expression),
1132  FsmInstance(FsmInstance),
1133  Timer // todo
1134}
1135
1136#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1137#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1138pub struct FsmDeclare {
1139  pub fsm: Fsm,
1140  pub pipe: FsmPipe,
1141}
1142
1143impl FsmDeclare {
1144  pub fn tokens(&self) -> Vec<Token> {
1145    let mut tokens = self.fsm.tokens();
1146    tokens.append(&mut self.pipe.tokens());
1147    tokens
1148  }
1149}
1150
1151#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1152#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1153pub struct Fsm {
1154  pub name: Identifier,
1155  pub args: Option<ArgumentList>,
1156  pub kind: Option<KindAnnotation>
1157}
1158
1159impl Fsm {
1160  pub fn tokens(&self) -> Vec<Token> {
1161    let mut tokens = self.name.tokens();
1162    if let Some(args) = &self.args {
1163      for (binding, expression) in args {
1164        if let Some(binding) = binding {
1165          tokens.append(&mut binding.tokens());
1166        }
1167        tokens.append(&mut expression.tokens());
1168      }
1169    }
1170    if let Some(kind) = &self.kind {
1171      tokens.append(&mut kind.tokens());
1172    }
1173    tokens
1174  }
1175}
1176
1177pub type FsmArgs = Vec<(Option<Identifier>,Expression)>;
1178
1179#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1180#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1181pub struct FsmInstance {
1182  pub name: Identifier,
1183  pub args: Option<FsmArgs>,
1184}
1185
1186impl FsmInstance {
1187  pub fn tokens(&self) -> Vec<Token> {
1188    let mut tokens = self.name.tokens();
1189    if let Some(args) = &self.args {
1190      for (binding, expression) in args {
1191        if let Some(binding) = binding {
1192          tokens.append(&mut binding.tokens());
1193        }
1194        tokens.append(&mut expression.tokens());
1195      }
1196    }
1197    tokens
1198  }
1199}
1200
1201#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1202#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1203pub struct EnumDefine {
1204  pub name: Identifier,
1205  pub variants: Vec<EnumVariant>,
1206}
1207
1208impl EnumDefine {
1209  pub fn tokens(&self) -> Vec<Token> {
1210    let mut tokens = self.name.tokens();
1211    for v in &self.variants {
1212      tokens.append(&mut v.tokens());
1213    }
1214    tokens
1215  }
1216}
1217
1218#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1219#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1220pub struct EnumVariant {
1221  pub name: Identifier,
1222  pub value: Option<KindAnnotation>,
1223}
1224
1225impl EnumVariant {
1226  pub fn tokens(&self) -> Vec<Token> {
1227    let mut tokens = self.name.tokens();
1228    if let Some(value) = &self.value {
1229      tokens.append(&mut value.tokens());
1230    }
1231    tokens
1232  }
1233}
1234
1235#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1236#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1237pub struct KindDefine {
1238  pub name: Identifier,
1239  pub kind: KindAnnotation,
1240}
1241
1242impl KindDefine {
1243  pub fn tokens(&self) -> Vec<Token> {
1244    let mut tokens = self.name.tokens();
1245    tokens.append(&mut self.kind.tokens());
1246    tokens
1247  }
1248}
1249
1250#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1251#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1252pub struct Record {
1253  pub bindings: Vec<Binding>,
1254}
1255
1256impl Record {
1257  pub fn tokens(&self) -> Vec<Token> {
1258    let mut tkns = vec![];
1259    for b in &self.bindings {
1260      let mut t = b.tokens();
1261      tkns.append(&mut t);
1262    }
1263    tkns
1264  }
1265}
1266
1267#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1268#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1269pub enum Structure {
1270  Empty,
1271  Map(Map),
1272  Matrix(Matrix),
1273  Record(Record),
1274  Set(Set),
1275  Table(Table),
1276  Tuple(Tuple),
1277  TupleStruct(TupleStruct),
1278}
1279
1280impl Structure {
1281  pub fn tokens(&self) -> Vec<Token> {
1282    match self {
1283      Structure::Empty => vec![],
1284      Structure::Map(map) => map.tokens(),
1285      Structure::Matrix(mat) => mat.tokens(),
1286      Structure::Record(rec) => rec.tokens(),
1287      Structure::Set(set) => set.tokens(),
1288      Structure::Table(tab) => tab.tokens(),
1289      Structure::Tuple(tup) => tup.tokens(),
1290      Structure::TupleStruct(ts) => ts.tokens(),
1291    }
1292  }
1293}
1294
1295#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1296#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1297pub struct Map {
1298  pub elements: Vec<Mapping>,
1299}
1300
1301impl Map {
1302  pub fn tokens(&self) -> Vec<Token> {
1303    let mut tkns = vec![];
1304    for e in &self.elements {
1305      let mut t = e.tokens();
1306      tkns.append(&mut t);
1307    }
1308    tkns
1309  }
1310}
1311
1312#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1313#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1314pub struct Mapping {
1315  pub key: Expression,
1316  pub value: Expression,
1317}
1318
1319impl Mapping {
1320  pub fn tokens(&self) -> Vec<Token> {
1321    let mut tkns = self.key.tokens();
1322    tkns.append(&mut self.value.tokens());
1323    tkns
1324  }
1325}
1326
1327#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1328#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1329pub struct Set {
1330  pub elements: Vec<Expression>,
1331}
1332
1333impl Set {
1334  pub fn tokens(&self) -> Vec<Token> {
1335    let mut tkns = vec![];
1336    for e in &self.elements {
1337      let mut t = e.tokens();
1338      tkns.append(&mut t);
1339    }
1340    tkns
1341  }
1342}
1343
1344#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1345#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1346pub struct Atom {
1347  pub name: Identifier,
1348}
1349
1350impl Atom {
1351  pub fn tokens(&self) -> Vec<Token> {
1352    self.name.tokens()
1353  }
1354}
1355
1356#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1357#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1358pub struct TupleStruct {
1359  pub name: Identifier,
1360  pub value: Box<Expression>,
1361}
1362
1363impl TupleStruct {
1364  pub fn tokens(&self) -> Vec<Token> {
1365    let mut tkns = self.name.tokens();
1366    tkns.append(&mut self.value.tokens());
1367    tkns
1368  }
1369}
1370
1371#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1372#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1373pub struct Matrix {
1374  pub rows: Vec<MatrixRow>,
1375}
1376
1377impl Matrix {
1378  pub fn tokens(&self) -> Vec<Token> {
1379    let mut tkns = vec![];
1380    for r in &self.rows {
1381      let mut t = r.tokens();
1382      tkns.append(&mut t);
1383    }
1384    tkns
1385  }
1386}
1387
1388#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1389#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1390pub struct TableHeader(pub Vec<Field>);
1391
1392impl TableHeader {
1393  pub fn new(fields: Vec<Field>) -> TableHeader {
1394    TableHeader(fields)
1395  }
1396  pub fn tokens(&self) -> Vec<Token> {
1397    let mut tkns = vec![];
1398    for f in &self.0 {
1399      let mut t = f.tokens();
1400      tkns.append(&mut t);
1401    }
1402    tkns
1403  }
1404}
1405
1406#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1407#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1408pub struct Table {
1409  pub header: TableHeader,
1410  pub rows: Vec<TableRow>,
1411}
1412
1413impl Table {
1414  pub fn tokens(&self) -> Vec<Token> {
1415    let mut tkns = vec![];
1416    for f in &self.header.0 {
1417      let mut t = f.tokens();
1418      tkns.append(&mut t);
1419    }
1420    for r in &self.rows {
1421      let mut t = r.tokens();
1422      tkns.append(&mut t);
1423    }
1424    tkns
1425  }
1426}
1427
1428#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1429#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1430pub struct Field {
1431  pub name: Identifier,
1432  pub kind: Option<KindAnnotation>,
1433}
1434
1435impl Field {
1436  pub fn tokens(&self) -> Vec<Token> {
1437    let mut tkns = self.name.tokens();
1438    if let Some(knd) = &self.kind {
1439      let mut t = knd.tokens();
1440      tkns.append(&mut t);
1441    }
1442    tkns
1443  }
1444}
1445
1446#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1447#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1448pub struct TableColumn {
1449  pub element: Expression,
1450}
1451
1452impl TableColumn {
1453  pub fn tokens(&self) -> Vec<Token> {
1454    self.element.tokens()
1455  }
1456}
1457
1458#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1459#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1460pub struct MatrixColumn {
1461  pub element: Expression,
1462}
1463
1464impl MatrixColumn {
1465  pub fn tokens(&self) -> Vec<Token> {
1466    self.element.tokens()
1467  }
1468}
1469
1470#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1471#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1472pub struct TableRow {
1473  pub columns: Vec<TableColumn>,
1474}
1475
1476impl TableRow {
1477  pub fn tokens(&self) -> Vec<Token> {
1478    let mut tkns = vec![];
1479    for r in &self.columns {
1480      let mut t = r.element.tokens();
1481      tkns.append(&mut t);
1482    }
1483    tkns
1484  }
1485}
1486
1487#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1488#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1489pub struct MatrixRow {
1490  pub columns: Vec<MatrixColumn>,
1491}
1492
1493impl MatrixRow {
1494  pub fn tokens(&self) -> Vec<Token> {
1495    let mut tkns = vec![];
1496    for r in &self.columns {
1497      let mut t = r.tokens();
1498      tkns.append(&mut t);
1499    }
1500    tkns
1501  }
1502}
1503
1504#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1505#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1506pub struct VariableDefine {
1507  pub mutable: bool,
1508  pub var: Var,
1509  pub expression: Expression,
1510}
1511
1512impl VariableDefine {
1513  pub fn tokens(&self) -> Vec<Token> {
1514    let mut tkns = self.var.tokens();
1515    tkns.append(&mut self.expression.tokens());
1516    tkns
1517  }
1518}
1519
1520#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1521#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1522pub struct Var {
1523  pub name: Identifier,
1524  pub kind: Option<KindAnnotation>,
1525}
1526
1527impl Var {
1528  pub fn tokens(&self) -> Vec<Token> {
1529    let mut tkns = self.name.tokens();
1530    if let Some(knd) = &self.kind {
1531      let mut t = knd.tokens();
1532      tkns.append(&mut t);
1533    }
1534    tkns
1535  }
1536}
1537
1538#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1539#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1540pub struct VariableAssign {
1541  pub target: SliceRef,
1542  pub expression: Expression,
1543}
1544
1545impl VariableAssign {
1546  pub fn tokens(&self) -> Vec<Token> {
1547    let mut tkns = self.target.tokens();
1548    tkns.append(&mut self.expression.tokens());
1549    tkns
1550  }
1551}
1552
1553#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1554#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1555pub struct Identifier {
1556  pub name: Token,
1557}
1558
1559impl Identifier {
1560  pub fn tokens(&self) -> Vec<Token> {
1561    vec![self.name.clone()]
1562  }
1563
1564  pub fn to_string(&self) -> String {
1565    self.name.to_string()
1566  }
1567
1568}
1569
1570impl Identifier {
1571  pub fn hash(&self) -> u64 {
1572    hash_chars(&self.name.chars)
1573  }
1574}
1575
1576#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1577#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1578pub struct Emoji {
1579  pub tokens: Vec<Token>,
1580}
1581
1582#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1583#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1584pub struct Word {
1585  pub tokens: Vec<Token>,
1586}
1587
1588#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1589#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1590pub struct Slice {
1591  pub name: Identifier,
1592  pub subscript: Vec<Subscript>
1593}
1594
1595impl Slice {
1596  pub fn tokens(&self) -> Vec<Token> {
1597    let mut tkns = self.name.tokens();
1598    for sub in &self.subscript {
1599      let mut sub_tkns = sub.tokens();
1600      tkns.append(&mut sub_tkns);
1601    }
1602    tkns
1603  }
1604}
1605
1606#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1607#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1608pub struct SliceRef {
1609  pub name: Identifier,
1610  pub subscript: Option<Vec<Subscript>>
1611}
1612
1613impl SliceRef {
1614  pub fn tokens(&self) -> Vec<Token> {
1615    let mut tkns = self.name.tokens();
1616    if let Some(subs) = &self.subscript {
1617      for sub in subs {
1618        let mut sub_tkns = sub.tokens();
1619        tkns.append(&mut sub_tkns);
1620      }
1621    }
1622    tkns
1623  }
1624}
1625
1626#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1627#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1628pub enum Subscript {
1629  All,                      // a[:]
1630  Brace(Vec<Subscript>),    // a{"foo"}
1631  Bracket(Vec<Subscript>),  // a[1,2,3]
1632  Dot(Identifier),          // a.b
1633  DotInt(RealNumber),       // a.1
1634  Formula(Factor),          // a[1 + 1]
1635  Range(RangeExpression),   // a[1 + 1]
1636  Swizzle(Vec<Identifier>), // a.b,c
1637}
1638
1639impl Subscript {
1640
1641  pub fn tokens(&self) -> Vec<Token> {
1642    match self {
1643      Subscript::All => vec![
1644        Token::new(TokenKind::Colon, SourceRange::default(), vec![':']),
1645      ],
1646      Subscript::Brace(subs) => {
1647        let mut tkns = vec![Token::new(TokenKind::LeftBrace, SourceRange::default(), vec!['{'])];
1648        for sub in subs {
1649          let mut sub_tkns = sub.tokens();
1650          tkns.append(&mut sub_tkns);
1651        }
1652        tkns.push(Token::new(TokenKind::RightBrace, SourceRange::default(), vec!['}']));
1653        tkns
1654      },
1655      Subscript::Bracket(subs) => {
1656        let mut tkns = vec![Token::new(TokenKind::LeftBracket, SourceRange::default(), vec!['['])];
1657        for sub in subs {
1658          let mut sub_tkns = sub.tokens();
1659          tkns.append(&mut sub_tkns);
1660        }
1661        tkns.push(Token::new(TokenKind::RightBracket, SourceRange::default(), vec![']']));
1662        tkns
1663      },
1664      Subscript::Dot(id) => id.tokens(),
1665      Subscript::DotInt(num) => num.tokens(),
1666      Subscript::Formula(factor) => factor.tokens(),
1667      Subscript::Range(range) => range.tokens(),
1668      Subscript::Swizzle(ids) => ids.iter().flat_map(|id| id.tokens()).collect(),
1669    }
1670  }
1671}
1672
1673#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1674#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1675pub enum Expression {
1676  Formula(Factor),
1677  FunctionCall(FunctionCall),
1678  FsmPipe(FsmPipe),
1679  Literal(Literal),
1680  Match(Box<MatchExpression>),
1681  Range(Box<RangeExpression>),
1682  Slice(Slice),
1683  Structure(Structure),
1684  SetComprehension(Box<SetComprehension>),
1685  MatrixComprehension(Box<MatrixComprehension>),
1686  Var(Var),
1687}
1688
1689impl Expression {
1690  pub fn tokens(&self) -> Vec<Token> {
1691    match self {
1692      Expression::Var(v) => v.tokens(),
1693      Expression::Literal(ltrl) => ltrl.tokens(),
1694      Expression::Structure(strct) => strct.tokens(),
1695      Expression::Formula(fctr) => fctr.tokens(),
1696      Expression::Match(match_expr) => match_expr.tokens(),
1697      Expression::Range(range) => range.tokens(),
1698      Expression::Slice(slice) => slice.tokens(),
1699      Expression::SetComprehension(sc) => sc.tokens(),
1700      Expression::FsmPipe(pipe) => pipe.tokens(),
1701      Expression::MatrixComprehension(mc) => mc.tokens(),
1702      _ => todo!(),
1703    }
1704  }
1705}
1706
1707#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1708#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1709pub struct MatchExpression {
1710  pub source: Expression,
1711  pub arms: Vec<MatchArm>,
1712}
1713
1714impl MatchExpression {
1715  pub fn tokens(&self) -> Vec<Token> {
1716    let mut tokens = self.source.tokens();
1717    for arm in &self.arms {
1718      tokens.append(&mut arm.pattern.tokens());
1719      if let Some(guard) = &arm.guard {
1720        tokens.append(&mut guard.tokens());
1721      }
1722      tokens.append(&mut arm.expression.tokens());
1723    }
1724    tokens
1725  }
1726}
1727
1728#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1729#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1730pub struct SetComprehension {
1731  pub expression: Expression,
1732  pub qualifiers: Vec<ComprehensionQualifier>,
1733}
1734
1735impl SetComprehension {
1736  pub fn tokens(&self) -> Vec<Token> {
1737    let mut tokens = self.expression.tokens();
1738    for qualifier in &self.qualifiers {
1739      tokens.append(&mut qualifier.tokens());
1740    }
1741    tokens
1742  }
1743}
1744
1745#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1746#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1747pub struct MatrixComprehension {
1748  pub expression: Expression,
1749  pub qualifiers: Vec<ComprehensionQualifier>,
1750}
1751
1752impl MatrixComprehension {
1753  pub fn tokens(&self) -> Vec<Token> {
1754    let mut tokens = self.expression.tokens();
1755    for qualifier in &self.qualifiers {
1756      tokens.append(&mut qualifier.tokens());
1757    }
1758    tokens
1759  }
1760}
1761
1762#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1763#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1764pub enum ComprehensionQualifier {
1765  Generator((Pattern,Expression)),
1766  Filter(Expression),
1767  Let(VariableDefine),
1768}
1769
1770impl ComprehensionQualifier {
1771  pub fn tokens(&self) -> Vec<Token> {
1772    match self {
1773      ComprehensionQualifier::Generator((pattern, expr)) => {
1774        let mut tokens = pattern.tokens();
1775        tokens.append(&mut expr.tokens());
1776        tokens
1777      }
1778      ComprehensionQualifier::Filter(expr) => expr.tokens(),
1779      ComprehensionQualifier::Let(var_def) => var_def.tokens(),
1780    }
1781  }
1782}
1783
1784pub type ArgumentList = Vec<(Option<Identifier>,Expression)>;
1785
1786#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1787#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1788pub struct FunctionCall {
1789  pub name: Identifier,
1790  pub args: ArgumentList,
1791}
1792
1793impl FunctionCall {
1794  pub fn tokens(&self) -> Vec<Token> {
1795    self.name.tokens()
1796  }
1797}
1798
1799#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1800#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1801pub struct Tuple {
1802  pub elements: Vec<Expression>
1803}
1804
1805impl Tuple {
1806  pub fn tokens(&self) -> Vec<Token> {
1807    let mut tokens = vec![];
1808    for elem in &self.elements {
1809      tokens.append(&mut elem.tokens());
1810    }
1811    tokens
1812  }
1813}
1814
1815#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1816#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1817pub struct Binding {
1818  pub name: Identifier,
1819  pub kind: Option<KindAnnotation>,
1820  pub value: Expression,
1821}
1822
1823impl Binding {
1824  pub fn tokens(&self) -> Vec<Token> {
1825    let mut tokens = self.name.tokens();
1826    if let Some(knd) = &self.kind {
1827      tokens.append(&mut knd.tokens());
1828    }
1829    tokens.append(&mut self.value.tokens());
1830    tokens
1831  }
1832}
1833
1834#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1835#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1836pub struct KindAnnotation {
1837  pub kind: Kind,
1838}
1839
1840impl KindAnnotation {
1841
1842  pub fn hash(&self) -> u64 {
1843    #[cfg(feature = "no_std")]
1844    let mut hasher = FxHasher::default();
1845    #[cfg(not(feature = "no_std"))]
1846    let mut hasher = std::collections::hash_map::DefaultHasher::new();
1847    self.kind.hash(&mut hasher);
1848    hasher.finish()
1849  }
1850
1851  pub fn tokens(&self) -> Vec<Token> {
1852    self.kind.tokens()
1853  }
1854}
1855
1856#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1857#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1858pub enum Kind {
1859  Any,
1860  Atom(Identifier),
1861  Table((Vec<(Identifier,Kind)>,Box<Literal>)),
1862  Set(Box<Kind>,Option<Box<Literal>>),
1863  Record((Vec<(Identifier,Kind)>)),
1864  Empty,
1865  //Fsm(Vec<Kind>,Vec<Kind>),
1866  //Function(Vec<Kind>,Vec<Kind>),
1867  Map(Box<Kind>,Box<Kind>),
1868  Matrix((Box<Kind>,Vec<Literal>)),
1869  Option(Box<Kind>),
1870  Scalar(Identifier),
1871  Tuple(Vec<Kind>),
1872  Kind(Box<Kind>),
1873}
1874
1875impl Kind {
1876  pub fn tokens(&self) -> Vec<Token> {
1877    match self {
1878      Kind::Option(x) => x.tokens(),
1879      Kind::Tuple(x) => x.iter().flat_map(|k| k.tokens()).collect(),
1880      Kind::Matrix((kind, literals)) => {
1881        let mut tokens = kind.tokens();
1882        for l in literals {
1883          tokens.append(&mut l.tokens());
1884        }
1885        tokens
1886      },
1887      Kind::Record(kinds) => {
1888        let mut tokens = vec![];
1889        for (id, kind) in kinds {
1890          tokens.append(&mut id.tokens());
1891          tokens.append(&mut kind.tokens());
1892        }
1893        tokens
1894      }
1895      Kind::Set(kind, size) => {
1896        let mut tokens = kind.tokens();
1897        if let Some(literal) = size {
1898          tokens.append(&mut literal.tokens());
1899        }
1900        tokens
1901      }
1902      Kind::Table((kinds, literal)) => {
1903        let mut tokens = vec![];
1904        for (id, kind) in kinds {
1905          tokens.append(&mut id.tokens());
1906          tokens.append(&mut kind.tokens());
1907        }
1908        tokens.append(&mut literal.tokens());
1909        tokens
1910      }
1911      Kind::Map(x, y) => x.tokens().into_iter().chain(y.tokens()).collect(),
1912      Kind::Scalar(x) => x.tokens(),
1913      Kind::Atom(x) => x.tokens(),
1914      Kind::Kind(x) => x.tokens(),
1915      Kind::Empty => vec![],
1916      Kind::Any => vec![],
1917    }
1918  }
1919}
1920
1921#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1922#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1923pub enum Literal {
1924  Atom(Atom),
1925  Boolean(Token),
1926  Empty(Token),
1927  Number(Number),
1928  String(MechString),
1929  Kind(Kind),
1930  TypedLiteral((Box<Literal>,KindAnnotation))
1931}
1932
1933impl Literal {
1934  pub fn tokens(&self) -> Vec<Token> {
1935    match self {
1936      Literal::Atom(atm) => atm.name.tokens(),
1937      Literal::Boolean(tkn) => vec![tkn.clone()],
1938      Literal::Number(x) => x.tokens(),
1939      Literal::String(strng) => vec![strng.text.clone()],
1940      Literal::Empty(tkn) => vec![tkn.clone()],
1941      Literal::Kind(knd) => knd.tokens(),
1942      Literal::TypedLiteral((lit, knd)) => {
1943        let mut tokens = lit.tokens();
1944        tokens.append(&mut knd.tokens());
1945        tokens
1946      }
1947    }
1948  }
1949}
1950
1951#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1952#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1953pub struct MechString {
1954  pub text: Token,
1955}
1956
1957impl MechString {
1958  pub fn to_string(&self) -> String {
1959    self.text.to_string()
1960  }
1961}
1962
1963pub type Hyperlink = (Paragraph, Token);
1964
1965#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1966#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1967pub enum ParagraphElement {
1968  Emphasis(Box<ParagraphElement>),
1969  FootnoteReference(Token),
1970  Highlight(Box<ParagraphElement>),
1971  Hyperlink(Hyperlink),
1972  InlineCode(Token),
1973  EvalInlineMechCode(Expression),
1974  InlineMechCode(MechCode),
1975  InlineEquation(Token),
1976  Reference(Token),
1977  SectionReference(Token),
1978  Strikethrough(Box<ParagraphElement>),
1979  Strong(Box<ParagraphElement>),
1980  Text(Token),
1981  Underline(Box<ParagraphElement>),
1982  Error(Token, SourceRange),
1983}
1984
1985impl Recoverable for ParagraphElement {
1986  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
1987    ParagraphElement::Error(skipped_tokens, range)
1988  }
1989}
1990
1991impl ParagraphElement {
1992
1993  pub fn tokens(&self) -> Vec<Token> {
1994    match self {
1995      ParagraphElement::Emphasis(t) => t.tokens(),
1996      ParagraphElement::FootnoteReference(t) => vec![t.clone()],
1997      ParagraphElement::Highlight(t) => t.tokens(),
1998      ParagraphElement::Hyperlink((t, u)) => {
1999        let mut tokens = t.tokens();
2000        tokens.push(u.clone());
2001        tokens
2002      },
2003      ParagraphElement::InlineCode(t) => vec![t.clone()],
2004      ParagraphElement::InlineEquation(t) => vec![t.clone()],
2005      ParagraphElement::InlineMechCode(t) => t.tokens(),
2006      ParagraphElement::EvalInlineMechCode(t) => t.tokens(),
2007      ParagraphElement::Reference(t) => vec![t.clone()],
2008      ParagraphElement::SectionReference(t) => vec![t.clone()],
2009      ParagraphElement::Strikethrough(t) => t.tokens(),
2010      ParagraphElement::Strong(t) => t.tokens(),
2011      ParagraphElement::Text(t) => vec![t.clone()],
2012      ParagraphElement::Underline(t) => t.tokens(),
2013      ParagraphElement::Error(t, _) => vec![t.clone()],
2014    }
2015  }
2016
2017  pub fn to_string(&self) -> String {
2018    match self {
2019      ParagraphElement::Emphasis(t) => t.to_string(),
2020      ParagraphElement::FootnoteReference(t) => t.to_string(),
2021      ParagraphElement::Highlight(t) => t.to_string(),
2022      ParagraphElement::Hyperlink((t, u)) => {
2023        format!("[{}]({})", t.to_string(), u.to_string())
2024      }
2025      ParagraphElement::InlineCode(t) => t.to_string(),
2026      ParagraphElement::InlineEquation(t) => t.to_string(),
2027      ParagraphElement::InlineMechCode(t) => format!("{:?}", t),
2028      ParagraphElement::EvalInlineMechCode(t) => format!("{:?}", t),
2029      ParagraphElement::Reference(t) => t.to_string(),
2030      ParagraphElement::SectionReference(t) => t.to_string(),
2031      ParagraphElement::Strikethrough(t) => t.to_string(),
2032      ParagraphElement::Strong(t) => t.to_string(),
2033      ParagraphElement::Text(t) => t.to_string(),
2034      ParagraphElement::Underline(t) => t.to_string(),
2035      ParagraphElement::Error(t, s) => format!("{{ERROR: {} at {:?}}}", t.to_string(), s),
2036    }
2037  }
2038
2039}
2040
2041#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2042#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2043pub struct Paragraph {
2044  pub elements: Vec<ParagraphElement>,
2045  pub error_range: Option<SourceRange>,
2046}
2047
2048impl Paragraph {
2049  pub fn to_string(&self) -> String {
2050    let mut out = "".to_string();
2051    for e in &self.elements {
2052      out.push_str(&e.to_string());
2053    }
2054    out
2055  }
2056
2057  pub fn from_tokens(tokens: Vec<Token>) -> Paragraph {
2058    let elements = tokens.into_iter().map(|t| ParagraphElement::Text(t)).collect();
2059    Paragraph {
2060      elements,
2061      error_range: None,
2062    }
2063  }
2064
2065  pub fn has_errors(&self) -> bool {
2066    self.error_range.is_some()
2067  }
2068
2069  pub fn tokens(&self) -> Vec<Token> {
2070    let mut tkns = vec![];
2071    for e in &self.elements {
2072      let mut e_tkns = e.tokens();
2073      tkns.append(&mut e_tkns);
2074    }
2075    tkns
2076  }
2077
2078}
2079
2080impl Recoverable for Paragraph {
2081  fn error_placeholder(skipped_tokens: Token, range: SourceRange) -> Self {
2082    Paragraph {
2083      elements: vec![ParagraphElement::Text(Token::new(TokenKind::Error, range.clone(), skipped_tokens.chars.clone()))],
2084      error_range: Some(range),
2085    }
2086  }
2087}
2088
2089
2090pub type Sign = bool;
2091pub type Numerator = Token;
2092pub type Denominator = Token;
2093pub type Whole = Token;
2094pub type Part = Token;
2095pub type Real = Box<Number>;
2096pub type Imaginary = Box<Number>;
2097pub type Base = (Whole, Part);
2098pub type Exponent = (Sign, Whole, Part);
2099
2100#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2101#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2102pub enum Number {
2103  Real(RealNumber),
2104  Complex(C64Node),
2105}
2106
2107impl Number {
2108
2109  pub fn from_integer(x: i64) -> Number {
2110    Number::Real(RealNumber::Integer(Token::new(TokenKind::Digit, SourceRange::default(), x.to_string().chars().collect())))
2111  }
2112
2113  pub fn to_string(&self) -> String {
2114    match self {
2115      Number::Real(x) => x.to_string(),
2116      Number::Complex(x) => x.to_string(),
2117    }
2118  }
2119
2120  pub fn tokens(&self) -> Vec<Token> {
2121    match self {
2122      Number::Real(x) => x.tokens(),
2123      Number::Complex(x) => x.tokens(),
2124    }
2125  }
2126}
2127
2128#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2129#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2130pub enum RealNumber {
2131  Binary(Token),
2132  Decimal(Token),
2133  Float((Whole,Part)),
2134  Hexadecimal(Token),
2135  Integer(Token),
2136  TypedInteger((Token,KindAnnotation)),
2137  Negated(Box<RealNumber>),
2138  Octal(Token),
2139  Rational((Numerator,Denominator)),
2140  Scientific((Base,Exponent)),
2141}
2142
2143impl RealNumber {
2144  pub fn tokens(&self) -> Vec<Token> {
2145    match self {
2146      RealNumber::Integer(tkn) => vec![tkn.clone()],
2147      RealNumber::TypedInteger((tkn, _)) => vec![tkn.clone()],
2148      RealNumber::Float((whole, part)) => vec![whole.clone(), part.clone()],
2149      RealNumber::Binary(tkn) => vec![tkn.clone()],
2150      RealNumber::Hexadecimal(tkn) => vec![tkn.clone()],
2151      RealNumber::Octal(tkn) => vec![tkn.clone()],
2152      RealNumber::Decimal(tkn) => vec![tkn.clone()],
2153      RealNumber::Rational((num, den)) => vec![num.clone(), den.clone()],
2154      RealNumber::Scientific(((whole,part), exponent)) => {
2155        let mut tokens = vec![whole.clone(), part.clone()];
2156        let (sign, whole_exp, part_exp) = exponent;
2157        tokens.push(Token::new(TokenKind::Plus, SourceRange::default(), if *sign { vec!['+'] } else { vec!['-'] }));
2158        tokens.push(whole_exp.clone());
2159        tokens.push(part_exp.clone());
2160        tokens
2161      }
2162      RealNumber::Negated(x) => {
2163        let mut tokens = vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])];
2164        tokens.append(&mut x.tokens());
2165        tokens
2166      }
2167    }
2168  }
2169  pub fn to_string(&self) -> String {
2170    match self {
2171      RealNumber::Integer(tkn) => tkn.to_string(),
2172      RealNumber::Float((whole, part)) => format!("{}.{}", whole.to_string(), part.to_string()),
2173      RealNumber::Binary(tkn) => format!("0b{}", tkn.to_string()),
2174      RealNumber::Hexadecimal(tkn) => format!("0x{}", tkn.to_string()),
2175      RealNumber::Octal(tkn) => format!("0o{}", tkn.to_string()),
2176      RealNumber::Decimal(tkn) => format!("0d{}", tkn.to_string()),
2177      RealNumber::Rational((num, den)) => format!("{}/{}", num.to_string(), den.to_string()),
2178      RealNumber::Scientific(((whole,part), exponent)) => {
2179        let (sign, whole, part) = exponent;
2180        let sign_str = if *sign { "+" } else { "-" };
2181        let whole_str = whole.to_string();
2182        let part_str = part.to_string();
2183        format!("{}{}.{}/10^{}", whole.to_string(), part.to_string(), sign_str, whole_str)
2184      }
2185      RealNumber::TypedInteger((tkn, kind)) => format!("{}{}", tkn.to_string(), kind.kind.tokens().iter().map(|t| t.to_string()).collect::<String>()),
2186      RealNumber::Negated(x) => format!("-{}", x.to_string()),
2187    }
2188  }
2189}
2190
2191#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2192#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2193pub struct ImaginaryNumber {
2194  pub number: RealNumber,
2195}
2196
2197#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2198#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2199pub struct C64Node {
2200  pub real: Option<RealNumber>,
2201  pub imaginary: ImaginaryNumber
2202}
2203
2204impl C64Node {
2205  pub fn tokens(&self) -> Vec<Token> {
2206    let mut tkns = vec![];
2207    if let Some(r) = &self.real {
2208      tkns.append(&mut r.tokens());
2209    }
2210    tkns.append(&mut self.imaginary.number.tokens());
2211    tkns
2212  }
2213
2214  pub fn to_string(&self) -> String {
2215    let mut out = "".to_string();
2216    if let Some(r) = &self.real {
2217      out.push_str(&r.to_string());
2218    }
2219    out.push_str("i");
2220    out
2221  }
2222}
2223
2224#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2225#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2226pub struct Comment {
2227  pub paragraph: Paragraph,
2228}
2229
2230impl Comment {
2231  pub fn tokens(&self) -> Vec<Token> {
2232    self.paragraph.tokens()
2233  }
2234}
2235
2236#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2237#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2238pub struct OpAssign {
2239  pub target: SliceRef,
2240  pub op: OpAssignOp,
2241  pub expression: Expression,
2242}
2243
2244impl OpAssign {
2245  pub fn tokens(&self) -> Vec<Token> {
2246    let mut tkns = self.target.tokens();
2247    tkns.append(&mut self.op.tokens());
2248    tkns.append(&mut self.expression.tokens());
2249    tkns
2250  }
2251}
2252
2253#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2254#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2255pub enum OpAssignOp {
2256  Add,
2257  Div,
2258  Exp, 
2259  Mod,  
2260  Mul,
2261  Sub,   
2262}
2263
2264impl OpAssignOp {
2265  pub fn tokens(&self) -> Vec<Token> {
2266    match self {
2267      OpAssignOp::Add => vec![Token::new(TokenKind::Plus, SourceRange::default(), vec!['+'])],
2268      OpAssignOp::Div => vec![Token::new(TokenKind::Slash, SourceRange::default(), vec!['/'])],
2269      OpAssignOp::Exp => vec![Token::new(TokenKind::Caret, SourceRange::default(), vec!['^'])],
2270      OpAssignOp::Mod => vec![Token::new(TokenKind::Percent, SourceRange::default(), vec!['%'])],
2271      OpAssignOp::Mul => vec![Token::new(TokenKind::Asterisk, SourceRange::default(), vec!['*'])],
2272      OpAssignOp::Sub => vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])],
2273    }
2274  }
2275}
2276
2277#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2278#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2279pub enum RangeOp {
2280  Exclusive,      
2281  Inclusive,
2282}
2283
2284#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2285#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2286pub enum AddSubOp {
2287  Add,
2288  Sub,
2289}
2290
2291#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2292#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2293pub enum MulDivOp {
2294  Div,
2295  Mod,
2296  Mul,
2297}
2298
2299#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2300#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2301pub enum VecOp {
2302  Cross,
2303  Dot,
2304  MatMul,
2305  Solve,
2306}
2307
2308#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2309#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2310pub enum PowerOp {
2311  Pow
2312}
2313
2314#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2315#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2316pub enum ComparisonOp {
2317  Equal,
2318  GreaterThan,
2319  GreaterThanEqual,
2320  LessThan,
2321  LessThanEqual,
2322  NotEqual,
2323  StrictEqual,
2324  StrictNotEqual,
2325}
2326
2327#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2328#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2329pub enum LogicOp {
2330  And,
2331  Not,
2332  Or,
2333  Xor,
2334}
2335
2336#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2337#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2338pub enum FormulaOperator {
2339  AddSub(AddSubOp),
2340  Comparison(ComparisonOp),
2341  Power(PowerOp),
2342  Logic(LogicOp),
2343  MulDiv(MulDivOp),
2344  Vec(VecOp),
2345  Table(TableOp),
2346  Set(SetOp),
2347}
2348
2349#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2350#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2351pub enum TableOp {
2352  InnerJoin,
2353  LeftOuterJoin,
2354  RightOuterJoin	,
2355  FullOuterJoin	,
2356  LeftSemiJoin,  
2357  LeftAntiJoin,
2358}
2359
2360#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2361#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2362pub enum SetOp {
2363  Union,
2364  Intersection,
2365  Difference,
2366  Complement,
2367  ElementOf,
2368  NotElementOf,
2369  ProperSubset,
2370  ProperSuperset,
2371  Subset,
2372  Superset,
2373  SymmetricDifference,
2374}
2375
2376#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2377#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2378pub struct RangeExpression {
2379  pub start: Factor,
2380  pub increment: Option<(RangeOp,Factor)>,
2381  pub operator: RangeOp,
2382  pub terminal: Factor,
2383}
2384
2385impl RangeExpression {
2386  pub fn tokens(&self) -> Vec<Token> {
2387    let mut tokens = self.start.tokens();
2388    tokens.append(&mut self.terminal.tokens());
2389    tokens
2390  }
2391}
2392
2393#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2394#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2395pub struct Term {
2396  pub lhs: Factor,
2397  pub rhs: Vec<(FormulaOperator,Factor)>
2398}
2399
2400impl Term {
2401  pub fn tokens(&self) -> Vec<Token> {
2402    let mut lhs_tkns = self.lhs.tokens();
2403    let mut rhs_tkns = vec![];
2404    for (op, r) in &self.rhs {
2405      let mut tkns = r.tokens();
2406      rhs_tkns.append(&mut tkns);
2407    }
2408    lhs_tkns.append(&mut rhs_tkns);
2409    lhs_tkns
2410  }
2411}
2412
2413#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2414#[derive(Clone, Debug, Hash, PartialEq, Eq)]
2415pub enum Factor {
2416  Expression(Box<Expression>),
2417  Negate(Box<Factor>),
2418  Not(Box<Factor>),
2419  Parenthetical(Box<Factor>),
2420  Term(Box<Term>),
2421  Transpose(Box<Factor>),
2422}
2423
2424impl Factor {
2425  pub fn tokens(&self) -> Vec<Token> {
2426    match self {
2427      Factor::Expression(x) => x.tokens(),
2428      Factor::Negate(x) => x.tokens(),
2429      Factor::Not(x) => x.tokens(),
2430      Factor::Parenthetical(x) => x.tokens(),
2431      Factor::Term(x) => x.tokens(),
2432      Factor::Transpose(x) => x.tokens(),
2433    }
2434  }
2435}
mech_core/nodes.rs

mech_core/
nodes.rs
