comparing 38ff1c1ed25f8272c37a99d70e89cbbd80d04e44 and main on drubery.com/icfp2007

+1 -1

.gitignore

···

       1
       1
        
       task/endo.dna

     

       2
       2
        
       .tup/

     

       3
       3
       -
       out/
     

       3
       3
       +
       /out/

-13

Tupfile

···

       1
       1
       -
       RUSTC_FLAGS= --edition=2024 --crate-type bin --emit=link -C opt-level=3 -C embed-bitcode=no --check-cfg 'cfg (docsrs,test)' --check-cfg 'cfg(feature, values())' --out-dir out/bin -C strip=debuginfo -L dependency=out/bin

     

       2
       2
       -
       

     

       3
       3
       -
       : dna2rna/src/*.rs |> rustc --crate-name dna2rna dna2rna/src/main.rs $(RUSTC_FLAGS) |> out/bin/dna2rna

     

       4
       4
       -
       : rna2bmp/src/*.rs |> rustc --crate-name rna2bmp rna2bmp/src/main.rs $(RUSTC_FLAGS) |> out/bin/rna2bmp

     

       5
       5
       -
       : asm2dna/src/*.rs |> rustc --crate-name asm2dna asm2dna/src/main.rs $(RUSTC_FLAGS) |> out/bin/asm2dna

     

       6
       6
       -
       

     

       7
       7
       -
       : foreach asm/*.asm | out/bin/asm2dna |> ./out/bin/asm2dna %f out/dna/%B.dna |> out/dna/%B.dna

     

       8
       8
       -
       

     

       9
       9
       -
       : foreach out/dna/*.dna | out/bin/dna2rna |> ./out/bin/dna2rna %f task/endo.dna out/rna/%B.rna |> out/rna/%B.rna

     

       10
       10
       -
       

     

       11
       11
       -
       : foreach out/rna/*.rna | out/bin/rna2bmp |> ./out/bin/rna2bmp %f out/bmp/%B.bmp |> out/bmp/%B.bmp

     

       12
       12
       -
       

     

       13
       13
       -
       : foreach out/bmp/*.bmp |> convert %f out/png/%B.png |> out/png/%B.png

+64

Tupfile.lua

···

       1
       1
       +
       function define_rust_rule(name, type, deps)

     

       2
       2
       +
           local inputs = {}

     

       3
       3
       +
           for _, input in ipairs(tup.glob(name .. "/src/*.rs")) do

     

       4
       4
       +
       	table.insert(inputs, input)

     

       5
       5
       +
           end

     

       6
       6
       +
       

     

       7
       7
       +
           local input_rs

     

       8
       8
       +
           local output

     

       9
       9
       +
           if type == "bin" then

     

       10
       10
       +
               input_rs = name .. "/src/main.rs"

     

       11
       11
       +
       	output = "out/bin/" .. name

     

       12
       12
       +
           else

     

       13
       13
       +
               input_rs = name .. "/src/lib.rs"

     

       14
       14
       +
       	output = "out/lib/lib" .. name .. ".rlib"

     

       15
       15
       +
           end

     

       16
       16
       +
           

     

       17
       17
       +
           local externs = {}

     

       18
       18
       +
           for _, dep in ipairs(deps) do

     

       19
       19
       +
               local rlib = "out/lib/lib" .. dep .. ".rlib"

     

       20
       20
       +
               table.insert(inputs, rlib)

     

       21
       21
       +
       	table.insert(externs, "--extern " .. dep .. "=" .. rlib)

     

       22
       22
       +
           end

     

       23
       23
       +
       

     

       24
       24
       +
           local flags = "--edition=2024 -C opt-level=3 -C embed-bitcode=no -C strip=debuginfo --emit=link"

     

       25
       25
       +
           local command = "rustc --crate-name " .. name .. " --crate-type=" .. type .. " " .. input_rs .. " -o %o " .. table.concat(externs, " ") .. " " .. flags

     

       26
       26
       +
           tup.definerule{inputs = inputs, command = command, outputs = {output}}

     

       27
       27
       +
       end

     

       28
       28
       +
       

     

       29
       29
       +
       define_rust_rule("dna_parsing", "lib", {})

     

       30
       30
       +
       define_rust_rule("dna2rna", "bin", {"dna_parsing"})

     

       31
       31
       +
       define_rust_rule("disassembler", "bin", {"dna_parsing"})

     

       32
       32
       +
       define_rust_rule("rna2bmp", "bin", {})

     

       33
       33
       +
       define_rust_rule("asm2dna", "bin", {})

     

       34
       34
       +
       

     

       35
       35
       +
       local asm = tup.glob("asm/*.asm")

     

       36
       36
       +
       asm.extra_inputs = {"out/bin/asm2dna"}

     

       37
       37
       +
       tup.foreach_rule(

     

       38
       38
       +
         asm,

     

       39
       39
       +
         "./out/bin/asm2dna %f %o",

     

       40
       40
       +
         {"out/dna/%B.dna"}

     

       41
       41
       +
       )

     

       42
       42
       +
       

     

       43
       43
       +
       local dna = tup.glob("out/dna/*.dna")

     

       44
       44
       +
       dna.extra_inputs = {"out/bin/dna2rna"}

     

       45
       45
       +
       tup.foreach_rule(

     

       46
       46
       +
         dna,

     

       47
       47
       +
         "./out/bin/dna2rna %f task/endo.dna %o",

     

       48
       48
       +
         {"out/rna/%B.rna"}

     

       49
       49
       +
       )

     

       50
       50
       +
       

     

       51
       51
       +
       local rna = tup.glob("out/rna/*.rna")

     

       52
       52
       +
       rna.extra_inputs = {"out/bin/rna2bmp"}

     

       53
       53
       +
       tup.foreach_rule(

     

       54
       54
       +
         rna,

     

       55
       55
       +
         "./out/bin/rna2bmp %f %o",

     

       56
       56
       +
         {"out/bmp/%B.bmp"}

     

       57
       57
       +
       )

     

       58
       58
       +
       

     

       59
       59
       +
       local bmp = tup.glob("out/bmp/*.bmp")

     

       60
       60
       +
       tup.foreach_rule(

     

       61
       61
       +
         bmp,

     

       62
       62
       +
         "convert %f %o",

     

       63
       63
       +
         {"out/png/%B.png"}

     

       64
       64
       +
       )

disassembler/.dir-locals.el

···

       1
       1
       +
       ((nil . ((default-directory . "~/repos/endo/disassembler/"))))

+14

disassembler/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "disassembler"

     

       7
       7
       +
       version = "0.1.0"

     

       8
       8
       +
       dependencies = [

     

       9
       9
       +
        "dna_parsing",

     

       10
       10
       +
       ]

     

       11
       11
       +
       

     

       12
       12
       +
       [[package]]

     

       13
       13
       +
       name = "dna_parsing"

     

       14
       14
       +
       version = "0.1.0"

disassembler/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "disassembler"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

     

       7
       7
       +
       dna_parsing = { path = "../dna_parsing" }

+69

disassembler/src/main.rs

···

       1
       1
       +
       use dna_parsing::base::Base;

     

       2
       2
       +
       use dna_parsing::parser::Parser;

     

       3
       3
       +
       use std::env;

     

       4
       4
       +
       use std::fs;

     

       5
       5
       +
       use std::io;

     

       6
       6
       +
       use std::io::Write;

     

       7
       7
       +
       

     

       8
       8
       +
       fn main() {

     

       9
       9
       +
           let args: Vec<String> = env::args().collect();

     

       10
       10
       +
           if args.len() < 3 {

     

       11
       11
       +
               println!("Usage: {} <dna file> <offset>", args[0]);

     

       12
       12
       +
               return;

     

       13
       13
       +
           }

     

       14
       14
       +
       

     

       15
       15
       +
           let Ok(dna) = fs::read_to_string(&args[1]) else {

     

       16
       16
       +
               println!("Failed to read dna file at {}", &args[1]);

     

       17
       17
       +
               return;

     

       18
       18
       +
           };

     

       19
       19
       +
           let Ok(offset): Result<usize, _> = args[2].parse() else {

     

       20
       20
       +
               println!("Failed to parse offset {}", &args[2]);

     

       21
       21
       +
               return;

     

       22
       22
       +
           };

     

       23
       23
       +
       

     

       24
       24
       +
           let mut index = 0;

     

       25
       25
       +
           loop {

     

       26
       26
       +
               print!("> ");

     

       27
       27
       +
               let _ = io::stdout().flush();

     

       28
       28
       +
               let mut line = String::new();

     

       29
       29
       +
               if !io::stdin().read_line(&mut line).is_ok() {

     

       30
       30
       +
                   println!("Failed to read response line");

     

       31
       31
       +
                   return;

     

       32
       32
       +
               }

     

       33
       33
       +
               line = line.trim().to_string();

     

       34
       34
       +
               if !line.is_empty() {

     

       35
       35
       +
                   let Ok(new_index): Result<usize, _> = line.parse() else {

     

       36
       36
       +
                       println!("Failed to parse {}", line);

     

       37
       37
       +
                       continue;

     

       38
       38
       +
                   };

     

       39
       39
       +
                   index = new_index;

     

       40
       40
       +
               }

     

       41
       41
       +
       

     

       42
       42
       +
               let mut parser = Parser::new(

     

       43
       43
       +
                   dna[index + offset..]

     

       44
       44
       +
                       .chars()

     

       45
       45
       +
                       .filter_map(|c| Base::from_char(c)),

     

       46
       46
       +
               );

     

       47
       47
       +
               let mut rna = Vec::new();

     

       48
       48
       +
               let Some(pattern) = parser.pattern(&mut rna) else {

     

       49
       49
       +
                   println!("Failed to parse pattern");

     

       50
       50
       +
                   continue;

     

       51
       51
       +
               };

     

       52
       52
       +
               let Some(template) = parser.template(&mut rna) else {

     

       53
       53
       +
                   println!("Failed to parse template");

     

       54
       54
       +
                   continue;

     

       55
       55
       +
               };

     

       56
       56
       +
       

     

       57
       57
       +
               if !rna.is_empty() {

     

       58
       58
       +
                   println!("RNA output:");

     

       59
       59
       +
                   for r in rna.iter() {

     

       60
       60
       +
                       let rna_str: String = r.iter().map(|b| b.to_char()).collect();

     

       61
       61
       +
                       println!("    {}", rna_str);

     

       62
       62
       +
                   }

     

       63
       63
       +
                   println!();

     

       64
       64
       +
               }

     

       65
       65
       +
               println!("{} ; {} ;", pattern, template);

     

       66
       66
       +
               index += parser.index();

     

       67
       67
       +
               println!("Now at: {}", index);

     

       68
       68
       +
           }

     

       69
       69
       +
       }

dna2rna/Cargo.lock

···

       5
       5
        
       [[package]]

     

       6
       6
        
       name = "dna2rna"

     

       7
       7
        
       version = "0.1.0"

     

       8
       8
       +
       dependencies = [

     

       9
       9
       +
        "dna_parsing",

     

       10
       10
       +
       ]

     

       11
       11
       +
       

     

       12
       12
       +
       [[package]]

     

       13
       13
       +
       name = "dna_parsing"

     

       14
       14
       +
       version = "0.1.0"

dna2rna/Cargo.toml

···

       4
       4
        
       edition = "2024"

     

       5
       5
        
       

     

       6
       6
        
       [dependencies]

     

       7
       7
       +
       dna_parsing = { path = "../dna_parsing" }

+1 -29

dna2rna/src/dna.rs

···

       1
       1
       +
       use dna_parsing::base::Base;

     

       1
       2
        
       use std::collections::VecDeque;

     

       2
       3
        
       use std::ops::Add;

     

       3
       4
        
       use std::ops::AddAssign;

     

       4
       5
        
       use std::ops::Deref;

     

       5
       6
        
       use std::ops::Index;

     

       6
       7
        
       use std::rc::Rc;

     

       7
       7
       -
       

     

       8
       8
       -
       #[derive(Copy, Clone, PartialEq, Debug)]

     

       9
       9
       -
       pub enum Base {

     

       10
       10
       -
           I,

     

       11
       11
       -
           C,

     

       12
       12
       -
           F,

     

       13
       13
       -
           P,

     

       14
       14
       -
       }

     

       15
       8
        
       

     

       16
       9
        
       #[derive(Clone, Debug)]

     

       17
       10
        
       pub enum Dna {

     
···

       39
       32
        
           len: usize,

     

       40
       33
        
           depth: usize,

     

       41
       34
        
           children: (DnaRef, DnaRef, DnaRef),

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       impl Base {

     

       45
       45
       -
           pub fn from_char(c: char) -> Option<Base> {

     

       46
       46
       -
               match c {

     

       47
       47
       -
                   'I' => Some(Base::I),

     

       48
       48
       -
                   'C' => Some(Base::C),

     

       49
       49
       -
                   'F' => Some(Base::F),

     

       50
       50
       -
                   'P' => Some(Base::P),

     

       51
       51
       -
                   _ => None,

     

       52
       52
       -
               }

     

       53
       53
       -
           }

     

       54
       54
       -
       

     

       55
       55
       -
           pub fn to_char(&self) -> char {

     

       56
       56
       -
               match self {

     

       57
       57
       -
                   Base::I => 'I',

     

       58
       58
       -
                   Base::C => 'C',

     

       59
       59
       -
                   Base::F => 'F',

     

       60
       60
       -
                   Base::P => 'P',

     

       61
       61
       -
               }

     

       62
       62
       -
           }

     

       63
       35
        
       }

     

       64
       36
        
       

     

       65
       37
        
       impl DnaRef {

-4

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
        
       mod match_replace;

     

       3
       3
       -
       mod parser;

     

       4
       4
       -
       mod pattern;

     

       5
       5
       -
       mod rna;

     

       6
       6
       -
       mod template;

     

       7
       3
        
       

     

       8
       4
        
       use std::env;

     

       9
       5
        
       use std::fs;

+6 -6

dna2rna/src/match_replace.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       1
        
       use crate::dna::DnaRef;

     

       3
       3
       -
       use crate::parser::Parser;

     

       4
       4
       -
       use crate::pattern::Pattern;

     

       5
       5
       -
       use crate::pattern::PatternItem;

     

       6
       6
       -
       use crate::rna::Rna;

     

       7
       7
       -
       use crate::template::TemplateItem;

     

       2
       2
       +
       use dna_parsing::base::Base;

     

       3
       3
       +
       use dna_parsing::parser::Parser;

     

       4
       4
       +
       use dna_parsing::pattern::Pattern;

     

       5
       5
       +
       use dna_parsing::pattern::PatternItem;

     

       6
       6
       +
       use dna_parsing::rna::Rna;

     

       7
       7
       +
       use dna_parsing::template::TemplateItem;

     

       8
       8
        
       

     

       9
       9
        
       struct MatchResult {

     

       10
       10
        
           end: usize,

-315

dna2rna/src/parser.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       2
       -
       use crate::pattern::Pattern;

     

       3
       3
       -
       use crate::pattern::PatternItem;

     

       4
       4
       -
       use crate::rna::Rna;

     

       5
       5
       -
       use crate::template::Template;

     

       6
       6
       -
       use crate::template::TemplateItem;

     

       7
       7
       -
       use std::mem;

     

       8
       8
       -
       

     

       9
       9
       -
       pub struct Parser<I>

     

       10
       10
       -
       where

     

       11
       11
       -
           I: Iterator<Item = Base>,

     

       12
       12
       -
       {

     

       13
       13
       -
           iter: I,

     

       14
       14
       -
           peeked: Vec<Base>,

     

       15
       15
       -
           index: usize,

     

       16
       16
       -
       }

     

       17
       17
       -
       

     

       18
       18
       -
       impl<I> Parser<I>

     

       19
       19
       -
       where

     

       20
       20
       -
           I: Iterator<Item = Base>,

     

       21
       21
       -
       {

     

       22
       22
       -
           pub fn new(iter: I) -> Parser<I> {

     

       23
       23
       -
               Parser {

     

       24
       24
       -
                   iter: iter,

     

       25
       25
       -
                   peeked: Vec::new(),

     

       26
       26
       -
                   index: 0,

     

       27
       27
       -
               }

     

       28
       28
       -
           }

     

       29
       29
       -
       

     

       30
       30
       -
           pub fn index(&self) -> usize {

     

       31
       31
       -
               self.index

     

       32
       32
       -
           }

     

       33
       33
       -
       

     

       34
       34
       -
           fn peek_to(&mut self, n: usize) {

     

       35
       35
       -
               while self.peeked.len() < n {

     

       36
       36
       -
                   if let Some(b) = self.iter.next() {

     

       37
       37
       -
                       self.peeked.push(b);

     

       38
       38
       -
                   } else {

     

       39
       39
       -
                       return;

     

       40
       40
       -
                   }

     

       41
       41
       -
               }

     

       42
       42
       -
           }

     

       43
       43
       -
       

     

       44
       44
       -
           pub fn next_is(&mut self, next: &[Base]) -> bool {

     

       45
       45
       -
               self.peek_to(next.len());

     

       46
       46
       -
               if self.peeked.len() < next.len() {

     

       47
       47
       -
                   return false;

     

       48
       48
       -
               }

     

       49
       49
       -
               return &self.peeked[..next.len()] == next;

     

       50
       50
       -
           }

     

       51
       51
       -
       

     

       52
       52
       -
           pub fn advance(&mut self, n: usize) {

     

       53
       53
       -
               self.peek_to(n);

     

       54
       54
       -
               self.index += n;

     

       55
       55
       -
               self.peeked.drain(..n);

     

       56
       56
       -
           }

     

       57
       57
       -
       

     

       58
       58
       -
           pub fn nat(&mut self) -> Option<usize> {

     

       59
       59
       -
               let mut ret = 0;

     

       60
       60
       -
               let mut bit = 1;

     

       61
       61
       -
               loop {

     

       62
       62
       -
                   if self.next_is(&[Base::P]) {

     

       63
       63
       -
                       self.advance(1);

     

       64
       64
       -
                       return Some(ret);

     

       65
       65
       -
                   } else if self.next_is(&[Base::I]) || self.next_is(&[Base::F]) {

     

       66
       66
       -
                       self.advance(1);

     

       67
       67
       -
                   } else if self.next_is(&[Base::C]) {

     

       68
       68
       -
                       ret += bit;

     

       69
       69
       -
                       self.advance(1);

     

       70
       70
       -
                   } else {

     

       71
       71
       -
                       return None;

     

       72
       72
       -
                   }

     

       73
       73
       -
       

     

       74
       74
       -
                   bit *= 2;

     

       75
       75
       -
               }

     

       76
       76
       -
           }

     

       77
       77
       -
       

     

       78
       78
       -
           pub fn consts(&mut self) -> Vec<Base> {

     

       79
       79
       -
               let mut ret = Vec::new();

     

       80
       80
       -
               loop {

     

       81
       81
       -
                   if self.next_is(&[Base::C]) {

     

       82
       82
       -
                       self.advance(1);

     

       83
       83
       -
                       ret.push(Base::I);

     

       84
       84
       -
                   } else if self.next_is(&[Base::F]) {

     

       85
       85
       -
                       self.advance(1);

     

       86
       86
       -
                       ret.push(Base::C);

     

       87
       87
       -
                   } else if self.next_is(&[Base::P]) {

     

       88
       88
       -
                       self.advance(1);

     

       89
       89
       -
                       ret.push(Base::F);

     

       90
       90
       -
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       91
       91
       -
                       self.advance(2);

     

       92
       92
       -
                       ret.push(Base::P);

     

       93
       93
       -
                   } else {

     

       94
       94
       -
                       return ret;

     

       95
       95
       -
                   }

     

       96
       96
       -
               }

     

       97
       97
       -
           }

     

       98
       98
       -
       

     

       99
       99
       -
           pub fn pattern(&mut self, rna: &mut Vec<Rna>) -> Option<Pattern> {

     

       100
       100
       -
               let mut ret = Vec::new();

     

       101
       101
       -
               let mut level = 0;

     

       102
       102
       -
               loop {

     

       103
       103
       -
                   if self.next_is(&[Base::C]) {

     

       104
       104
       -
                       self.advance(1);

     

       105
       105
       -
                       ret.push(PatternItem::Base(Base::I));

     

       106
       106
       -
                   } else if self.next_is(&[Base::F]) {

     

       107
       107
       -
                       self.advance(1);

     

       108
       108
       -
                       ret.push(PatternItem::Base(Base::C));

     

       109
       109
       -
                   } else if self.next_is(&[Base::P]) {

     

       110
       110
       -
                       self.advance(1);

     

       111
       111
       -
                       ret.push(PatternItem::Base(Base::F));

     

       112
       112
       -
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       113
       113
       -
                       self.advance(2);

     

       114
       114
       -
                       ret.push(PatternItem::Base(Base::P));

     

       115
       115
       -
                   } else if self.next_is(&[Base::I, Base::P]) {

     

       116
       116
       -
                       self.advance(2);

     

       117
       117
       -
                       let n = self.nat()?;

     

       118
       118
       -
                       ret.push(PatternItem::Skip(n));

     

       119
       119
       -
                   } else if self.next_is(&[Base::I, Base::F]) {

     

       120
       120
       -
                       self.advance(3);

     

       121
       121
       -
                       let s = self.consts();

     

       122
       122
       -
                       ret.push(PatternItem::Search(s));

     

       123
       123
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::P]) {

     

       124
       124
       -
                       self.advance(3);

     

       125
       125
       -
                       level += 1;

     

       126
       126
       -
                       ret.push(PatternItem::Open);

     

       127
       127
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::C])

     

       128
       128
       -
                       || self.next_is(&[Base::I, Base::I, Base::F])

     

       129
       129
       -
                   {

     

       130
       130
       -
                       self.advance(3);

     

       131
       131
       -
                       if level == 0 {

     

       132
       132
       -
                           return Some(Pattern::new(ret));

     

       133
       133
       -
                       }

     

       134
       134
       -
                       level -= 1;

     

       135
       135
       -
                       ret.push(PatternItem::Close);

     

       136
       136
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       137
       137
       -
                       self.advance(3);

     

       138
       138
       -
                       self.peek_to(7);

     

       139
       139
       -
                       let mut r = Vec::new();

     

       140
       140
       -
                       mem::swap(&mut r, &mut self.peeked);

     

       141
       141
       -
                       rna.push(r.try_into().unwrap());

     

       142
       142
       -
                       self.index += 7;

     

       143
       143
       -
                   } else {

     

       144
       144
       -
                       return None;

     

       145
       145
       -
                   }

     

       146
       146
       -
               }

     

       147
       147
       -
           }

     

       148
       148
       -
       

     

       149
       149
       -
           pub fn template(&mut self, rna: &mut Vec<Rna>) -> Option<Template> {

     

       150
       150
       -
               let mut ret = Vec::new();

     

       151
       151
       -
               loop {

     

       152
       152
       -
                   if self.next_is(&[Base::C]) {

     

       153
       153
       -
                       self.advance(1);

     

       154
       154
       -
                       ret.push(TemplateItem::Base(Base::I));

     

       155
       155
       -
                   } else if self.next_is(&[Base::F]) {

     

       156
       156
       -
                       self.advance(1);

     

       157
       157
       -
                       ret.push(TemplateItem::Base(Base::C));

     

       158
       158
       -
                   } else if self.next_is(&[Base::P]) {

     

       159
       159
       -
                       self.advance(1);

     

       160
       160
       -
                       ret.push(TemplateItem::Base(Base::F));

     

       161
       161
       -
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       162
       162
       -
                       self.advance(2);

     

       163
       163
       -
                       ret.push(TemplateItem::Base(Base::P));

     

       164
       164
       -
                   } else if self.next_is(&[Base::I, Base::P]) || self.next_is(&[Base::I, Base::F]) {

     

       165
       165
       -
                       self.advance(2);

     

       166
       166
       -
                       let l = self.nat()?;

     

       167
       167
       -
                       let n = self.nat()?;

     

       168
       168
       -
                       ret.push(TemplateItem::Ref(n, l));

     

       169
       169
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::C])

     

       170
       170
       -
                       || self.next_is(&[Base::I, Base::I, Base::F])

     

       171
       171
       -
                   {

     

       172
       172
       -
                       self.advance(3);

     

       173
       173
       -
                       return Some(Template::new(ret));

     

       174
       174
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::P]) {

     

       175
       175
       -
                       self.advance(3);

     

       176
       176
       -
                       let n = self.nat()?;

     

       177
       177
       -
                       ret.push(TemplateItem::Len(n));

     

       178
       178
       -
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       179
       179
       -
                       self.advance(3);

     

       180
       180
       -
                       self.peek_to(7);

     

       181
       181
       -
                       let mut r = Vec::new();

     

       182
       182
       -
                       mem::swap(&mut r, &mut self.peeked);

     

       183
       183
       -
                       rna.push(r.try_into().unwrap());

     

       184
       184
       -
                       self.index += 7;

     

       185
       185
       -
                   } else {

     

       186
       186
       -
                       return None;

     

       187
       187
       -
                   }

     

       188
       188
       -
               }

     

       189
       189
       -
           }

     

       190
       190
       -
       }

     

       191
       191
       -
       

     

       192
       192
       -
       #[cfg(test)]

     

       193
       193
       -
       mod tests {

     

       194
       194
       -
           use super::*;

     

       195
       195
       -
       

     

       196
       196
       -
           fn dna_from_str(s: &str) -> Vec<Base> {

     

       197
       197
       -
               s.chars().filter_map(|c| Base::from_char(c)).collect()

     

       198
       198
       -
           }

     

       199
       199
       -
       

     

       200
       200
       -
           #[test]

     

       201
       201
       -
           fn test_base() {

     

       202
       202
       -
               let dna = dna_from_str("ICFP").into_iter();

     

       203
       203
       -
               let mut parser = Parser::new(dna);

     

       204
       204
       -
               assert!(parser.next_is(&[Base::I]));

     

       205
       205
       -
               assert!(parser.next_is(&[Base::I, Base::C]));

     

       206
       206
       -
               assert!(parser.next_is(&[Base::I, Base::C, Base::F]));

     

       207
       207
       -
               assert!(parser.next_is(&[Base::I, Base::C, Base::F, Base::P]));

     

       208
       208
       -
           }

     

       209
       209
       -
       

     

       210
       210
       -
           #[test]

     

       211
       211
       -
           fn test_nat() {

     

       212
       212
       -
               let dna = dna_from_str("CP").into_iter();

     

       213
       213
       -
               let mut parser = Parser::new(dna);

     

       214
       214
       -
               assert_eq!(parser.nat(), Some(1));

     

       215
       215
       -
               assert_eq!(parser.index, 2);

     

       216
       216
       -
       

     

       217
       217
       -
               let dna = dna_from_str("ICICP").into_iter();

     

       218
       218
       -
               let mut parser = Parser::new(dna);

     

       219
       219
       -
               assert_eq!(parser.nat(), Some(10));

     

       220
       220
       -
               assert_eq!(parser.index, 5);

     

       221
       221
       -
       

     

       222
       222
       -
               let dna = dna_from_str("III").into_iter();

     

       223
       223
       -
               let mut parser = Parser::new(dna);

     

       224
       224
       -
               assert_eq!(parser.nat(), None);

     

       225
       225
       -
               assert_eq!(parser.index, 3);

     

       226
       226
       -
           }

     

       227
       227
       -
       

     

       228
       228
       -
           #[test]

     

       229
       229
       -
           fn test_consts() {

     

       230
       230
       -
               let dna = dna_from_str("CFPICIIC").into_iter();

     

       231
       231
       -
               let mut parser = Parser::new(dna);

     

       232
       232
       -
               assert_eq!(parser.consts(), &[Base::I, Base::C, Base::F, Base::P]);

     

       233
       233
       -
               assert_eq!(parser.index, 5);

     

       234
       234
       -
           }

     

       235
       235
       -
       

     

       236
       236
       -
           #[test]

     

       237
       237
       -
           fn test_pattern() {

     

       238
       238
       -
               let mut rna = Vec::new();

     

       239
       239
       -
       

     

       240
       240
       -
               let dna = dna_from_str("CIIC").into_iter();

     

       241
       241
       -
               let mut parser = Parser::new(dna);

     

       242
       242
       -
               assert_eq!(

     

       243
       243
       -
                   parser.pattern(&mut rna),

     

       244
       244
       -
                   Some(Pattern::new(vec![PatternItem::Base(Base::I)]))

     

       245
       245
       -
               );

     

       246
       246
       -
               assert_eq!(parser.index, 4);

     

       247
       247
       -
       

     

       248
       248
       -
               let dna = dna_from_str("IIPIPICPIICICIIF").into_iter();

     

       249
       249
       -
               let mut parser = Parser::new(dna);

     

       250
       250
       -
               assert_eq!(

     

       251
       251
       -
                   parser.pattern(&mut rna),

     

       252
       252
       -
                   Some(Pattern::new(vec![

     

       253
       253
       -
                       PatternItem::Open,

     

       254
       254
       -
                       PatternItem::Skip(2),

     

       255
       255
       -
                       PatternItem::Close,

     

       256
       256
       -
                       PatternItem::Base(Base::P)

     

       257
       257
       -
                   ]))

     

       258
       258
       -
               );

     

       259
       259
       -
               assert_eq!(parser.index, 16);

     

       260
       260
       -
       

     

       261
       261
       -
               let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       262
       262
       -
               let mut parser = Parser::new(dna);

     

       263
       263
       -
               assert_eq!(parser.pattern(&mut rna), Some(Pattern::new(vec![])));

     

       264
       264
       -
               assert_eq!(parser.index, 13);

     

       265
       265
       -
               assert_eq!(

     

       266
       266
       -
                   rna,

     

       267
       267
       -
                   vec![[

     

       268
       268
       -
                       Base::P,

     

       269
       269
       -
                       Base::F,

     

       270
       270
       -
                       Base::C,

     

       271
       271
       -
                       Base::I,

     

       272
       272
       -
                       Base::C,

     

       273
       273
       -
                       Base::F,

     

       274
       274
       -
                       Base::P

     

       275
       275
       -
                   ]]

     

       276
       276
       -
               );

     

       277
       277
       -
           }

     

       278
       278
       -
       

     

       279
       279
       -
           #[test]

     

       280
       280
       -
           fn test_template() {

     

       281
       281
       -
               let mut rna = Vec::new();

     

       282
       282
       -
       

     

       283
       283
       -
               let dna = dna_from_str("CFPICIFCPICPIIPIICPIIC").into_iter();

     

       284
       284
       -
               let mut parser = Parser::new(dna);

     

       285
       285
       -
               assert_eq!(

     

       286
       286
       -
                   parser.template(&mut rna),

     

       287
       287
       -
                   Some(Template::new(vec![

     

       288
       288
       -
                       TemplateItem::Base(Base::I),

     

       289
       289
       -
                       TemplateItem::Base(Base::C),

     

       290
       290
       -
                       TemplateItem::Base(Base::F),

     

       291
       291
       -
                       TemplateItem::Base(Base::P),

     

       292
       292
       -
                       TemplateItem::Ref(2, 1),

     

       293
       293
       -
                       TemplateItem::Len(4)

     

       294
       294
       -
                   ]))

     

       295
       295
       -
               );

     

       296
       296
       -
               assert_eq!(parser.index, 22);

     

       297
       297
       -
       

     

       298
       298
       -
               let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       299
       299
       -
               let mut parser = Parser::new(dna);

     

       300
       300
       -
               assert_eq!(parser.template(&mut rna), Some(Template::new(vec![])));

     

       301
       301
       -
               assert_eq!(parser.index, 13);

     

       302
       302
       -
               assert_eq!(

     

       303
       303
       -
                   rna,

     

       304
       304
       -
                   vec![[

     

       305
       305
       -
                       Base::P,

     

       306
       306
       -
                       Base::F,

     

       307
       307
       -
                       Base::C,

     

       308
       308
       -
                       Base::I,

     

       309
       309
       -
                       Base::C,

     

       310
       310
       -
                       Base::F,

     

       311
       311
       -
                       Base::P

     

       312
       312
       -
                   ]]

     

       313
       313
       -
               );

     

       314
       314
       -
           }

     

       315
       315
       -
       }

-114

dna2rna/src/pattern.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       2
       -
       use std::fmt;

     

       3
       3
       -
       use std::slice;

     

       4
       4
       -
       use std::vec;

     

       5
       5
       -
       

     

       6
       6
       -
       #[derive(Debug, PartialEq)]

     

       7
       7
       -
       pub enum PatternItem {

     

       8
       8
       -
           Base(Base),

     

       9
       9
       -
           Skip(usize),

     

       10
       10
       -
           Search(Vec<Base>),

     

       11
       11
       -
           Open,

     

       12
       12
       -
           Close,

     

       13
       13
       -
       }

     

       14
       14
       -
       

     

       15
       15
       -
       impl fmt::Display for PatternItem {

     

       16
       16
       -
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       17
       17
       -
               match &self {

     

       18
       18
       -
                   PatternItem::Base(b) => write!(f, "{}", b.to_char()),

     

       19
       19
       -
                   PatternItem::Skip(n) => write!(f, "!{{{}}}", n),

     

       20
       20
       -
                   PatternItem::Search(s) => {

     

       21
       21
       -
                       write!(f, "?{{")?;

     

       22
       22
       -
                       for b in s {

     

       23
       23
       -
                           write!(f, "{}", b.to_char())?;

     

       24
       24
       -
                       }

     

       25
       25
       -
                       write!(f, "}}")?;

     

       26
       26
       -
                       Ok(())

     

       27
       27
       -
                   }

     

       28
       28
       -
                   PatternItem::Open => write!(f, "("),

     

       29
       29
       -
                   PatternItem::Close => write!(f, ")"),

     

       30
       30
       -
               }

     

       31
       31
       -
           }

     

       32
       32
       -
       }

     

       33
       33
       -
       

     

       34
       34
       -
       #[derive(PartialEq, Debug)]

     

       35
       35
       -
       pub struct Pattern {

     

       36
       36
       -
           pattern: Vec<PatternItem>,

     

       37
       37
       -
       }

     

       38
       38
       -
       

     

       39
       39
       -
       impl Pattern {

     

       40
       40
       -
           pub fn new(pattern: Vec<PatternItem>) -> Pattern {

     

       41
       41
       -
               Pattern { pattern: pattern }

     

       42
       42
       -
           }

     

       43
       43
       -
       

     

       44
       44
       -
           pub fn iter<'a>(&'a self) -> slice::Iter<'a, PatternItem> {

     

       45
       45
       -
               self.pattern.iter()

     

       46
       46
       -
           }

     

       47
       47
       -
       

     

       48
       48
       -
           pub fn into_iter<'a>(self) -> vec::IntoIter<PatternItem> {

     

       49
       49
       -
               self.pattern.into_iter()

     

       50
       50
       -
           }

     

       51
       51
       -
       }

     

       52
       52
       -
       

     

       53
       53
       -
       impl fmt::Display for Pattern {

     

       54
       54
       -
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       55
       55
       -
               for p in self.iter() {

     

       56
       56
       -
                   write!(f, "{}", p)?;

     

       57
       57
       -
               }

     

       58
       58
       -
               Ok(())

     

       59
       59
       -
           }

     

       60
       60
       -
       }

     

       61
       61
       -
       

     

       62
       62
       -
       #[cfg(test)]

     

       63
       63
       -
       mod tests {

     

       64
       64
       -
           use super::*;

     

       65
       65
       -
       

     

       66
       66
       -
           #[test]

     

       67
       67
       -
           fn test_display_base() {

     

       68
       68
       -
               assert_eq!(

     

       69
       69
       -
                   Pattern::new(vec![

     

       70
       70
       -
                       PatternItem::Base(Base::I),

     

       71
       71
       -
                       PatternItem::Base(Base::C),

     

       72
       72
       -
                       PatternItem::Base(Base::F),

     

       73
       73
       -
                       PatternItem::Base(Base::P)

     

       74
       74
       -
                   ])

     

       75
       75
       -
                   .to_string(),

     

       76
       76
       -
                   "ICFP"

     

       77
       77
       -
               );

     

       78
       78
       -
           }

     

       79
       79
       -
       

     

       80
       80
       -
           #[test]

     

       81
       81
       -
           fn test_display_skip() {

     

       82
       82
       -
               assert_eq!(Pattern::new(vec![PatternItem::Skip(5)]).to_string(), "!{5}");

     

       83
       83
       -
           }

     

       84
       84
       -
       

     

       85
       85
       -
           #[test]

     

       86
       86
       -
           fn test_display_search() {

     

       87
       87
       -
               assert_eq!(

     

       88
       88
       -
                   Pattern::new(vec![PatternItem::Search(vec![

     

       89
       89
       -
                       Base::I,

     

       90
       90
       -
                       Base::C,

     

       91
       91
       -
                       Base::F,

     

       92
       92
       -
                       Base::P

     

       93
       93
       -
                   ])])

     

       94
       94
       -
                   .to_string(),

     

       95
       95
       -
                   "?{ICFP}"

     

       96
       96
       -
               );

     

       97
       97
       -
           }

     

       98
       98
       -
       

     

       99
       99
       -
           #[test]

     

       100
       100
       -
           fn test_display_group() {

     

       101
       101
       -
               assert_eq!(

     

       102
       102
       -
                   Pattern::new(vec![

     

       103
       103
       -
                       PatternItem::Open,

     

       104
       104
       -
                       PatternItem::Base(Base::I),

     

       105
       105
       -
                       PatternItem::Base(Base::C),

     

       106
       106
       -
                       PatternItem::Base(Base::F),

     

       107
       107
       -
                       PatternItem::Base(Base::P),

     

       108
       108
       -
                       PatternItem::Close,

     

       109
       109
       -
                   ])

     

       110
       110
       -
                   .to_string(),

     

       111
       111
       -
                   "(ICFP)"

     

       112
       112
       -
               )

     

       113
       113
       -
           }

     

       114
       114
       -
       }

-3

dna2rna/src/rna.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       2
       -
       

     

       3
       3
       -
       pub type Rna = [Base; 7];

-89

dna2rna/src/template.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       2
       -
       use std::fmt;

     

       3
       3
       -
       use std::slice;

     

       4
       4
       -
       use std::vec;

     

       5
       5
       -
       

     

       6
       6
       -
       #[derive(Debug, PartialEq)]

     

       7
       7
       -
       pub enum TemplateItem {

     

       8
       8
       -
           Base(Base),

     

       9
       9
       -
           Ref(usize, usize),

     

       10
       10
       -
           Len(usize),

     

       11
       11
       -
       }

     

       12
       12
       -
       

     

       13
       13
       -
       impl fmt::Display for TemplateItem {

     

       14
       14
       -
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       15
       15
       -
               match &self {

     

       16
       16
       -
                   TemplateItem::Base(b) => write!(f, "{}", b.to_char()),

     

       17
       17
       -
                   TemplateItem::Ref(n, l) => {

     

       18
       18
       -
                       if *l == 0 {

     

       19
       19
       -
                           write!(f, "{{{}}}", n)

     

       20
       20
       -
                       } else {

     

       21
       21
       -
                           write!(f, "{{{},{}}}", n, l)

     

       22
       22
       -
                       }

     

       23
       23
       -
                   }

     

       24
       24
       -
                   TemplateItem::Len(n) => {

     

       25
       25
       -
                       write!(f, "|{}|", n)

     

       26
       26
       -
                   }

     

       27
       27
       -
               }

     

       28
       28
       -
           }

     

       29
       29
       -
       }

     

       30
       30
       -
       

     

       31
       31
       -
       #[derive(Debug, PartialEq)]

     

       32
       32
       -
       pub struct Template {

     

       33
       33
       -
           template: Vec<TemplateItem>,

     

       34
       34
       -
       }

     

       35
       35
       -
       

     

       36
       36
       -
       impl Template {

     

       37
       37
       -
           pub fn new(template: Vec<TemplateItem>) -> Template {

     

       38
       38
       -
               Template { template: template }

     

       39
       39
       -
           }

     

       40
       40
       -
       

     

       41
       41
       -
           pub fn iter<'a>(&'a self) -> slice::Iter<'a, TemplateItem> {

     

       42
       42
       -
               self.template.iter()

     

       43
       43
       -
           }

     

       44
       44
       -
       

     

       45
       45
       -
           pub fn into_iter<'a>(self) -> vec::IntoIter<TemplateItem> {

     

       46
       46
       -
               self.template.into_iter()

     

       47
       47
       -
           }

     

       48
       48
       -
       }

     

       49
       49
       -
       

     

       50
       50
       -
       impl fmt::Display for Template {

     

       51
       51
       -
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       52
       52
       -
               for p in self.iter() {

     

       53
       53
       -
                   write!(f, "{}", p)?;

     

       54
       54
       -
               }

     

       55
       55
       -
               Ok(())

     

       56
       56
       -
           }

     

       57
       57
       -
       }

     

       58
       58
       -
       

     

       59
       59
       -
       #[cfg(test)]

     

       60
       60
       -
       mod tests {

     

       61
       61
       -
           use super::*;

     

       62
       62
       -
       

     

       63
       63
       -
           #[test]

     

       64
       64
       -
           fn test_display_base() {

     

       65
       65
       -
               assert_eq!(

     

       66
       66
       -
                   Template::new(vec![

     

       67
       67
       -
                       TemplateItem::Base(Base::I),

     

       68
       68
       -
                       TemplateItem::Base(Base::C),

     

       69
       69
       -
                       TemplateItem::Base(Base::F),

     

       70
       70
       -
                       TemplateItem::Base(Base::P)

     

       71
       71
       -
                   ])

     

       72
       72
       -
                   .to_string(),

     

       73
       73
       -
                   "ICFP"

     

       74
       74
       -
               );

     

       75
       75
       -
           }

     

       76
       76
       -
       

     

       77
       77
       -
           #[test]

     

       78
       78
       -
           fn test_display_ref() {

     

       79
       79
       -
               assert_eq!(

     

       80
       80
       -
                   Template::new(vec![TemplateItem::Ref(3, 2), TemplateItem::Ref(4, 0),]).to_string(),

     

       81
       81
       -
                   "{3,2}{4}"

     

       82
       82
       -
               );

     

       83
       83
       -
           }

     

       84
       84
       -
       

     

       85
       85
       -
           #[test]

     

       86
       86
       -
           fn test_display_lenf() {

     

       87
       87
       -
               assert_eq!(Template::new(vec![TemplateItem::Len(3)]).to_string(), "|3|");

     

       88
       88
       -
           }

     

       89
       89
       -
       }

dna_parsing/.dir-locals.el

···

       1
       1
       +
       ((nil . ((default-directory . "~/repos/endo/dna_parsing/"))))

dna_parsing/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "dna_parsing"

     

       7
       7
       +
       version = "0.1.0"

dna_parsing/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "dna_parsing"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+28

dna_parsing/src/base.rs

···

       1
       1
       +
       #[derive(Copy, Clone, PartialEq, Debug)]

     

       2
       2
       +
       pub enum Base {

     

       3
       3
       +
           I,

     

       4
       4
       +
           C,

     

       5
       5
       +
           F,

     

       6
       6
       +
           P,

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       impl Base {

     

       10
       10
       +
           pub fn from_char(c: char) -> Option<Base> {

     

       11
       11
       +
               match c {

     

       12
       12
       +
                   'I' => Some(Base::I),

     

       13
       13
       +
                   'C' => Some(Base::C),

     

       14
       14
       +
                   'F' => Some(Base::F),

     

       15
       15
       +
                   'P' => Some(Base::P),

     

       16
       16
       +
                   _ => None,

     

       17
       17
       +
               }

     

       18
       18
       +
           }

     

       19
       19
       +
       

     

       20
       20
       +
           pub fn to_char(&self) -> char {

     

       21
       21
       +
               match self {

     

       22
       22
       +
                   Base::I => 'I',

     

       23
       23
       +
                   Base::C => 'C',

     

       24
       24
       +
                   Base::F => 'F',

     

       25
       25
       +
                   Base::P => 'P',

     

       26
       26
       +
               }

     

       27
       27
       +
           }

     

       28
       28
       +
       }

dna_parsing/src/lib.rs

···

       1
       1
       +
       pub mod base;

     

       2
       2
       +
       pub mod parser;

     

       3
       3
       +
       pub mod pattern;

     

       4
       4
       +
       pub mod rna;

     

       5
       5
       +
       pub mod template;

+315

dna_parsing/src/parser.rs

···

       1
       1
       +
       use crate::base::Base;

     

       2
       2
       +
       use crate::pattern::Pattern;

     

       3
       3
       +
       use crate::pattern::PatternItem;

     

       4
       4
       +
       use crate::rna::Rna;

     

       5
       5
       +
       use crate::template::Template;

     

       6
       6
       +
       use crate::template::TemplateItem;

     

       7
       7
       +
       use std::mem;

     

       8
       8
       +
       

     

       9
       9
       +
       pub struct Parser<I>

     

       10
       10
       +
       where

     

       11
       11
       +
           I: Iterator<Item = Base>,

     

       12
       12
       +
       {

     

       13
       13
       +
           iter: I,

     

       14
       14
       +
           peeked: Vec<Base>,

     

       15
       15
       +
           index: usize,

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       impl<I> Parser<I>

     

       19
       19
       +
       where

     

       20
       20
       +
           I: Iterator<Item = Base>,

     

       21
       21
       +
       {

     

       22
       22
       +
           pub fn new(iter: I) -> Parser<I> {

     

       23
       23
       +
               Parser {

     

       24
       24
       +
                   iter: iter,

     

       25
       25
       +
                   peeked: Vec::new(),

     

       26
       26
       +
                   index: 0,

     

       27
       27
       +
               }

     

       28
       28
       +
           }

     

       29
       29
       +
       

     

       30
       30
       +
           pub fn index(&self) -> usize {

     

       31
       31
       +
               self.index

     

       32
       32
       +
           }

     

       33
       33
       +
       

     

       34
       34
       +
           fn peek_to(&mut self, n: usize) {

     

       35
       35
       +
               while self.peeked.len() < n {

     

       36
       36
       +
                   if let Some(b) = self.iter.next() {

     

       37
       37
       +
                       self.peeked.push(b);

     

       38
       38
       +
                   } else {

     

       39
       39
       +
                       return;

     

       40
       40
       +
                   }

     

       41
       41
       +
               }

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           pub fn next_is(&mut self, next: &[Base]) -> bool {

     

       45
       45
       +
               self.peek_to(next.len());

     

       46
       46
       +
               if self.peeked.len() < next.len() {

     

       47
       47
       +
                   return false;

     

       48
       48
       +
               }

     

       49
       49
       +
               return &self.peeked[..next.len()] == next;

     

       50
       50
       +
           }

     

       51
       51
       +
       

     

       52
       52
       +
           pub fn advance(&mut self, n: usize) {

     

       53
       53
       +
               self.peek_to(n);

     

       54
       54
       +
               self.index += n;

     

       55
       55
       +
               self.peeked.drain(..n);

     

       56
       56
       +
           }

     

       57
       57
       +
       

     

       58
       58
       +
           pub fn nat(&mut self) -> Option<usize> {

     

       59
       59
       +
               let mut ret = 0;

     

       60
       60
       +
               let mut bit = 1;

     

       61
       61
       +
               loop {

     

       62
       62
       +
                   if self.next_is(&[Base::P]) {

     

       63
       63
       +
                       self.advance(1);

     

       64
       64
       +
                       return Some(ret);

     

       65
       65
       +
                   } else if self.next_is(&[Base::I]) || self.next_is(&[Base::F]) {

     

       66
       66
       +
                       self.advance(1);

     

       67
       67
       +
                   } else if self.next_is(&[Base::C]) {

     

       68
       68
       +
                       ret += bit;

     

       69
       69
       +
                       self.advance(1);

     

       70
       70
       +
                   } else {

     

       71
       71
       +
                       return None;

     

       72
       72
       +
                   }

     

       73
       73
       +
       

     

       74
       74
       +
                   bit *= 2;

     

       75
       75
       +
               }

     

       76
       76
       +
           }

     

       77
       77
       +
       

     

       78
       78
       +
           pub fn consts(&mut self) -> Vec<Base> {

     

       79
       79
       +
               let mut ret = Vec::new();

     

       80
       80
       +
               loop {

     

       81
       81
       +
                   if self.next_is(&[Base::C]) {

     

       82
       82
       +
                       self.advance(1);

     

       83
       83
       +
                       ret.push(Base::I);

     

       84
       84
       +
                   } else if self.next_is(&[Base::F]) {

     

       85
       85
       +
                       self.advance(1);

     

       86
       86
       +
                       ret.push(Base::C);

     

       87
       87
       +
                   } else if self.next_is(&[Base::P]) {

     

       88
       88
       +
                       self.advance(1);

     

       89
       89
       +
                       ret.push(Base::F);

     

       90
       90
       +
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       91
       91
       +
                       self.advance(2);

     

       92
       92
       +
                       ret.push(Base::P);

     

       93
       93
       +
                   } else {

     

       94
       94
       +
                       return ret;

     

       95
       95
       +
                   }

     

       96
       96
       +
               }

     

       97
       97
       +
           }

     

       98
       98
       +
       

     

       99
       99
       +
           pub fn pattern(&mut self, rna: &mut Vec<Rna>) -> Option<Pattern> {

     

       100
       100
       +
               let mut ret = Vec::new();

     

       101
       101
       +
               let mut level = 0;

     

       102
       102
       +
               loop {

     

       103
       103
       +
                   if self.next_is(&[Base::C]) {

     

       104
       104
       +
                       self.advance(1);

     

       105
       105
       +
                       ret.push(PatternItem::Base(Base::I));

     

       106
       106
       +
                   } else if self.next_is(&[Base::F]) {

     

       107
       107
       +
                       self.advance(1);

     

       108
       108
       +
                       ret.push(PatternItem::Base(Base::C));

     

       109
       109
       +
                   } else if self.next_is(&[Base::P]) {

     

       110
       110
       +
                       self.advance(1);

     

       111
       111
       +
                       ret.push(PatternItem::Base(Base::F));

     

       112
       112
       +
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       113
       113
       +
                       self.advance(2);

     

       114
       114
       +
                       ret.push(PatternItem::Base(Base::P));

     

       115
       115
       +
                   } else if self.next_is(&[Base::I, Base::P]) {

     

       116
       116
       +
                       self.advance(2);

     

       117
       117
       +
                       let n = self.nat()?;

     

       118
       118
       +
                       ret.push(PatternItem::Skip(n));

     

       119
       119
       +
                   } else if self.next_is(&[Base::I, Base::F]) {

     

       120
       120
       +
                       self.advance(3);

     

       121
       121
       +
                       let s = self.consts();

     

       122
       122
       +
                       ret.push(PatternItem::Search(s));

     

       123
       123
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::P]) {

     

       124
       124
       +
                       self.advance(3);

     

       125
       125
       +
                       level += 1;

     

       126
       126
       +
                       ret.push(PatternItem::Open);

     

       127
       127
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::C])

     

       128
       128
       +
                       || self.next_is(&[Base::I, Base::I, Base::F])

     

       129
       129
       +
                   {

     

       130
       130
       +
                       self.advance(3);

     

       131
       131
       +
                       if level == 0 {

     

       132
       132
       +
                           return Some(Pattern::new(ret));

     

       133
       133
       +
                       }

     

       134
       134
       +
                       level -= 1;

     

       135
       135
       +
                       ret.push(PatternItem::Close);

     

       136
       136
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       137
       137
       +
                       self.advance(3);

     

       138
       138
       +
                       self.peek_to(7);

     

       139
       139
       +
                       let mut r = Vec::new();

     

       140
       140
       +
                       mem::swap(&mut r, &mut self.peeked);

     

       141
       141
       +
                       rna.push(r.try_into().unwrap());

     

       142
       142
       +
                       self.index += 7;

     

       143
       143
       +
                   } else {

     

       144
       144
       +
                       return None;

     

       145
       145
       +
                   }

     

       146
       146
       +
               }

     

       147
       147
       +
           }

     

       148
       148
       +
       

     

       149
       149
       +
           pub fn template(&mut self, rna: &mut Vec<Rna>) -> Option<Template> {

     

       150
       150
       +
               let mut ret = Vec::new();

     

       151
       151
       +
               loop {

     

       152
       152
       +
                   if self.next_is(&[Base::C]) {

     

       153
       153
       +
                       self.advance(1);

     

       154
       154
       +
                       ret.push(TemplateItem::Base(Base::I));

     

       155
       155
       +
                   } else if self.next_is(&[Base::F]) {

     

       156
       156
       +
                       self.advance(1);

     

       157
       157
       +
                       ret.push(TemplateItem::Base(Base::C));

     

       158
       158
       +
                   } else if self.next_is(&[Base::P]) {

     

       159
       159
       +
                       self.advance(1);

     

       160
       160
       +
                       ret.push(TemplateItem::Base(Base::F));

     

       161
       161
       +
                   } else if self.next_is(&[Base::I, Base::C]) {

     

       162
       162
       +
                       self.advance(2);

     

       163
       163
       +
                       ret.push(TemplateItem::Base(Base::P));

     

       164
       164
       +
                   } else if self.next_is(&[Base::I, Base::P]) || self.next_is(&[Base::I, Base::F]) {

     

       165
       165
       +
                       self.advance(2);

     

       166
       166
       +
                       let l = self.nat()?;

     

       167
       167
       +
                       let n = self.nat()?;

     

       168
       168
       +
                       ret.push(TemplateItem::Ref(n, l));

     

       169
       169
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::C])

     

       170
       170
       +
                       || self.next_is(&[Base::I, Base::I, Base::F])

     

       171
       171
       +
                   {

     

       172
       172
       +
                       self.advance(3);

     

       173
       173
       +
                       return Some(Template::new(ret));

     

       174
       174
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::P]) {

     

       175
       175
       +
                       self.advance(3);

     

       176
       176
       +
                       let n = self.nat()?;

     

       177
       177
       +
                       ret.push(TemplateItem::Len(n));

     

       178
       178
       +
                   } else if self.next_is(&[Base::I, Base::I, Base::I]) {

     

       179
       179
       +
                       self.advance(3);

     

       180
       180
       +
                       self.peek_to(7);

     

       181
       181
       +
                       let mut r = Vec::new();

     

       182
       182
       +
                       mem::swap(&mut r, &mut self.peeked);

     

       183
       183
       +
                       rna.push(r.try_into().unwrap());

     

       184
       184
       +
                       self.index += 7;

     

       185
       185
       +
                   } else {

     

       186
       186
       +
                       return None;

     

       187
       187
       +
                   }

     

       188
       188
       +
               }

     

       189
       189
       +
           }

     

       190
       190
       +
       }

     

       191
       191
       +
       

     

       192
       192
       +
       #[cfg(test)]

     

       193
       193
       +
       mod tests {

     

       194
       194
       +
           use super::*;

     

       195
       195
       +
       

     

       196
       196
       +
           fn dna_from_str(s: &str) -> Vec<Base> {

     

       197
       197
       +
               s.chars().filter_map(|c| Base::from_char(c)).collect()

     

       198
       198
       +
           }

     

       199
       199
       +
       

     

       200
       200
       +
           #[test]

     

       201
       201
       +
           fn test_base() {

     

       202
       202
       +
               let dna = dna_from_str("ICFP").into_iter();

     

       203
       203
       +
               let mut parser = Parser::new(dna);

     

       204
       204
       +
               assert!(parser.next_is(&[Base::I]));

     

       205
       205
       +
               assert!(parser.next_is(&[Base::I, Base::C]));

     

       206
       206
       +
               assert!(parser.next_is(&[Base::I, Base::C, Base::F]));

     

       207
       207
       +
               assert!(parser.next_is(&[Base::I, Base::C, Base::F, Base::P]));

     

       208
       208
       +
           }

     

       209
       209
       +
       

     

       210
       210
       +
           #[test]

     

       211
       211
       +
           fn test_nat() {

     

       212
       212
       +
               let dna = dna_from_str("CP").into_iter();

     

       213
       213
       +
               let mut parser = Parser::new(dna);

     

       214
       214
       +
               assert_eq!(parser.nat(), Some(1));

     

       215
       215
       +
               assert_eq!(parser.index, 2);

     

       216
       216
       +
       

     

       217
       217
       +
               let dna = dna_from_str("ICICP").into_iter();

     

       218
       218
       +
               let mut parser = Parser::new(dna);

     

       219
       219
       +
               assert_eq!(parser.nat(), Some(10));

     

       220
       220
       +
               assert_eq!(parser.index, 5);

     

       221
       221
       +
       

     

       222
       222
       +
               let dna = dna_from_str("III").into_iter();

     

       223
       223
       +
               let mut parser = Parser::new(dna);

     

       224
       224
       +
               assert_eq!(parser.nat(), None);

     

       225
       225
       +
               assert_eq!(parser.index, 3);

     

       226
       226
       +
           }

     

       227
       227
       +
       

     

       228
       228
       +
           #[test]

     

       229
       229
       +
           fn test_consts() {

     

       230
       230
       +
               let dna = dna_from_str("CFPICIIC").into_iter();

     

       231
       231
       +
               let mut parser = Parser::new(dna);

     

       232
       232
       +
               assert_eq!(parser.consts(), &[Base::I, Base::C, Base::F, Base::P]);

     

       233
       233
       +
               assert_eq!(parser.index, 5);

     

       234
       234
       +
           }

     

       235
       235
       +
       

     

       236
       236
       +
           #[test]

     

       237
       237
       +
           fn test_pattern() {

     

       238
       238
       +
               let mut rna = Vec::new();

     

       239
       239
       +
       

     

       240
       240
       +
               let dna = dna_from_str("CIIC").into_iter();

     

       241
       241
       +
               let mut parser = Parser::new(dna);

     

       242
       242
       +
               assert_eq!(

     

       243
       243
       +
                   parser.pattern(&mut rna),

     

       244
       244
       +
                   Some(Pattern::new(vec![PatternItem::Base(Base::I)]))

     

       245
       245
       +
               );

     

       246
       246
       +
               assert_eq!(parser.index, 4);

     

       247
       247
       +
       

     

       248
       248
       +
               let dna = dna_from_str("IIPIPICPIICICIIF").into_iter();

     

       249
       249
       +
               let mut parser = Parser::new(dna);

     

       250
       250
       +
               assert_eq!(

     

       251
       251
       +
                   parser.pattern(&mut rna),

     

       252
       252
       +
                   Some(Pattern::new(vec![

     

       253
       253
       +
                       PatternItem::Open,

     

       254
       254
       +
                       PatternItem::Skip(2),

     

       255
       255
       +
                       PatternItem::Close,

     

       256
       256
       +
                       PatternItem::Base(Base::P)

     

       257
       257
       +
                   ]))

     

       258
       258
       +
               );

     

       259
       259
       +
               assert_eq!(parser.index, 16);

     

       260
       260
       +
       

     

       261
       261
       +
               let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       262
       262
       +
               let mut parser = Parser::new(dna);

     

       263
       263
       +
               assert_eq!(parser.pattern(&mut rna), Some(Pattern::new(vec![])));

     

       264
       264
       +
               assert_eq!(parser.index, 13);

     

       265
       265
       +
               assert_eq!(

     

       266
       266
       +
                   rna,

     

       267
       267
       +
                   vec![[

     

       268
       268
       +
                       Base::P,

     

       269
       269
       +
                       Base::F,

     

       270
       270
       +
                       Base::C,

     

       271
       271
       +
                       Base::I,

     

       272
       272
       +
                       Base::C,

     

       273
       273
       +
                       Base::F,

     

       274
       274
       +
                       Base::P

     

       275
       275
       +
                   ]]

     

       276
       276
       +
               );

     

       277
       277
       +
           }

     

       278
       278
       +
       

     

       279
       279
       +
           #[test]

     

       280
       280
       +
           fn test_template() {

     

       281
       281
       +
               let mut rna = Vec::new();

     

       282
       282
       +
       

     

       283
       283
       +
               let dna = dna_from_str("CFPICIFCPICPIIPIICPIIC").into_iter();

     

       284
       284
       +
               let mut parser = Parser::new(dna);

     

       285
       285
       +
               assert_eq!(

     

       286
       286
       +
                   parser.template(&mut rna),

     

       287
       287
       +
                   Some(Template::new(vec![

     

       288
       288
       +
                       TemplateItem::Base(Base::I),

     

       289
       289
       +
                       TemplateItem::Base(Base::C),

     

       290
       290
       +
                       TemplateItem::Base(Base::F),

     

       291
       291
       +
                       TemplateItem::Base(Base::P),

     

       292
       292
       +
                       TemplateItem::Ref(2, 1),

     

       293
       293
       +
                       TemplateItem::Len(4)

     

       294
       294
       +
                   ]))

     

       295
       295
       +
               );

     

       296
       296
       +
               assert_eq!(parser.index, 22);

     

       297
       297
       +
       

     

       298
       298
       +
               let dna = dna_from_str("IIIPFCICFPIIC").into_iter();

     

       299
       299
       +
               let mut parser = Parser::new(dna);

     

       300
       300
       +
               assert_eq!(parser.template(&mut rna), Some(Template::new(vec![])));

     

       301
       301
       +
               assert_eq!(parser.index, 13);

     

       302
       302
       +
               assert_eq!(

     

       303
       303
       +
                   rna,

     

       304
       304
       +
                   vec![[

     

       305
       305
       +
                       Base::P,

     

       306
       306
       +
                       Base::F,

     

       307
       307
       +
                       Base::C,

     

       308
       308
       +
                       Base::I,

     

       309
       309
       +
                       Base::C,

     

       310
       310
       +
                       Base::F,

     

       311
       311
       +
                       Base::P

     

       312
       312
       +
                   ]]

     

       313
       313
       +
               );

     

       314
       314
       +
           }

     

       315
       315
       +
       }

+114

dna_parsing/src/pattern.rs

···

       1
       1
       +
       use crate::base::Base;

     

       2
       2
       +
       use std::fmt;

     

       3
       3
       +
       use std::slice;

     

       4
       4
       +
       use std::vec;

     

       5
       5
       +
       

     

       6
       6
       +
       #[derive(Debug, PartialEq)]

     

       7
       7
       +
       pub enum PatternItem {

     

       8
       8
       +
           Base(Base),

     

       9
       9
       +
           Skip(usize),

     

       10
       10
       +
           Search(Vec<Base>),

     

       11
       11
       +
           Open,

     

       12
       12
       +
           Close,

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       impl fmt::Display for PatternItem {

     

       16
       16
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       17
       17
       +
               match &self {

     

       18
       18
       +
                   PatternItem::Base(b) => write!(f, "{}", b.to_char()),

     

       19
       19
       +
                   PatternItem::Skip(n) => write!(f, "!{{{}}}", n),

     

       20
       20
       +
                   PatternItem::Search(s) => {

     

       21
       21
       +
                       write!(f, "?{{")?;

     

       22
       22
       +
                       for b in s {

     

       23
       23
       +
                           write!(f, "{}", b.to_char())?;

     

       24
       24
       +
                       }

     

       25
       25
       +
                       write!(f, "}}")?;

     

       26
       26
       +
                       Ok(())

     

       27
       27
       +
                   }

     

       28
       28
       +
                   PatternItem::Open => write!(f, "("),

     

       29
       29
       +
                   PatternItem::Close => write!(f, ")"),

     

       30
       30
       +
               }

     

       31
       31
       +
           }

     

       32
       32
       +
       }

     

       33
       33
       +
       

     

       34
       34
       +
       #[derive(PartialEq, Debug)]

     

       35
       35
       +
       pub struct Pattern {

     

       36
       36
       +
           pattern: Vec<PatternItem>,

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       impl Pattern {

     

       40
       40
       +
           pub fn new(pattern: Vec<PatternItem>) -> Pattern {

     

       41
       41
       +
               Pattern { pattern: pattern }

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           pub fn iter<'a>(&'a self) -> slice::Iter<'a, PatternItem> {

     

       45
       45
       +
               self.pattern.iter()

     

       46
       46
       +
           }

     

       47
       47
       +
       

     

       48
       48
       +
           pub fn into_iter<'a>(self) -> vec::IntoIter<PatternItem> {

     

       49
       49
       +
               self.pattern.into_iter()

     

       50
       50
       +
           }

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       impl fmt::Display for Pattern {

     

       54
       54
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       55
       55
       +
               for p in self.iter() {

     

       56
       56
       +
                   write!(f, "{}", p)?;

     

       57
       57
       +
               }

     

       58
       58
       +
               Ok(())

     

       59
       59
       +
           }

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       #[cfg(test)]

     

       63
       63
       +
       mod tests {

     

       64
       64
       +
           use super::*;

     

       65
       65
       +
       

     

       66
       66
       +
           #[test]

     

       67
       67
       +
           fn test_display_base() {

     

       68
       68
       +
               assert_eq!(

     

       69
       69
       +
                   Pattern::new(vec![

     

       70
       70
       +
                       PatternItem::Base(Base::I),

     

       71
       71
       +
                       PatternItem::Base(Base::C),

     

       72
       72
       +
                       PatternItem::Base(Base::F),

     

       73
       73
       +
                       PatternItem::Base(Base::P)

     

       74
       74
       +
                   ])

     

       75
       75
       +
                   .to_string(),

     

       76
       76
       +
                   "ICFP"

     

       77
       77
       +
               );

     

       78
       78
       +
           }

     

       79
       79
       +
       

     

       80
       80
       +
           #[test]

     

       81
       81
       +
           fn test_display_skip() {

     

       82
       82
       +
               assert_eq!(Pattern::new(vec![PatternItem::Skip(5)]).to_string(), "!{5}");

     

       83
       83
       +
           }

     

       84
       84
       +
       

     

       85
       85
       +
           #[test]

     

       86
       86
       +
           fn test_display_search() {

     

       87
       87
       +
               assert_eq!(

     

       88
       88
       +
                   Pattern::new(vec![PatternItem::Search(vec![

     

       89
       89
       +
                       Base::I,

     

       90
       90
       +
                       Base::C,

     

       91
       91
       +
                       Base::F,

     

       92
       92
       +
                       Base::P

     

       93
       93
       +
                   ])])

     

       94
       94
       +
                   .to_string(),

     

       95
       95
       +
                   "?{ICFP}"

     

       96
       96
       +
               );

     

       97
       97
       +
           }

     

       98
       98
       +
       

     

       99
       99
       +
           #[test]

     

       100
       100
       +
           fn test_display_group() {

     

       101
       101
       +
               assert_eq!(

     

       102
       102
       +
                   Pattern::new(vec![

     

       103
       103
       +
                       PatternItem::Open,

     

       104
       104
       +
                       PatternItem::Base(Base::I),

     

       105
       105
       +
                       PatternItem::Base(Base::C),

     

       106
       106
       +
                       PatternItem::Base(Base::F),

     

       107
       107
       +
                       PatternItem::Base(Base::P),

     

       108
       108
       +
                       PatternItem::Close,

     

       109
       109
       +
                   ])

     

       110
       110
       +
                   .to_string(),

     

       111
       111
       +
                   "(ICFP)"

     

       112
       112
       +
               )

     

       113
       113
       +
           }

     

       114
       114
       +
       }

dna_parsing/src/rna.rs

···

       1
       1
       +
       use crate::base::Base;

     

       2
       2
       +
       

     

       3
       3
       +
       pub type Rna = [Base; 7];

+89

dna_parsing/src/template.rs

···

       1
       1
       +
       use crate::base::Base;

     

       2
       2
       +
       use std::fmt;

     

       3
       3
       +
       use std::slice;

     

       4
       4
       +
       use std::vec;

     

       5
       5
       +
       

     

       6
       6
       +
       #[derive(Debug, PartialEq)]

     

       7
       7
       +
       pub enum TemplateItem {

     

       8
       8
       +
           Base(Base),

     

       9
       9
       +
           Ref(usize, usize),

     

       10
       10
       +
           Len(usize),

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       impl fmt::Display for TemplateItem {

     

       14
       14
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       15
       15
       +
               match &self {

     

       16
       16
       +
                   TemplateItem::Base(b) => write!(f, "{}", b.to_char()),

     

       17
       17
       +
                   TemplateItem::Ref(n, l) => {

     

       18
       18
       +
                       if *l == 0 {

     

       19
       19
       +
                           write!(f, "{{{}}}", n)

     

       20
       20
       +
                       } else {

     

       21
       21
       +
                           write!(f, "{{{},{}}}", n, l)

     

       22
       22
       +
                       }

     

       23
       23
       +
                   }

     

       24
       24
       +
                   TemplateItem::Len(n) => {

     

       25
       25
       +
                       write!(f, "|{}|", n)

     

       26
       26
       +
                   }

     

       27
       27
       +
               }

     

       28
       28
       +
           }

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       #[derive(Debug, PartialEq)]

     

       32
       32
       +
       pub struct Template {

     

       33
       33
       +
           template: Vec<TemplateItem>,

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       impl Template {

     

       37
       37
       +
           pub fn new(template: Vec<TemplateItem>) -> Template {

     

       38
       38
       +
               Template { template: template }

     

       39
       39
       +
           }

     

       40
       40
       +
       

     

       41
       41
       +
           pub fn iter<'a>(&'a self) -> slice::Iter<'a, TemplateItem> {

     

       42
       42
       +
               self.template.iter()

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
           pub fn into_iter<'a>(self) -> vec::IntoIter<TemplateItem> {

     

       46
       46
       +
               self.template.into_iter()

     

       47
       47
       +
           }

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       impl fmt::Display for Template {

     

       51
       51
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       52
       52
       +
               for p in self.iter() {

     

       53
       53
       +
                   write!(f, "{}", p)?;

     

       54
       54
       +
               }

     

       55
       55
       +
               Ok(())

     

       56
       56
       +
           }

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       #[cfg(test)]

     

       60
       60
       +
       mod tests {

     

       61
       61
       +
           use super::*;

     

       62
       62
       +
       

     

       63
       63
       +
           #[test]

     

       64
       64
       +
           fn test_display_base() {

     

       65
       65
       +
               assert_eq!(

     

       66
       66
       +
                   Template::new(vec![

     

       67
       67
       +
                       TemplateItem::Base(Base::I),

     

       68
       68
       +
                       TemplateItem::Base(Base::C),

     

       69
       69
       +
                       TemplateItem::Base(Base::F),

     

       70
       70
       +
                       TemplateItem::Base(Base::P)

     

       71
       71
       +
                   ])

     

       72
       72
       +
                   .to_string(),

     

       73
       73
       +
                   "ICFP"

     

       74
       74
       +
               );

     

       75
       75
       +
           }

     

       76
       76
       +
       

     

       77
       77
       +
           #[test]

     

       78
       78
       +
           fn test_display_ref() {

     

       79
       79
       +
               assert_eq!(

     

       80
       80
       +
                   Template::new(vec![TemplateItem::Ref(3, 2), TemplateItem::Ref(4, 0),]).to_string(),

     

       81
       81
       +
                   "{3,2}{4}"

     

       82
       82
       +
               );

     

       83
       83
       +
           }

     

       84
       84
       +
       

     

       85
       85
       +
           #[test]

     

       86
       86
       +
           fn test_display_lenf() {

     

       87
       87
       +
               assert_eq!(Template::new(vec![TemplateItem::Len(3)]).to_string(), "|3|");

     

       88
       88
       +
           }

     

       89
       89
       +
       }

+20

generate_crate_rule.py

···

       1
       1
       +
       import sys

     

       2
       2
       +
       

     

       3
       3
       +
       # 'lib' or 'bin'

     

       4
       4
       +
       crate_type = sys.argv[1]

     

       5
       5
       +
       crate_name = sys.argv[2]

     

       6
       6
       +
       if crate_type == "bin":

     

       7
       7
       +
           input_rs = f"{crate_name}/src/main.rs"

     

       8
       8
       +
           outfile = f"out/bin/{crate_name}"

     

       9
       9
       +
       else:

     

       10
       10
       +
           input_rs = f"{crate_name}/src/lib.rs"

     

       11
       11
       +
           outfile = f"out/lib/lib{crate_name}.rlib"

     

       12
       12
       +
       

     

       13
       13
       +
       dep_crates = sys.argv[3:]

     

       14
       14
       +
       dep_inputs = " ".join([f"out/lib/lib{dep}.rlib" for dep in dep_crates])

     

       15
       15
       +
       externs = " ".join([f"--extern {dep}=out/lib/lib{dep}.rlib" for dep in dep_crates])

     

       16
       16
       +
       

     

       17
       17
       +
       flags = "--edition=2024 -C opt-level=3 -C embed-bitcode=no -C strip=debuginfo --emit=link"

     

       18
       18
       +
       

     

       19
       19
       +
       inputs = f"{crate_name}/src/*.rs"

     

       20
       20
       +
       print(f": {crate_name}/src/*.rs {dep_inputs} |> rustc --crate-name {crate_name} --crate-type={crate_type} {input_rs} -o %o {externs} {flags} |> {outfile}")

Compare changes