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#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
89#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
90pub enum TokenKind {
91  AbstractSigil, Alpha, Ampersand, Any, Apostrophe, AssignOperator, Asterisk, AsyncTransitionOperator, At,
92  Backslash, Bar, BoxDrawing,
93  Caret, CarriageReturn, CarriageReturnNewLine, Colon, CodeBlock, Comma,
94  Dash, DefineOperator, Digit, Dollar,
95  Emoji, EmphasisSigil, Empty, Equal, EquationSigil, Exclamation, 
96  False, FloatLeft, FloatRight, FootnotePrefix,
97  Grave, GraveCodeBlockSigil,
98  HashTag, HighlightSigil, HttpPrefix,
99  Identifier, ImgPrefix, InfoSigil, InlineCode, 
100  LeftAngle, LeftBrace, LeftBracket, LeftParenthesis,
101  Newline, Not, Number,
102  OutputOperator,
103  Percent, Period, Plus,
104  Question, QuestionSigil, Quote, QuoteSigil,
105  RightAngle, RightBrace, RightBracket, RightParenthesis,
106  SectionSigil, Semicolon, Space, Slash, String, StrikeSigil, StrongSigil,
107  Tab, Text, Tilde, TildeCodeBlockSigil, Title, TransitionOperator, True,
108  UnderlineSigil, Underscore,
109}
110
111#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
112#[derive(Clone, Hash, PartialEq, Eq)]
113pub struct Token { 
114  pub kind: TokenKind, 
115  pub chars: Vec<char>, 
116  pub src_range: SourceRange 
117}
118
119impl fmt::Debug for Token {
120  #[inline]
121  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
122    write!(f, "{:?}:{:?}:{:?}", self.kind, String::from_iter(self.chars.iter().cloned()), self.src_range);
123    Ok(())
124  }
125}
126
127impl Default for Token {
128  fn default() -> Self {
129    Token{
130      kind: TokenKind::Empty,
131      chars: vec![],
132      src_range: SourceRange::default(),
133    }
134  }
135}
136
137impl Token {
138
139  pub fn new(kind: TokenKind, src_range: SourceRange, chars: Vec<char>) -> Token {
140    Token{kind, chars, src_range}
141  }
142
143  pub fn to_string(&self) -> String {
144    self.chars.iter().collect()
145  }
146
147  pub fn merge_tokens(tokens: &mut Vec<Token>) -> Option<Token> {
148    if tokens.len() == 0 {
149      None
150    } else if tokens.len() == 1 {
151      Some(tokens[0].clone())
152    } else {
153      let first = tokens[0].src_range.clone();
154      let kind = tokens[0].kind.clone();
155      let last = tokens.last().unwrap().src_range.clone();
156      let src_range = merge_src_range(first, last);
157      let chars: Vec<char> = tokens.iter_mut().fold(vec![],|mut m, ref mut t| {m.append(&mut t.chars.clone()); m});
158      let merged_token = Token{kind, chars, src_range};
159      Some(merged_token)
160    }
161  }
162}
163
164#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
165#[derive(Clone, Debug, Hash, PartialEq, Eq)]
166pub struct TableOfContents {
167    pub title: Option<Title>,
168    pub sections: Vec<Section>,
169}
170
171#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
172#[derive(Clone, Debug, Hash, PartialEq, Eq)]
173pub struct Program {
174  pub title: Option<Title>,
175  pub body: Body,
176}
177
178impl Program {
179  pub fn tokens(&self) -> Vec<Token> {
180    /*let mut title_tokens = match self.title.tokens() {
181      Some(tkns) => tkns,
182      None => vec![],
183    };*/
184    let body_tokens = self.body.tokens();
185    body_tokens
186  }
187
188  pub fn table_of_contents(&self) -> TableOfContents {
189    let mut sections = vec![];
190    for s in &self.body.sections {
191      sections.push(s.table_of_contents());
192    }
193    TableOfContents {
194      title: self.title.clone(),
195      sections,
196    }
197  }
198
199}
200
201#[cfg(feature = "pretty_print")]
202impl PrettyPrint for Program {
203fn pretty_print(&self) -> String {
204    #[cfg(feature = "serde")]
205    let json_string = serde_json::to_string_pretty(self).unwrap();
206    #[cfg(not(feature = "serde"))]
207    let json_string = "Error: Enable Serde to prettt print trees.".to_string();
208
209    let depth = |line: &str|->usize{line.chars().take_while(|&c| c == ' ').count()};
210    let mut result = String::new();
211    let lines: Vec<&str> = json_string.lines().collect();
212    result.push_str("Program\n");
213    for (index, line) in lines.iter().enumerate() {
214      let trm = line.trim();
215      if trm == "}" || 
216         trm == "},"|| 
217         trm == "{" || 
218         trm == "[" || 
219         trm == "],"|| 
220         trm == "]" {
221        continue;
222      }
223  
224      // Count leading spaces to determine depth
225      let d = depth(line);
226      // Construct the tree-like prefix
227      let mut prefix = String::new();
228      for _ in 0..d {
229        prefix.push_str(" ");
230      }
231      if index == lines.len() {
232        prefix.push_str("└ ");
233      } else {
234        if depth(lines[index + 1]) != d {
235          prefix.push_str("└ ");
236        } else {
237          prefix.push_str("├ ");
238        }
239      }
240      let trm = line.trim();
241      let trm = trm.trim_end_matches('{')
242                    .trim_start_matches('"')
243                    .trim_end_matches(':')
244                    .trim_end_matches('"')
245                    .trim_end_matches('[');
246      prefix.push_str(trm);
247  
248      // Append formatted line to result
249      result.push_str(&prefix);
250      result.push('\n');
251      result = result.replace("\":", "");
252    }
253    let mut indexed_str = IndexedString::new(&result);
254    'rows: for i in 0..indexed_str.rows {
255      let rowz = &indexed_str.index_map[i];
256      for j in 0..rowz.len() {
257        let c = match indexed_str.get(i,j) {
258          Some(c) => c,
259          None => continue,
260        };
261        if c == '└' {
262          for k in i+1..indexed_str.rows {
263            match indexed_str.get(k,j) {
264              Some(c2) => {
265                if c2 == '└' {
266                  indexed_str.set(i,j,'├');
267                  for l in i+1..k {
268                    match indexed_str.get(l,j) {
269                      Some(' ') => {indexed_str.set(l,j,'│');},
270                      Some('└') => {indexed_str.set(l,j,'├');},
271                      _ => (),
272                    }
273                  }
274                } else if c2 == ' ' {
275                  continue;
276                } else {
277                  continue 'rows;
278                }
279              },
280              None => continue,
281            }
282  
283          }
284        } else if c == ' ' || c == '│' {
285          continue;
286        } else {
287          continue 'rows;
288        }
289      }
290    }
291    indexed_str.to_string()
292  }
293}
294
295#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
296#[derive(Clone, Debug, Hash, PartialEq, Eq)]
297pub struct Title {
298  pub text: Token,
299}
300
301impl Title {
302
303  pub fn to_string(&self) -> String {
304    self.text.to_string()
305  }
306
307}
308
309#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
310#[derive(Clone, Debug, Hash, PartialEq, Eq)]
311pub struct Body {
312  pub sections: Vec<Section>,
313}
314
315impl Body {
316  pub fn tokens(&self) -> Vec<Token> {
317    let mut out = vec![];
318    for s in &self.sections {
319      let mut tkns = s.tokens();
320      out.append(&mut tkns);
321    }
322    out
323  }
324}
325
326#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
327#[derive(Clone, Debug, Hash, PartialEq, Eq)]
328pub enum ColumnAlignment {
329  Left,
330  Center,
331  Right,
332}
333
334#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
335#[derive(Clone, Debug, Hash, PartialEq, Eq)]
336pub struct MarkdownTable {
337  pub header: Vec<Paragraph>,
338  pub rows: Vec<Vec<Paragraph>>,
339  pub alignment: Vec<ColumnAlignment>,
340}
341
342#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
343#[derive(Clone, Debug, Hash, PartialEq, Eq)]
344pub struct Subtitle {
345  pub text: Paragraph,
346  pub level: u8,
347}
348
349impl Subtitle {
350  pub fn to_string(&self) -> String {
351    self.text.to_string()
352  }
353}
354
355#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
356#[derive(Clone, Debug, Hash, PartialEq, Eq)]
357pub struct Section {
358  pub subtitle: Option<Subtitle>,
359  pub elements: Vec<SectionElement>,
360}
361
362impl Section {
363
364  pub fn table_of_contents(&self) -> Section {
365    let elements: Vec<_> = self.elements.iter()
366      .filter(|e| matches!(e, SectionElement::Subtitle(_)))
367      .cloned()
368      .collect();
369    Section {
370      subtitle: self.subtitle.clone(),
371      elements,
372    }
373  }
374
375  pub fn tokens(&self) -> Vec<Token> {
376    let mut out = vec![];
377    for s in &self.elements {
378      let mut tkns = s.tokens();
379      out.append(&mut tkns);
380    }
381    out
382  }
383}
384
385#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
386#[derive(Clone, Debug, Hash, PartialEq, Eq)]
387pub struct Grammar {
388  pub rules: Vec<Rule>,
389}
390
391#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
392#[derive(Clone, Debug, Hash, PartialEq, Eq)]
393pub struct GrammarIdentifier {
394  pub name: Token,
395}
396
397impl GrammarIdentifier {
398  pub fn tokens(&self) -> Vec<Token> {
399    vec![self.name.clone()]
400  }
401
402  pub fn to_string(&self) -> String {
403    self.name.to_string()
404  }
405}
406
407#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
408#[derive(Clone, Debug, Hash, PartialEq, Eq)]
409pub struct Rule {
410  pub name: GrammarIdentifier,
411  pub expr: GrammarExpression,
412}
413
414#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
415#[derive(Clone, Debug, Hash, PartialEq, Eq)]
416pub enum GrammarExpression {
417  Choice(Vec<GrammarExpression>),
418  Definition(GrammarIdentifier),
419  Group(Box<GrammarExpression>),
420  List(Box<GrammarExpression>, Box<GrammarExpression>),
421  Not(Box<GrammarExpression>),
422  Optional(Box<GrammarExpression>),
423  Peek(Box<GrammarExpression>),
424  Repeat0(Box<GrammarExpression>),
425  Repeat1(Box<GrammarExpression>),
426  Range(Token,Token),
427  Sequence(Vec<GrammarExpression>),
428  Terminal(Token),
429}
430
431#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
432#[derive(Clone, Debug, Hash, PartialEq, Eq)]
433pub struct Citation {
434  pub id: Token,
435  pub text: Paragraph,
436}
437
438impl Citation {
439  pub fn to_string(&self) -> String {
440    format!("[{}]: {}", self.id.to_string(), self.text.to_string())
441  }
442}
443
444// Stores code block configuration
445#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
446#[derive(Clone, Debug, Hash, PartialEq, Eq)]
447pub struct BlockConfig {
448  pub namespace: u64,
449  pub disabled: bool,
450  pub hidden: bool,
451}
452
453pub type Footnote = (Token, Paragraph);
454
455#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
456#[derive(Clone, Debug, Hash, PartialEq, Eq)]
457pub enum FloatDirection {
458  Left,
459  Right,
460}
461
462#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
463#[derive(Clone, Debug, Hash, PartialEq, Eq)]
464pub struct FencedMechCode {
465  pub code: Vec<(MechCode,Option<Comment>)>,
466  pub config: BlockConfig,
467  pub options: Option<OptionMap>,
468}
469
470#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
471#[derive(Clone, Debug, Hash, PartialEq, Eq)]
472pub enum SectionElement {
473  Abstract(Vec<Paragraph>),
474  QuoteBlock(Vec<Paragraph>),
475  InfoBlock(Vec<Paragraph>),
476  QuestionBlock(Vec<Paragraph>),
477  Citation(Citation),
478  CodeBlock(Token),
479  Comment(Comment),
480  Diagram(Token),
481  Equation(Token),
482  FencedMechCode(FencedMechCode),
483  Float((Box<SectionElement>, FloatDirection)),
484  Footnote(Footnote),
485  Grammar(Grammar),
486  Image(Image),
487  List(MDList),
488  MechCode(Vec<(MechCode,Option<Comment>)>),
489  Paragraph(Paragraph),
490  Subtitle(Subtitle),
491  Table(MarkdownTable),
492  ThematicBreak,
493}
494
495impl SectionElement {
496  pub fn tokens(&self) -> Vec<Token> {
497    match self {
498      SectionElement::FencedMechCode(c) => {
499        let mut tokens = vec![];
500        for (c,_) in &c.code {
501          tokens.append(&mut c.tokens());
502        }
503        tokens
504      }
505      SectionElement::MechCode(codes) => {
506        let mut tokens = vec![];
507        for (code,_) in codes {
508          tokens.append(&mut code.tokens());
509        }
510        tokens
511      },
512      _ => todo!(),
513    }
514  }
515}
516
517#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
518#[derive(Clone, Debug, Hash, PartialEq, Eq)]
519pub struct OptionMap {
520  pub elements: Vec<(Identifier, MechString)>,
521}
522
523
524#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
525#[derive(Clone, Debug, Hash, PartialEq, Eq)]
526pub struct Image {
527  pub src: Token,
528  pub caption: Option<Paragraph>,
529  pub style: Option<OptionMap>,
530}
531
532impl Image {
533  pub fn to_string(&self) -> String {
534    let caption = match &self.caption {
535      Some(c) => c.to_string(),
536      None => "".to_string(),
537    };
538    format!("![{}]({})", caption, self.src.to_string())
539  }
540}
541
542pub type UnorderedList = Vec<((Option<Token>,Paragraph),Option<MDList>)>;
543pub type CheckList = Vec<((bool,Paragraph),Option<MDList>)>;
544
545#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
546#[derive(Clone, Debug, Hash, PartialEq, Eq)]
547pub struct OrderedList {
548  pub start: Number,
549  pub items: Vec<((Number,Paragraph),Option<MDList>)>,
550}
551
552#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
553#[derive(Clone, Debug, Hash, PartialEq, Eq)]
554pub enum MDList {
555  Unordered(UnorderedList),
556  Ordered(OrderedList),
557  Check(CheckList)
558}
559
560#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
561#[derive(Clone, Debug, Hash, PartialEq, Eq)]
562pub enum MechCode {
563  Comment(Comment),
564  Expression(Expression),
565  //FsmImplementation(FsmImplementation),
566  //FsmSpecification(FsmSpecification),
567  FunctionDefine(FunctionDefine),
568  Statement(Statement),
569}
570
571impl MechCode {
572  pub fn tokens(&self) -> Vec<Token> {
573    match self {
574      MechCode::Expression(x) => x.tokens(),
575      MechCode::Statement(x) => x.tokens(),
576      _ => todo!(),
577      //FunctionDefine(x) => x.tokens(),
578      //FsmSpecification(x) => x.tokens(),
579      //FsmImplementation(x) => x.tokens(),
580    }
581  }
582}
583
584#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
585#[derive(Clone, Debug, Hash, PartialEq, Eq)]
586pub struct FunctionDefine {
587  pub name: Identifier,
588  pub input: Vec<FunctionArgument>,
589  pub output: Vec<FunctionArgument>,
590  pub statements: Vec<Statement>,
591}
592
593#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
594#[derive(Clone, Debug, Hash, PartialEq, Eq)]
595pub struct FunctionArgument {
596  pub name: Identifier,
597  pub kind: KindAnnotation,
598}
599
600impl FunctionArgument {
601  pub fn tokens(&self) -> Vec<Token> {
602    let mut tokens = self.name.tokens();
603    tokens.append(&mut self.kind.tokens());
604    tokens
605  }
606}
607
608#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
609#[derive(Clone, Debug, Hash, PartialEq, Eq)]
610pub struct FsmImplementation {
611  pub name: Identifier,
612  pub input: Vec<Identifier>,
613  pub start: Pattern,
614  pub arms: Vec<FsmArm>,
615}
616
617#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
618#[derive(Clone, Debug, Hash, PartialEq, Eq)]
619pub enum FsmArm {
620  Guard(Pattern,Vec<Guard>),
621  Transition(Pattern,Vec<Transition>),
622}
623
624#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
625#[derive(Clone, Debug, Hash, PartialEq, Eq)]
626pub struct Guard { 
627  pub condition: Pattern,
628  pub transitions: Vec<Transition>,
629}
630
631#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
632#[derive(Clone, Debug, Hash, PartialEq, Eq)]
633pub enum Transition {
634  Async(Pattern),
635  CodeBlock(Vec<(MechCode, Option<Comment>)>),
636  Next(Pattern),
637  Output(Pattern),
638  Statement(Statement),
639}
640
641#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
642#[derive(Clone, Debug, Hash, PartialEq, Eq)]
643pub enum Pattern {
644  Expression(Expression),
645  Formula(Factor),
646  TupleStruct(PatternTupleStruct),
647  Wildcard,
648}
649
650#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
651#[derive(Clone, Debug, Hash, PartialEq, Eq)]
652pub struct PatternTupleStruct {
653  pub name: Identifier,
654  pub patterns: Vec<Pattern>,
655}
656
657pub type PatternTuple = Vec<Pattern>;
658
659#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
660#[derive(Clone, Debug, Hash, PartialEq, Eq)]
661pub struct FsmSpecification {
662  pub name: Identifier,
663  pub input: Vec<Var>,
664  pub output: Option<KindAnnotation>,
665  pub states: Vec<StateDefinition>,
666}
667
668#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
669#[derive(Clone, Debug, Hash, PartialEq, Eq)]
670pub struct StateDefinition {
671  pub name: Identifier,
672  pub state_variables: Option<Vec<Var>>,
673}
674
675#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
676#[derive(Clone, Debug, Hash, PartialEq, Eq)]
677pub enum Statement {
678  EnumDefine(EnumDefine),
679  //FsmDeclare(FsmDeclare),
680  KindDefine(KindDefine),
681  OpAssign(OpAssign),
682  VariableAssign(VariableAssign),
683  VariableDefine(VariableDefine),
684  TupleDestructure(TupleDestructure),
685  SplitTable,     // todo
686  FlattenTable,   // todo
687}
688
689impl Statement {
690  pub fn tokens(&self) -> Vec<Token> {
691    match self {
692      Statement::EnumDefine(x) => x.tokens(),
693      //Statement::FsmDeclare(x) => x.tokens(),
694      Statement::KindDefine(x) => x.tokens(),
695      Statement::OpAssign(x) => x.tokens(),
696      Statement::VariableAssign(x) => x.tokens(),
697      Statement::VariableDefine(x) => x.tokens(),
698      Statement::TupleDestructure(x) => x.tokens(),
699      Statement::SplitTable => vec![], // todo
700      Statement::FlattenTable => vec![], // todo
701    }
702  }
703}
704
705#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
706#[derive(Clone, Debug, Hash, PartialEq, Eq)]
707pub struct TupleDestructure {
708  pub vars: Vec<Identifier>,
709  pub expression: Expression,
710}
711
712impl TupleDestructure {
713  pub fn tokens(&self) -> Vec<Token> {
714    let mut tokens = vec![];
715    for var in &self.vars {
716      tokens.append(&mut var.tokens());
717    }
718    tokens.append(&mut self.expression.tokens());
719    tokens
720  }
721}
722
723#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
724#[derive(Clone, Debug, Hash, PartialEq, Eq)]
725pub struct FsmPipe {
726  pub start: FsmInstance,
727  pub transitions: Vec<Transition>
728}
729
730#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
731#[derive(Clone, Debug, Hash, PartialEq, Eq)]
732pub enum PipeElement {
733  Expression(Expression),
734  FsmInstance(FsmInstance),
735  Timer // todo
736}
737
738#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
739#[derive(Clone, Debug, Hash, PartialEq, Eq)]
740pub struct FsmDeclare {
741  pub fsm: Fsm,
742  pub pipe: FsmPipe,
743}
744
745#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
746#[derive(Clone, Debug, Hash, PartialEq, Eq)]
747pub struct Fsm {
748  pub name: Identifier,
749  pub args: Option<ArgumentList>,
750  pub kind: Option<KindAnnotation>
751}
752
753pub type FsmArgs = Vec<(Option<Identifier>,Expression)>;
754
755#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
756#[derive(Clone, Debug, Hash, PartialEq, Eq)]
757pub struct FsmInstance {
758  pub name: Identifier,
759  pub args: Option<FsmArgs>,
760}
761
762#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
763#[derive(Clone, Debug, Hash, PartialEq, Eq)]
764pub struct EnumDefine {
765  pub name: Identifier,
766  pub variants: Vec<EnumVariant>,
767}
768
769impl EnumDefine {
770  pub fn tokens(&self) -> Vec<Token> {
771    let mut tokens = self.name.tokens();
772    for v in &self.variants {
773      tokens.append(&mut v.tokens());
774    }
775    tokens
776  }
777}
778
779#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
780#[derive(Clone, Debug, Hash, PartialEq, Eq)]
781pub struct EnumVariant {
782  pub name: Identifier,
783  pub value: Option<KindAnnotation>,
784}
785
786impl EnumVariant {
787  pub fn tokens(&self) -> Vec<Token> {
788    let mut tokens = self.name.tokens();
789    if let Some(value) = &self.value {
790      tokens.append(&mut value.tokens());
791    }
792    tokens
793  }
794}
795
796#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
797#[derive(Clone, Debug, Hash, PartialEq, Eq)]
798pub struct KindDefine {
799  pub name: Identifier,
800  pub kind: KindAnnotation,
801}
802
803impl KindDefine {
804  pub fn tokens(&self) -> Vec<Token> {
805    let mut tokens = self.name.tokens();
806    tokens.append(&mut self.kind.tokens());
807    tokens
808  }
809}
810
811#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
812#[derive(Clone, Debug, Hash, PartialEq, Eq)]
813pub struct Record {
814  pub bindings: Vec<Binding>,
815}
816
817#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
818#[derive(Clone, Debug, Hash, PartialEq, Eq)]
819pub enum Structure {
820  Empty,
821  Map(Map),
822  Matrix(Matrix),
823  Record(Record),
824  Set(Set),
825  Table(Table),
826  Tuple(Tuple),
827  TupleStruct(TupleStruct),
828}
829
830impl Structure {
831  pub fn tokens(&self) -> Vec<Token> {
832    match self {
833      Structure::Matrix(mat) => mat.tokens(),
834      _ => todo!(),
835    }
836  }
837}
838
839#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
840#[derive(Clone, Debug, Hash, PartialEq, Eq)]
841pub struct Map {
842  pub elements: Vec<Mapping>,
843}
844
845#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
846#[derive(Clone, Debug, Hash, PartialEq, Eq)]
847pub struct Mapping {
848  pub key: Expression,
849  pub value: Expression,
850}
851
852#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
853#[derive(Clone, Debug, Hash, PartialEq, Eq)]
854pub struct Set {
855  pub elements: Vec<Expression>,
856}
857
858#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
859#[derive(Clone, Debug, Hash, PartialEq, Eq)]
860pub struct Atom {
861  pub name: Identifier,
862}
863
864#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
865#[derive(Clone, Debug, Hash, PartialEq, Eq)]
866pub struct TupleStruct {
867  pub name: Identifier,
868  pub value: Box<Expression>,
869}
870
871#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
872#[derive(Clone, Debug, Hash, PartialEq, Eq)]
873pub struct Matrix {
874  pub rows: Vec<MatrixRow>,
875}
876
877impl Matrix {
878  pub fn tokens(&self) -> Vec<Token> {
879    let mut tkns = vec![];
880    for r in &self.rows {
881      let mut t = r.tokens();
882      tkns.append(&mut t);
883    }
884    tkns
885  }
886}
887
888pub type TableHeader = Vec<Field>;
889
890#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
891#[derive(Clone, Debug, Hash, PartialEq, Eq)]
892pub struct Table {
893  pub header: TableHeader,
894  pub rows: Vec<TableRow>,
895}
896
897#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
898#[derive(Clone, Debug, Hash, PartialEq, Eq)]
899pub struct Field {
900  pub name: Identifier,
901  pub kind: Option<KindAnnotation>,
902}
903
904#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
905#[derive(Clone, Debug, Hash, PartialEq, Eq)]
906pub struct TableColumn {
907  pub element: Expression,
908}
909
910#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
911#[derive(Clone, Debug, Hash, PartialEq, Eq)]
912pub struct MatrixColumn {
913  pub element: Expression,
914}
915
916impl MatrixColumn {
917  pub fn tokens(&self) -> Vec<Token> {
918    self.element.tokens()
919  }
920}
921
922#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
923#[derive(Clone, Debug, Hash, PartialEq, Eq)]
924pub struct TableRow {
925  pub columns: Vec<TableColumn>,
926}
927
928#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
929#[derive(Clone, Debug, Hash, PartialEq, Eq)]
930pub struct MatrixRow {
931  pub columns: Vec<MatrixColumn>,
932}
933
934impl MatrixRow {
935  pub fn tokens(&self) -> Vec<Token> {
936    let mut tkns = vec![];
937    for r in &self.columns {
938      let mut t = r.tokens();
939      tkns.append(&mut t);
940    }
941    tkns
942  }
943}
944
945#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
946#[derive(Clone, Debug, Hash, PartialEq, Eq)]
947pub struct VariableDefine {
948  pub mutable: bool,
949  pub var: Var,
950  pub expression: Expression,
951}
952
953impl VariableDefine {
954  pub fn tokens(&self) -> Vec<Token> {
955    let mut tkns = self.var.tokens();
956    tkns.append(&mut self.expression.tokens());
957    tkns
958  }
959}
960
961#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
962#[derive(Clone, Debug, Hash, PartialEq, Eq)]
963pub struct Var {
964  pub name: Identifier,
965  pub kind: Option<KindAnnotation>,
966}
967
968impl Var {
969  pub fn tokens(&self) -> Vec<Token> {
970    let mut tkns = self.name.tokens();
971    if let Some(knd) = &self.kind {
972      let mut t = knd.tokens();
973      tkns.append(&mut t);
974    }
975    tkns
976  }
977}
978
979
980#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
981#[derive(Clone, Debug, Hash, PartialEq, Eq)]
982pub struct VariableAssign {
983  pub target: SliceRef,
984  pub expression: Expression,
985}
986
987impl VariableAssign {
988  pub fn tokens(&self) -> Vec<Token> {
989    let mut tkns = self.target.tokens();
990    tkns.append(&mut self.expression.tokens());
991    tkns
992  }
993}
994
995#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
996#[derive(Clone, Debug, Hash, PartialEq, Eq)]
997pub struct Identifier {
998  pub name: Token,
999}
1000
1001impl Identifier {
1002  pub fn tokens(&self) -> Vec<Token> {
1003    vec![self.name.clone()]
1004  }
1005
1006  pub fn to_string(&self) -> String {
1007    self.name.to_string()
1008  }
1009
1010}
1011
1012
1013impl Identifier {
1014  pub fn hash(&self) -> u64 {
1015    hash_chars(&self.name.chars)
1016  }
1017}
1018
1019#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1020#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1021pub struct Emoji {
1022  pub tokens: Vec<Token>,
1023}
1024
1025#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1026#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1027pub struct Word {
1028  pub tokens: Vec<Token>,
1029}
1030
1031#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1032#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1033pub struct Slice {
1034  pub name: Identifier,
1035  pub subscript: Vec<Subscript>
1036}
1037
1038impl Slice {
1039  pub fn tokens(&self) -> Vec<Token> {
1040    let mut tkns = self.name.tokens();
1041    for sub in &self.subscript {
1042      let mut sub_tkns = sub.tokens();
1043      tkns.append(&mut sub_tkns);
1044    }
1045    tkns
1046  }
1047}
1048
1049#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1050#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1051pub struct SliceRef {
1052  pub name: Identifier,
1053  pub subscript: Option<Vec<Subscript>>
1054}
1055
1056impl SliceRef {
1057  pub fn tokens(&self) -> Vec<Token> {
1058    let mut tkns = self.name.tokens();
1059    if let Some(subs) = &self.subscript {
1060      for sub in subs {
1061        let mut sub_tkns = sub.tokens();
1062        tkns.append(&mut sub_tkns);
1063      }
1064    }
1065    tkns
1066  }
1067}
1068
1069#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1070#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1071pub enum Subscript {
1072  All,                      // a[:]
1073  Brace(Vec<Subscript>),    // a{"foo"}
1074  Bracket(Vec<Subscript>),  // a[1,2,3]
1075  Dot(Identifier),          // a.b
1076  DotInt(RealNumber),       // a.1
1077  Formula(Factor),          // a[1 + 1]
1078  Range(RangeExpression),   // a[1 + 1]
1079  Swizzle(Vec<Identifier>), // a.b,c
1080}
1081
1082impl Subscript {
1083
1084  pub fn tokens(&self) -> Vec<Token> {
1085    match self {
1086      Subscript::All => vec![
1087        Token::new(TokenKind::Colon, SourceRange::default(), vec![':']),
1088      ],
1089      Subscript::Brace(subs) => {
1090        let mut tkns = vec![Token::new(TokenKind::LeftBrace, SourceRange::default(), vec!['{'])];
1091        for sub in subs {
1092          let mut sub_tkns = sub.tokens();
1093          tkns.append(&mut sub_tkns);
1094        }
1095        tkns.push(Token::new(TokenKind::RightBrace, SourceRange::default(), vec!['}']));
1096        tkns
1097      },
1098      Subscript::Bracket(subs) => {
1099        let mut tkns = vec![Token::new(TokenKind::LeftBracket, SourceRange::default(), vec!['['])];
1100        for sub in subs {
1101          let mut sub_tkns = sub.tokens();
1102          tkns.append(&mut sub_tkns);
1103        }
1104        tkns.push(Token::new(TokenKind::RightBracket, SourceRange::default(), vec![']']));
1105        tkns
1106      },
1107      Subscript::Dot(id) => id.tokens(),
1108      Subscript::DotInt(num) => num.tokens(),
1109      Subscript::Formula(factor) => factor.tokens(),
1110      Subscript::Range(range) => range.tokens(),
1111      Subscript::Swizzle(ids) => ids.iter().flat_map(|id| id.tokens()).collect(),
1112    }
1113  }
1114}
1115
1116#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1117#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1118pub enum Expression {
1119  Formula(Factor),
1120  FunctionCall(FunctionCall),
1121  //FsmPipe(FsmPipe),
1122  Literal(Literal),
1123  Range(Box<RangeExpression>),
1124  Slice(Slice),
1125  Structure(Structure),
1126  Var(Var),
1127}
1128
1129impl Expression {
1130  pub fn tokens(&self) -> Vec<Token> {
1131    match self {
1132      Expression::Var(v) => v.tokens(),
1133      Expression::Literal(ltrl) => ltrl.tokens(),
1134      Expression::Structure(strct) => strct.tokens(),
1135      Expression::Formula(fctr) => fctr.tokens(),
1136      Expression::Range(range) => range.tokens(),
1137      Expression::Slice(slice) => slice.tokens(),
1138      _ => todo!(),
1139    }
1140  }
1141}
1142
1143pub type ArgumentList = Vec<(Option<Identifier>,Expression)>;
1144
1145#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1146#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1147pub struct FunctionCall {
1148  pub name: Identifier,
1149  pub args: ArgumentList,
1150}
1151
1152impl FunctionCall {
1153  pub fn tokens(&self) -> Vec<Token> {
1154    self.name.tokens()
1155  }
1156}
1157
1158#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1159#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1160pub struct Tuple {
1161  pub elements: Vec<Expression>
1162}
1163
1164#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1165#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1166pub struct Binding {
1167  pub name: Identifier,
1168  pub kind: Option<KindAnnotation>,
1169  pub value: Expression,
1170}
1171
1172#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1173#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1174pub struct KindAnnotation {
1175  pub kind: Kind,
1176}
1177
1178impl KindAnnotation {
1179
1180  pub fn hash(&self) -> u64 {
1181    #[cfg(feature = "no_std")]
1182    let mut hasher = FxHasher::default();
1183    #[cfg(not(feature = "no_std"))]
1184    let mut hasher = std::collections::hash_map::DefaultHasher::new();
1185    self.kind.hash(&mut hasher);
1186    hasher.finish()
1187  }
1188
1189  pub fn tokens(&self) -> Vec<Token> {
1190    self.kind.tokens()
1191  }
1192}
1193
1194#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1195#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1196pub enum Kind {
1197  Any,
1198  Atom(Identifier),
1199  Table((Vec<(Identifier,Kind)>,Box<Literal>)),
1200  Set(Box<Kind>,Option<Box<Literal>>),
1201  Record((Vec<(Identifier,Kind)>)),
1202  Empty,
1203  //Fsm(Vec<Kind>,Vec<Kind>),
1204  //Function(Vec<Kind>,Vec<Kind>),
1205  Map(Box<Kind>,Box<Kind>),
1206  Matrix((Box<Kind>,Vec<Literal>)),
1207  Option(Box<Kind>),
1208  Scalar(Identifier),
1209  Tuple(Vec<Kind>),
1210}
1211
1212impl Kind {
1213  pub fn tokens(&self) -> Vec<Token> {
1214    match self {
1215      Kind::Option(x) => x.tokens(),
1216      Kind::Tuple(x) => x.iter().flat_map(|k| k.tokens()).collect(),
1217      Kind::Matrix((kind, literals)) => {
1218        let mut tokens = kind.tokens();
1219        for l in literals {
1220          tokens.append(&mut l.tokens());
1221        }
1222        tokens
1223      },
1224      Kind::Record(kinds) => {
1225        let mut tokens = vec![];
1226        for (id, kind) in kinds {
1227          tokens.append(&mut id.tokens());
1228          tokens.append(&mut kind.tokens());
1229        }
1230        tokens
1231      }
1232      Kind::Set(kind, size) => {
1233        let mut tokens = kind.tokens();
1234        if let Some(literal) = size {
1235          tokens.append(&mut literal.tokens());
1236        }
1237        tokens
1238      }
1239      Kind::Table((kinds, literal)) => {
1240        let mut tokens = vec![];
1241        for (id, kind) in kinds {
1242          tokens.append(&mut id.tokens());
1243          tokens.append(&mut kind.tokens());
1244        }
1245        tokens.append(&mut literal.tokens());
1246        tokens
1247      }
1248      Kind::Map(x, y) => x.tokens().into_iter().chain(y.tokens()).collect(),
1249      Kind::Scalar(x) => x.tokens(),
1250      Kind::Atom(x) => x.tokens(),
1251      Kind::Empty => vec![],
1252      Kind::Any => vec![],
1253    }
1254  }
1255}
1256
1257#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1258#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1259pub enum Literal {
1260  Atom(Atom),
1261  Boolean(Token),
1262  Empty(Token),
1263  Number(Number),
1264  String(MechString),
1265  Kind(Kind),
1266  TypedLiteral((Box<Literal>,KindAnnotation))
1267}
1268
1269impl Literal {
1270  pub fn tokens(&self) -> Vec<Token> {
1271    match self {
1272      Literal::Atom(atm) => atm.name.tokens(),
1273      Literal::Boolean(tkn) => vec![tkn.clone()],
1274      Literal::Number(x) => x.tokens(),
1275      Literal::String(strng) => vec![strng.text.clone()],
1276      Literal::Empty(tkn) => vec![tkn.clone()],
1277      Literal::Kind(knd) => knd.tokens(),
1278      Literal::TypedLiteral((lit, knd)) => {
1279        let mut tokens = lit.tokens();
1280        tokens.append(&mut knd.tokens());
1281        tokens
1282      }
1283    }
1284  }
1285}
1286
1287#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1288#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1289pub struct MechString {
1290  pub text: Token,
1291}
1292
1293impl MechString {
1294  pub fn to_string(&self) -> String {
1295    self.text.to_string()
1296  }
1297}
1298
1299pub type Hyperlink = (Token, Token);
1300
1301#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1302#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1303pub enum ParagraphElement {
1304  Emphasis(Box<ParagraphElement>),
1305  FootnoteReference(Token),
1306  Highlight(Box<ParagraphElement>),
1307  Hyperlink(Hyperlink),
1308  InlineCode(Token),
1309  EvalInlineMechCode(Expression),
1310  InlineMechCode(MechCode),
1311  InlineEquation(Token),
1312  Reference(Token),
1313  SectionReference(Token),
1314  Strikethrough(Box<ParagraphElement>),
1315  Strong(Box<ParagraphElement>),
1316  Text(Token),
1317  Underline(Box<ParagraphElement>),
1318}
1319
1320impl ParagraphElement {
1321
1322  pub fn to_string(&self) -> String {
1323    match self {
1324      ParagraphElement::Emphasis(t) => t.to_string(),
1325      ParagraphElement::FootnoteReference(t) => t.to_string(),
1326      ParagraphElement::Highlight(t) => t.to_string(),
1327      ParagraphElement::Hyperlink((t, u)) => {
1328        format!("[{}]({})", t.to_string(), u.to_string())
1329      }
1330      ParagraphElement::InlineCode(t) => t.to_string(),
1331      ParagraphElement::InlineEquation(t) => t.to_string(),
1332      ParagraphElement::InlineMechCode(t) => format!("{:?}", t),
1333      ParagraphElement::EvalInlineMechCode(t) => format!("{:?}", t),
1334      ParagraphElement::Reference(t) => t.to_string(),
1335      ParagraphElement::SectionReference(t) => t.to_string(),
1336      ParagraphElement::Strikethrough(t) => t.to_string(),
1337      ParagraphElement::Strong(t) => t.to_string(),
1338      ParagraphElement::Text(t) => t.to_string(),
1339      ParagraphElement::Underline(t) => t.to_string(),
1340    }
1341  }
1342
1343}
1344
1345#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1346#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1347pub struct Paragraph {
1348  pub elements: Vec<ParagraphElement>,
1349}
1350
1351impl Paragraph {
1352  pub fn to_string(&self) -> String {
1353    let mut out = "".to_string();
1354    for e in &self.elements {
1355      out.push_str(&e.to_string());
1356    }
1357    out
1358  }
1359}
1360
1361pub type Sign = bool;
1362pub type Numerator = Token;
1363pub type Denominator = Token;
1364pub type Whole = Token;
1365pub type Part = Token;
1366pub type Real = Box<Number>;
1367pub type Imaginary = Box<Number>;
1368pub type Base = (Whole, Part);
1369pub type Exponent = (Sign, Whole, Part);
1370
1371#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1372#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1373pub enum Number {
1374  Real(RealNumber),
1375  Complex(C64Node),
1376}
1377
1378impl Number {
1379
1380  pub fn from_integer(x: i64) -> Number {
1381    Number::Real(RealNumber::Integer(Token::new(TokenKind::Digit, SourceRange::default(), x.to_string().chars().collect())))
1382  }
1383
1384  pub fn to_string(&self) -> String {
1385    match self {
1386      Number::Real(x) => x.to_string(),
1387      Number::Complex(x) => x.to_string(),
1388    }
1389  }
1390
1391  pub fn tokens(&self) -> Vec<Token> {
1392    match self {
1393      Number::Real(x) => x.tokens(),
1394      Number::Complex(x) => x.tokens(),
1395    }
1396  }
1397}
1398
1399#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1400#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1401pub enum RealNumber {
1402  Binary(Token),
1403  Decimal(Token),
1404  Float((Whole,Part)),
1405  Hexadecimal(Token),
1406  Integer(Token),
1407  Negated(Box<RealNumber>),
1408  Octal(Token),
1409  Rational((Numerator,Denominator)),
1410  Scientific((Base,Exponent)),
1411}
1412
1413impl RealNumber {
1414  pub fn tokens(&self) -> Vec<Token> {
1415    match self {
1416      RealNumber::Integer(tkn) => vec![tkn.clone()],
1417      _ => todo!(),
1418    }
1419  }
1420  pub fn to_string(&self) -> String {
1421    match self {
1422      RealNumber::Integer(tkn) => tkn.to_string(),
1423      RealNumber::Float((whole, part)) => format!("{}.{}", whole.to_string(), part.to_string()),
1424      RealNumber::Binary(tkn) => format!("0b{}", tkn.to_string()),
1425      RealNumber::Hexadecimal(tkn) => format!("0x{}", tkn.to_string()),
1426      RealNumber::Octal(tkn) => format!("0o{}", tkn.to_string()),
1427      RealNumber::Decimal(tkn) => format!("0d{}", tkn.to_string()),
1428      RealNumber::Rational((num, den)) => format!("{}/{}", num.to_string(), den.to_string()),
1429      RealNumber::Scientific(((whole,part), exponent)) => {
1430        let (sign, whole, part) = exponent;
1431        let sign_str = if *sign { "+" } else { "-" };
1432        let whole_str = whole.to_string();
1433        let part_str = part.to_string();
1434        format!("{}{}.{}/10^{}", whole.to_string(), part.to_string(), sign_str, whole_str)
1435      }
1436      RealNumber::Negated(x) => format!("-{}", x.to_string()),
1437    }
1438  }
1439}
1440
1441#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1442#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1443pub struct ImaginaryNumber {
1444  pub number: RealNumber,
1445}
1446
1447#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1448#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1449pub struct C64Node {
1450  pub real: Option<RealNumber>,
1451  pub imaginary: ImaginaryNumber
1452}
1453
1454impl C64Node {
1455  pub fn tokens(&self) -> Vec<Token> {
1456    let mut tkns = vec![];
1457    if let Some(r) = &self.real {
1458      tkns.append(&mut r.tokens());
1459    }
1460    tkns.append(&mut self.imaginary.number.tokens());
1461    tkns
1462  }
1463
1464  pub fn to_string(&self) -> String {
1465    let mut out = "".to_string();
1466    if let Some(r) = &self.real {
1467      out.push_str(&r.to_string());
1468    }
1469    out.push_str("i");
1470    out
1471  }
1472}
1473
1474#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1475#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1476pub struct Comment {
1477  pub paragraph: Paragraph,
1478}
1479
1480#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1481#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1482pub struct OpAssign {
1483  pub target: SliceRef,
1484  pub op: OpAssignOp,
1485  pub expression: Expression,
1486}
1487
1488impl OpAssign {
1489  pub fn tokens(&self) -> Vec<Token> {
1490    let mut tkns = self.target.tokens();
1491    tkns.append(&mut self.op.tokens());
1492    tkns.append(&mut self.expression.tokens());
1493    tkns
1494  }
1495}
1496
1497#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1498#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1499pub enum OpAssignOp {
1500  Add,
1501  Div,
1502  Exp, 
1503  Mod,  
1504  Mul,
1505  Sub,   
1506}
1507
1508impl OpAssignOp {
1509  pub fn tokens(&self) -> Vec<Token> {
1510    match self {
1511      OpAssignOp::Add => vec![Token::new(TokenKind::Plus, SourceRange::default(), vec!['+'])],
1512      OpAssignOp::Div => vec![Token::new(TokenKind::Slash, SourceRange::default(), vec!['/'])],
1513      OpAssignOp::Exp => vec![Token::new(TokenKind::Caret, SourceRange::default(), vec!['^'])],
1514      OpAssignOp::Mod => vec![Token::new(TokenKind::Percent, SourceRange::default(), vec!['%'])],
1515      OpAssignOp::Mul => vec![Token::new(TokenKind::Asterisk, SourceRange::default(), vec!['*'])],
1516      OpAssignOp::Sub => vec![Token::new(TokenKind::Dash, SourceRange::default(), vec!['-'])],
1517    }
1518  }
1519}
1520
1521#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1522#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1523pub enum RangeOp {
1524  Exclusive,      
1525  Inclusive,
1526}
1527
1528#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1529#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1530pub enum AddSubOp {
1531  Add,
1532  Sub,
1533}
1534
1535#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1536#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1537pub enum MulDivOp {
1538  Div,
1539  Mod,
1540  Mul,
1541}
1542
1543#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1544#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1545pub enum VecOp {
1546  Cross,
1547  Dot,
1548  MatMul,
1549  Solve,
1550}
1551
1552#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1553#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1554pub enum ExponentOp {
1555  Exp
1556}
1557
1558#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1559#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1560pub enum ComparisonOp {
1561  Equal,
1562  GreaterThan,
1563  GreaterThanEqual,
1564  LessThan,
1565  LessThanEqual,
1566  NotEqual,
1567  StrictEqual,
1568  StrictNotEqual,
1569}
1570
1571#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1572#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1573pub enum LogicOp {
1574  And,
1575  Not,
1576  Or,
1577  Xor,
1578}
1579
1580#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1581#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1582pub enum FormulaOperator {
1583  AddSub(AddSubOp),
1584  Comparison(ComparisonOp),
1585  Exponent(ExponentOp),
1586  Logic(LogicOp),
1587  MulDiv(MulDivOp),
1588  Vec(VecOp),
1589  Table(TableOp),
1590  Set(SetOp),
1591}
1592
1593#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1594#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1595pub enum TableOp {
1596  InnerJoin,
1597  LeftOuterJoin,
1598  RightOuterJoin	,
1599  FullOuterJoin	,
1600  LeftSemiJoin,  
1601  LeftAntiJoin,
1602}
1603
1604#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1605#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1606pub enum SetOp {
1607  Union,
1608  Intersection,
1609  Difference,
1610  Complement,
1611  Subset,
1612  Superset,
1613  ProperSubset,
1614  ProperSuperset,
1615  ElementOf,
1616  NotElementOf,
1617}
1618
1619#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1620#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1621pub struct RangeExpression {
1622  pub start: Factor,
1623  pub increment: Option<(RangeOp,Factor)>,
1624  pub operator: RangeOp,
1625  pub terminal: Factor,
1626}
1627
1628impl RangeExpression {
1629  pub fn tokens(&self) -> Vec<Token> {
1630    let mut tokens = self.start.tokens();
1631    tokens.append(&mut self.terminal.tokens());
1632    tokens
1633  }
1634}
1635
1636#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1637#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1638pub struct Term {
1639  pub lhs: Factor,
1640  pub rhs: Vec<(FormulaOperator,Factor)>
1641}
1642
1643impl Term {
1644  pub fn tokens(&self) -> Vec<Token> {
1645    let mut lhs_tkns = self.lhs.tokens();
1646    let mut rhs_tkns = vec![];
1647    for (op, r) in &self.rhs {
1648      let mut tkns = r.tokens();
1649      rhs_tkns.append(&mut tkns);
1650    }
1651    lhs_tkns.append(&mut rhs_tkns);
1652    lhs_tkns
1653  }
1654}
1655
1656#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
1657#[derive(Clone, Debug, Hash, PartialEq, Eq)]
1658pub enum Factor {
1659  Expression(Box<Expression>),
1660  Negate(Box<Factor>),
1661  Not(Box<Factor>),
1662  Parenthetical(Box<Factor>),
1663  Term(Box<Term>),
1664  Transpose(Box<Factor>),
1665}
1666
1667impl Factor {
1668  pub fn tokens(&self) -> Vec<Token> {
1669    match self {
1670      Factor::Expression(x) => x.tokens(),
1671      Factor::Negate(x) => x.tokens(),
1672      Factor::Not(x) => x.tokens(),
1673      Factor::Parenthetical(x) => x.tokens(),
1674      Factor::Term(x) => x.tokens(),
1675      Factor::Transpose(x) => x.tokens(),
1676    }
1677  }
1678}
mech_core/nodes.rs

mech_core/
nodes.rs
