···

       
1
       
1
       
 
       
task/endo.dna

     

       
2
       
2
       
 
       
.tup/

     

       
3
       
3
       
-
       
out/
     

       
3
       
3
       
+
       
/out/
     

···

       
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

     

···

       
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
       
+
       
)

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{9,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{9,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{10,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{10,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{11,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{11,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{12,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{12,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{13,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{13,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{1,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{1,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{2,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{2,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{3,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{3,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{4,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{4,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{5,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{5,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{6,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{6,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{7,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{7,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{42,24} ;

     

       
2
       
2
       
-
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; "0"n{8,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{42,24} ;

     

       
2
       
2
       
+
       
(?{IFPICFPPCFFPP}!{0x503})n{0,24} ; {0}n{8,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})II ; "0"IC ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})II ; {0}IC ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{1337,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{1337,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{10646,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{10646,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{85,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{85,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{1729,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{1729,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{5,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{5,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{8,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{8,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{123456,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{123456,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{4405829,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{4405829,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{112,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{112,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})n{0,24} ; "0"n{2181889,24} ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})n{0,24} ; {0}n{2181889,24} ;

     

···

       
1
       
1
       
-
       
(?{IFPCFFP})I ; "0"C ;

     

       
1
       
1
       
+
       
(?{IFPCFFP})I ; {0}C ;

     

···

       
1
       
1
       
-
       
(?{IFPFI})P ; "0"F ;

     

       
1
       
1
       
+
       
(?{IFPFI})P ; {0}F ;

     

···

       
1
       
1
       
-
       
(?{IFPP})F ; "0"P ;

     

       
1
       
1
       
+
       
(?{IFPP})F ; {0}P ;

     

···

       
134
       
134
       
 
       
                Some('(') => self.emit("IIP"),

     

       
135
       
135
       
 
       
                Some(')') => self.emit("IIC"),

     

       
136
       
136
       
 
       
                Some(';') => self.emit("IIC"),

     

       
137
       
137
       
-
       
                Some('"') => {

     

       
138
       
138
       
-
       
                    let n = self.read_to("\",").ok_or("Reference failed terminate")?;

     

       
137
       
137
       
+
       
                Some('{') => {

     

       
138
       
138
       
+
       
                    let n = self.read_to("},").ok_or("Reference failed terminate")?;

     

       
139
       
139
       
 
       
                    let n = Self::parse_int(&n).ok_or("Reference group index invalid")?;

     

       
140
       
140
       
 
       
                    let l = match self.iter.next() {

     

       
141
       
141
       
-
       
                        Some('"') => String::from("0"),

     

       
141
       
141
       
+
       
                        Some('}') => String::from("0"),

     

       
142
       
142
       
 
       
                        Some(',') => {

     

       
143
       
143
       
-
       
                            let l = self.read_to("\"").ok_or("Reference failed to terminate")?;

     

       
144
       
144
       
-
       
                            self.expect('"');

     

       
143
       
143
       
+
       
                            let l = self.read_to("}").ok_or("Reference failed to terminate")?;

     

       
144
       
144
       
+
       
                            self.expect('}');

     

       
145
       
145
       
 
       
                            l

     

       
146
       
146
       
 
       
                        }

     

       
147
       
147
       
 
       
                        _ => return Err("Reference failed to terminate"),

     
···

       
227
       
227
       
 
       


     

       
228
       
228
       
 
       
    #[test]

     

       
229
       
229
       
 
       
    fn test_assemble_pattern_quote() {

     

       
230
       
230
       
-
       
        let asm = assemble(&"\"2\"").unwrap();

     

       
230
       
230
       
+
       
        let asm = assemble(&"{2}").unwrap();

     

       
231
       
231
       
 
       
        assert_eq!(b"IPPICP", &asm[..]);

     

       
232
       
232
       
 
       


     

       
233
       
233
       
-
       
        let asm = assemble(&"\"2,3\"").unwrap();

     

       
233
       
233
       
+
       
        let asm = assemble(&"{2,3}").unwrap();

     

       
234
       
234
       
 
       
        assert_eq!(b"IPCCPICP", &asm[..]);

     

       
235
       
235
       
 
       
    }

     

       
236
       
236
       
 
       


     

···

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

     

···

       
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"

     

···

       
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" }

     

···

       
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
       
+
       
}

     

···

       
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"

     

···

       
4
       
4
       
 
       
edition = "2024"

     

       
5
       
5
       
 
       


     

       
6
       
6
       
 
       
[dependencies]

     

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

···

       
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 {

     

···

       
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;

     

···

       
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,

     

       
11
       
11
       
 
       
    groups: Vec<(usize, usize)>,

     

       
12
       
12
       
 
       
}

     

       
13
       
13
       
 
       


     

       
14
       
14
       
-
       
fn do_match(dna: &DnaRef, start: usize, pattern: &Pattern) -> Option<MatchResult> {

     

       
14
       
14
       
+
       
fn do_match(dna: &DnaRef, start: usize, pattern: Pattern) -> Option<MatchResult> {

     

       
15
       
15
       
 
       
    let mut index = start;

     

       
16
       
16
       
 
       
    let mut env = Vec::new();

     

       
17
       
17
       
 
       
    let mut opens = Vec::new();

     

       
18
       
18
       
-
       
    for p in pattern.iter() {

     

       
18
       
18
       
+
       
    for p in pattern.into_iter() {

     

       
19
       
19
       
 
       
        match p {

     

       
20
       
20
       
 
       
            PatternItem::Base(b) => {

     

       
21
       
21
       
-
       
                if index >= dna.len() || dna[index] != *b {

     

       
21
       
21
       
+
       
                if index >= dna.len() || dna[index] != b {

     

       
22
       
22
       
 
       
                    return None;

     

       
23
       
23
       
 
       
                }

     

       
24
       
24
       
 
       


     
···

       
123
       
123
       
 
       
    let template = parser.template(rna)?;

     

       
124
       
124
       
 
       
    let index = parser.index();

     

       
125
       
125
       
 
       


     

       
126
       
126
       
-
       
    if let Some(matched) = do_match(&dna, index, &pattern) {

     

       
126
       
126
       
+
       
    if let Some(matched) = do_match(&dna, index, pattern) {

     

       
127
       
127
       
 
       
        let mut replace = DnaRef::new();

     

       
128
       
128
       
 
       
        for t in template.into_iter() {

     

       
129
       
129
       
 
       
            match t {

     

···

       
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(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(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(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(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(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(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(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
       
-
       
}

     

···

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

     

       
2
       
2
       
-
       


     

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

     

       
4
       
4
       
-
       
pub enum PatternItem {

     

       
5
       
5
       
-
       
    Base(Base),

     

       
6
       
6
       
-
       
    Skip(usize),

     

       
7
       
7
       
-
       
    Search(Vec<Base>),

     

       
8
       
8
       
-
       
    Open,

     

       
9
       
9
       
-
       
    Close,

     

       
10
       
10
       
-
       
}

     

       
11
       
11
       
-
       


     

       
12
       
12
       
-
       
pub type Pattern = Vec<PatternItem>;

     

···

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

     

       
2
       
2
       
-
       


     

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

     

···

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

     

       
2
       
2
       
-
       


     

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

     

       
4
       
4
       
-
       
pub enum TemplateItem {

     

       
5
       
5
       
-
       
    Base(Base),

     

       
6
       
6
       
-
       
    Ref(usize, usize),

     

       
7
       
7
       
-
       
    Len(usize),

     

       
8
       
8
       
-
       
}

     

       
9
       
9
       
-
       


     

       
10
       
10
       
-
       
pub type Template = Vec<TemplateItem>;

     

···

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

     

···

       
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"

     

···

       
1
       
1
       
+
       
[package]

     

       
2
       
2
       
+
       
name = "dna_parsing"

     

       
3
       
3
       
+
       
version = "0.1.0"

     

       
4
       
4
       
+
       
edition = "2024"

     

       
5
       
5
       
+
       


     

       
6
       
6
       
+
       
[dependencies]

     

···

       
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
       
+
       
}

     

···

       
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;

     

···

       
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
       
+
       
}