comparing f1bfe6734db80c7482e9ec331e9f7399f5acc016 and main on drubery.com/icfp2007

+2 -2

.gitignore

···

       1
       1
        
       task/endo.dna

     

       2
       2
       -
       

     

       3
       3
       -
       dna2rna/target/
     

       2
       2
       +
       .tup/

     

       3
       3
       +
       /out/

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

asm/empty.asm

This is a binary file and will not be displayed.

+1

asm/gene_list_1.asm

···

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

+2

asm/gene_list_10.asm

···

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

     

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

+2

asm/gene_list_11.asm

···

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

     

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

+2

asm/gene_list_12.asm

···

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

     

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

+2

asm/gene_list_13.asm

···

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

     

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

+2

asm/gene_list_14.asm

···

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

     

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

+2

asm/gene_list_2.asm

···

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

     

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

+2

asm/gene_list_3.asm

···

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

     

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

+2

asm/gene_list_4.asm

···

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

     

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

+2

asm/gene_list_5.asm

···

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

     

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

+2

asm/gene_list_6.asm

···

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

     

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

+2

asm/gene_list_7.asm

···

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

     

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

+2

asm/gene_list_8.asm

···

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

     

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

+2

asm/gene_list_9.asm

···

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

     

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

+1

asm/repair_guide.asm

···

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

+1

asm/repair_guide_catalog.asm

···

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

+1

asm/repair_guide_charset.asm

···

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

+1

asm/repair_guide_field_repair.asm

···

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

+1

asm/repair_guide_genome_structure.asm

···

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

+1

asm/repair_guide_l_systems.asm

···

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

+1

asm/repair_guide_more_genome_structure.asm

···

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

+1

asm/repair_guide_rna_compression.asm

···

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

+1

asm/repair_guide_security.asm

···

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

+1

asm/repair_guide_wanted.asm

···

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

+1

asm/repair_guide_weird_rna.asm

···

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

+1

asm/startup.asm

···

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

+1

asm/sun.asm

···

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

+1

asm/task.asm

···

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

+1

asm2dna/.dir-locals.el

···

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

+7

asm2dna/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 = "asm2dna"

     

       7
       7
       +
       version = "0.1.0"

+6

asm2dna/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "asm2dna"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+251

asm2dna/src/assembler.rs

···

       1
       1
       +
       use std::iter::Peekable;

     

       2
       2
       +
       use std::str::Chars;

     

       3
       3
       +
       

     

       4
       4
       +
       pub type Error = &'static str;

     

       5
       5
       +
       

     

       6
       6
       +
       pub fn assemble(asm: &str) -> Result<Vec<u8>, Error> {

     

       7
       7
       +
           Assembler::new(asm).assemble()

     

       8
       8
       +
       }

     

       9
       9
       +
       

     

       10
       10
       +
       struct Assembler<'a> {

     

       11
       11
       +
           iter: Peekable<Chars<'a>>,

     

       12
       12
       +
           output: Vec<u8>,

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       enum IntPadding {

     

       16
       16
       +
           NoPadding,

     

       17
       17
       +
           PaddedTo(usize),

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       impl<'a> Assembler<'a> {

     

       21
       21
       +
           fn new(buf: &'a str) -> Assembler<'a> {

     

       22
       22
       +
               Assembler {

     

       23
       23
       +
                   iter: buf.chars().peekable(),

     

       24
       24
       +
                   output: Vec::new(),

     

       25
       25
       +
               }

     

       26
       26
       +
           }

     

       27
       27
       +
       

     

       28
       28
       +
           fn expect(&mut self, c: char) -> Option<()> {

     

       29
       29
       +
               match self.iter.next() {

     

       30
       30
       +
                   Some(d) => {

     

       31
       31
       +
                       if c == d {

     

       32
       32
       +
                           Some(())

     

       33
       33
       +
                       } else {

     

       34
       34
       +
                           None

     

       35
       35
       +
                       }

     

       36
       36
       +
                   }

     

       37
       37
       +
                   None => None,

     

       38
       38
       +
               }

     

       39
       39
       +
           }

     

       40
       40
       +
       

     

       41
       41
       +
           fn emit(&mut self, s: &str) {

     

       42
       42
       +
               self.output.extend_from_slice(s.as_bytes());

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
           fn read_to(&mut self, any_of: &str) -> Option<String> {

     

       46
       46
       +
               let mut s = String::new();

     

       47
       47
       +
               loop {

     

       48
       48
       +
                   if let Some(c) = self.iter.peek()

     

       49
       49
       +
                       && any_of.contains(*c)

     

       50
       50
       +
                   {

     

       51
       51
       +
                       return Some(s);

     

       52
       52
       +
                   }

     

       53
       53
       +
       

     

       54
       54
       +
                   match self.iter.next() {

     

       55
       55
       +
                       Some(c) => s.push(c),

     

       56
       56
       +
                       None => return None,

     

       57
       57
       +
                   }

     

       58
       58
       +
               }

     

       59
       59
       +
           }

     

       60
       60
       +
       

     

       61
       61
       +
           fn parse_int(s: &str) -> Option<usize> {

     

       62
       62
       +
               let is_hex = s.starts_with("0x");

     

       63
       63
       +
               let base = if is_hex { 16 } else { 10 };

     

       64
       64
       +
               let mut ret = 0;

     

       65
       65
       +
               let mut iter = s.chars();

     

       66
       66
       +
               if is_hex {

     

       67
       67
       +
                   iter.nth(1);

     

       68
       68
       +
               }

     

       69
       69
       +
       

     

       70
       70
       +
               for c in iter {

     

       71
       71
       +
                   ret *= base;

     

       72
       72
       +
                   ret += c.to_digit(base)?;

     

       73
       73
       +
               }

     

       74
       74
       +
       

     

       75
       75
       +
               return Some(ret as usize);

     

       76
       76
       +
           }

     

       77
       77
       +
       

     

       78
       78
       +
           fn encode_int(mut n: usize, p: IntPadding) -> String {

     

       79
       79
       +
               let mut s = String::new();

     

       80
       80
       +
               while n > 0 {

     

       81
       81
       +
                   if n % 2 == 1 {

     

       82
       82
       +
                       s += "C";

     

       83
       83
       +
                   } else {

     

       84
       84
       +
                       s += "I";

     

       85
       85
       +
                   }

     

       86
       86
       +
       

     

       87
       87
       +
                   n /= 2;

     

       88
       88
       +
               }

     

       89
       89
       +
       

     

       90
       90
       +
               if let IntPadding::PaddedTo(p) = p {

     

       91
       91
       +
                   for _ in s.len()..(p - 1) {

     

       92
       92
       +
                       s += "I";

     

       93
       93
       +
                   }

     

       94
       94
       +
               }

     

       95
       95
       +
       

     

       96
       96
       +
               s += "P";

     

       97
       97
       +
               return s;

     

       98
       98
       +
           }

     

       99
       99
       +
       

     

       100
       100
       +
           fn emit_consts(&mut self, s: &str) {

     

       101
       101
       +
               for c in s.chars() {

     

       102
       102
       +
                   match c {

     

       103
       103
       +
                       'I' => self.emit("C"),

     

       104
       104
       +
                       'C' => self.emit("F"),

     

       105
       105
       +
                       'F' => self.emit("P"),

     

       106
       106
       +
                       'P' => self.emit("IC"),

     

       107
       107
       +
                       _ => {}

     

       108
       108
       +
                   }

     

       109
       109
       +
               }

     

       110
       110
       +
           }

     

       111
       111
       +
       

     

       112
       112
       +
           fn assemble(mut self) -> Result<Vec<u8>, Error> {

     

       113
       113
       +
               loop {

     

       114
       114
       +
                   match self.iter.next() {

     

       115
       115
       +
                       Some('I') => self.emit("C"),

     

       116
       116
       +
                       Some('C') => self.emit("F"),

     

       117
       117
       +
                       Some('F') => self.emit("P"),

     

       118
       118
       +
                       Some('P') => self.emit("IC"),

     

       119
       119
       +
                       Some('!') => {

     

       120
       120
       +
                           self.expect('{').ok_or("Skip followed by non-{")?;

     

       121
       121
       +
                           let n = self.read_to("}").ok_or("Skip failed to terminate")?;

     

       122
       122
       +
                           let n = Self::parse_int(&n).ok_or("Invalid int inside skip")?;

     

       123
       123
       +
                           self.emit("IP");

     

       124
       124
       +
                           self.emit(&Self::encode_int(n, IntPadding::NoPadding));

     

       125
       125
       +
                           self.expect('}').ok_or("Skip failed to terminate")?;

     

       126
       126
       +
                       }

     

       127
       127
       +
                       Some('?') => {

     

       128
       128
       +
                           self.expect('{').ok_or("Search followed by non-?")?;

     

       129
       129
       +
                           let s = self.read_to("}").ok_or("Search failed to terminate")?;

     

       130
       130
       +
                           self.emit("IFF");

     

       131
       131
       +
                           self.emit_consts(&s);

     

       132
       132
       +
                           self.expect('}').ok_or("Search failed to terminate")?;

     

       133
       133
       +
                       }

     

       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")?;

     

       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"),

     

       142
       142
       +
                               Some(',') => {

     

       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"),

     

       148
       148
       +
                           };

     

       149
       149
       +
                           let l = Self::parse_int(&l).ok_or("Reference level invalid")?;

     

       150
       150
       +
                           self.emit("IP");

     

       151
       151
       +
                           self.emit(&Self::encode_int(l, IntPadding::NoPadding));

     

       152
       152
       +
                           self.emit(&Self::encode_int(n, IntPadding::NoPadding));

     

       153
       153
       +
                       }

     

       154
       154
       +
                       Some('|') => {

     

       155
       155
       +
                           let n = self.read_to("|").ok_or("Length failed to terminate")?;

     

       156
       156
       +
                           let n = Self::parse_int(&n).ok_or("Length group index invalid")?;

     

       157
       157
       +
                           self.emit("IIP");

     

       158
       158
       +
                           self.emit(&Self::encode_int(n, IntPadding::NoPadding));

     

       159
       159
       +
                           self.expect('|').ok_or("Length failed to terminate")?;

     

       160
       160
       +
                       }

     

       161
       161
       +
                       Some('n') => {

     

       162
       162
       +
                           self.expect('{');

     

       163
       163
       +
                           let n = self

     

       164
       164
       +
                               .read_to("},")

     

       165
       165
       +
                               .ok_or("Int constant failed to terminate")?;

     

       166
       166
       +
                           let n = Self::parse_int(&n).ok_or("Int constant invalid")?;

     

       167
       167
       +
                           match self.iter.next() {

     

       168
       168
       +
                               Some('}') => {

     

       169
       169
       +
                                   self.emit(&Self::encode_int(n, IntPadding::NoPadding));

     

       170
       170
       +
                               }

     

       171
       171
       +
                               Some(',') => {

     

       172
       172
       +
                                   let pad = self

     

       173
       173
       +
                                       .read_to("}")

     

       174
       174
       +
                                       .ok_or("Int constant failed to terminate")?;

     

       175
       175
       +
                                   let pad =

     

       176
       176
       +
                                       Self::parse_int(&pad).ok_or("Int constant padding invalid")?;

     

       177
       177
       +
                                   self.emit_consts(&Self::encode_int(n, IntPadding::PaddedTo(pad)));

     

       178
       178
       +
                                   self.expect('}').ok_or("Int constant failed to terminate")?;

     

       179
       179
       +
                               }

     

       180
       180
       +
                               _ => return Err("Int constant failed to terminate"),

     

       181
       181
       +
                           };

     

       182
       182
       +
                       }

     

       183
       183
       +
                       Some(' ') | Some('\n') => {}

     

       184
       184
       +
                       None => return Ok(self.output),

     

       185
       185
       +
                       Some(c) => {

     

       186
       186
       +
                           println!("{}", c);

     

       187
       187
       +
                           return Err("Invalid character");

     

       188
       188
       +
                       }

     

       189
       189
       +
                   }

     

       190
       190
       +
               }

     

       191
       191
       +
           }

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       #[cfg(test)]

     

       195
       195
       +
       mod tests {

     

       196
       196
       +
           use super::*;

     

       197
       197
       +
       

     

       198
       198
       +
           #[test]

     

       199
       199
       +
           fn test_assemble_bases() {

     

       200
       200
       +
               let asm = assemble(&"ICFP").unwrap();

     

       201
       201
       +
               assert_eq!(b"CFPIC", &asm[..]);

     

       202
       202
       +
           }

     

       203
       203
       +
       

     

       204
       204
       +
           #[test]

     

       205
       205
       +
           fn test_assemble_skip() {

     

       206
       206
       +
               let asm = assemble(&"!{1} !{0x10}").unwrap();

     

       207
       207
       +
               assert_eq!(b"IPCPIPIIIICP", &asm[..]);

     

       208
       208
       +
           }

     

       209
       209
       +
       

     

       210
       210
       +
           #[test]

     

       211
       211
       +
           fn test_assemble_search() {

     

       212
       212
       +
               let asm = assemble(&"?{ICFP}").unwrap();

     

       213
       213
       +
               assert_eq!(b"IFFCFPIC", &asm[..]);

     

       214
       214
       +
           }

     

       215
       215
       +
       

     

       216
       216
       +
           #[test]

     

       217
       217
       +
           fn test_assemble_groups() {

     

       218
       218
       +
               let asm = assemble(&"()()").unwrap();

     

       219
       219
       +
               assert_eq!(b"IIPIICIIPIIC", &asm[..]);

     

       220
       220
       +
           }

     

       221
       221
       +
       

     

       222
       222
       +
           #[test]

     

       223
       223
       +
           fn test_assemble_pattern_template() {

     

       224
       224
       +
               let asm = assemble(&"!{2} ; II ;").unwrap();

     

       225
       225
       +
               assert_eq!(b"IPICPIICCCIIC", &asm[..]);

     

       226
       226
       +
           }

     

       227
       227
       +
       

     

       228
       228
       +
           #[test]

     

       229
       229
       +
           fn test_assemble_pattern_quote() {

     

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

     

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

     

       232
       232
       +
       

     

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

     

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

     

       235
       235
       +
           }

     

       236
       236
       +
       

     

       237
       237
       +
           #[test]

     

       238
       238
       +
           fn test_assemble_pattern_length() {

     

       239
       239
       +
               let asm = assemble(&"|3|").unwrap();

     

       240
       240
       +
               assert_eq!(b"IIPCCP", &asm[..]);

     

       241
       241
       +
           }

     

       242
       242
       +
       

     

       243
       243
       +
           #[test]

     

       244
       244
       +
           fn test_assemble_pattern_constant() {

     

       245
       245
       +
               let asm = assemble(&"n{4,5}").unwrap();

     

       246
       246
       +
               assert_eq!(b"CCFCIC", &asm[..]);

     

       247
       247
       +
       

     

       248
       248
       +
               let asm = assemble(&"n{0x123,24}").unwrap();

     

       249
       249
       +
               assert_eq!(b"FFCCCFCCFCCCCCCCCCCCCCCIC", &asm[..]);

     

       250
       250
       +
           }

     

       251
       251
       +
       }

+23

asm2dna/src/main.rs

···

       1
       1
       +
       mod assembler;

     

       2
       2
       +
       

     

       3
       3
       +
       use std::env;

     

       4
       4
       +
       use std::fs;

     

       5
       5
       +
       

     

       6
       6
       +
       fn main() {

     

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

     

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

     

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

     

       10
       10
       +
               return;

     

       11
       11
       +
           }

     

       12
       12
       +
       

     

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

     

       14
       14
       +
               println!("Failed to open asm file at {}", &args[1]);

     

       15
       15
       +
               return;

     

       16
       16
       +
           };

     

       17
       17
       +
           match assembler::assemble(&asm) {

     

       18
       18
       +
               Ok(dna) => {

     

       19
       19
       +
                   let _ = fs::write(&args[2], dna);

     

       20
       20
       +
               }

     

       21
       21
       +
               Err(err) => println!("{}", err),

     

       22
       22
       +
           }

     

       23
       23
       +
       }

+1

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"

+7

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

+7

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"

+1

dna2rna/Cargo.toml

···

       4
       4
        
       edition = "2024"

     

       5
       5
        
       

     

       6
       6
        
       [dependencies]

     

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

+83 -50

dna2rna/src/dna.rs

···

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

     

       1
       2
        
       use std::collections::VecDeque;

     

       2
       3
        
       use std::ops::Add;

     

       4
       4
       +
       use std::ops::AddAssign;

     

       3
       5
        
       use std::ops::Deref;

     

       4
       6
        
       use std::ops::Index;

     

       5
       7
        
       use std::rc::Rc;

     

       6
       6
       -
       

     

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

     

       8
       8
       -
       pub enum Base {

     

       9
       9
       -
           I,

     

       10
       10
       -
           C,

     

       11
       11
       -
           F,

     

       12
       12
       -
           P,

     

       13
       13
       -
       }

     

       14
       8
        
       

     

       15
       9
        
       #[derive(Clone, Debug)]

     

       16
       10
        
       pub enum Dna {

     
···

       40
       34
        
           children: (DnaRef, DnaRef, DnaRef),

     

       41
       35
        
       }

     

       42
       36
        
       

     

       43
       43
       -
       impl Base {

     

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

     

       45
       45
       -
               match c {

     

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

     

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

     

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

     

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

     

       50
       50
       -
                   _ => None,

     

       51
       51
       -
               }

     

       52
       52
       -
           }

     

       53
       53
       -
       

     

       54
       54
       -
           fn to_char(&self) -> char {

     

       55
       55
       -
               match self {

     

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

     

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

     

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

     

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

     

       60
       60
       -
               }

     

       61
       61
       -
           }

     

       62
       62
       -
       }

     

       63
       63
       -
       

     

       64
       37
        
       impl DnaRef {

     

       65
       38
        
           pub fn new() -> Self {

     

       66
       39
        
               Self::DnaRef(Rc::new(Dna::Empty))

     

       67
       40
        
           }

     

       68
       41
        
       

     

       69
       69
       -
           fn from_base(b: Base) -> Self {

     

       42
       42
       +
           pub fn from_base(b: Base) -> Self {

     

       70
       43
        
               Self::DnaRef(Rc::new(Dna::Leaf(b)))

     

       71
       44
        
           }

     

       72
       45
        
       

     
···

       135
       108
        
                       let (a, b) = &node.children;

     

       136
       109
        
                       if n < a.len() {

     

       137
       110
        
                           let (x, y) = a.split(n);

     

       138
       138
       -
                           (x, y + b.clone())

     

       111
       111
       +
                           (x, y + b)

     

       139
       112
        
                       } else if n == a.len() {

     

       140
       113
        
                           (a.clone(), b.clone())

     

       141
       114
        
                       } else {

     

       142
       115
        
                           let (x, y) = b.split(n - a.len());

     

       143
       143
       -
                           (a.clone() + x, y)

     

       116
       116
       +
                           (a + x, y)

     

       144
       117
        
                       }

     

       145
       118
        
                   }

     

       146
       119
        
                   Dna::ThreeNode(node) => {

     

       147
       120
        
                       let (a, b, c) = &node.children;

     

       148
       121
        
                       if n < a.len() {

     

       149
       122
        
                           let (x, y) = a.split(n);

     

       150
       150
       -
                           (x, y + b.clone() + c.clone())

     

       123
       123
       +
                           (x, y + b + c)

     

       151
       124
        
                       } else if n == a.len() {

     

       152
       152
       -
                           (a.clone(), b.clone() + c.clone())

     

       125
       125
       +
                           (a.clone(), b + c)

     

       153
       126
        
                       } else if n - a.len() < b.len() {

     

       154
       127
        
                           let (x, y) = b.split(n - a.len());

     

       155
       155
       -
                           (a.clone() + x, y + c.clone())

     

       128
       128
       +
                           (a + x, y + c)

     

       156
       129
        
                       } else if n == a.len() + b.len() {

     

       157
       157
       -
                           (a.clone() + b.clone(), c.clone())

     

       130
       130
       +
                           (a + b, c.clone())

     

       158
       131
        
                       } else {

     

       159
       132
        
                           let (x, y) = c.split(n - a.len() - b.len());

     

       160
       160
       -
                           (a.clone() + b.clone() + x, y)

     

       133
       133
       +
                           (a + b + x, y)

     

       161
       134
        
                       }

     

       162
       135
        
                   }

     

       163
       136
        
               }

     

       164
       137
        
           }

     

       165
       138
        
       

     

       139
       139
       +
           #[cfg(test)]

     

       166
       140
        
           pub fn to_string(&self) -> String {

     

       167
       141
        
               self.iter().map(|b| Base::to_char(&b)).collect::<String>()

     

       168
       142
        
           }

     
···

       280
       254
        
           Two(DnaRef, DnaRef),

     

       281
       255
        
       }

     

       282
       256
        
       

     

       283
       283
       -
       fn add_helper(lhs: DnaRef, rhs: DnaRef) -> AddState {

     

       257
       257
       +
       fn add_helper(lhs: &DnaRef, rhs: &DnaRef) -> AddState {

     

       284
       258
        
           if lhs.depth() == rhs.depth() {

     

       285
       285
       -
               AddState::Two(lhs, rhs)

     

       259
       259
       +
               AddState::Two(lhs.clone(), rhs.clone())

     

       286
       260
        
           } else if lhs.depth() < rhs.depth() {

     

       287
       287
       -
               match &*rhs {

     

       261
       261
       +
               match &**rhs {

     

       288
       262
        
                   Dna::Empty => unreachable!(),

     

       289
       289
       -
                   Dna::Leaf(_) => AddState::One(rhs),

     

       263
       263
       +
                   Dna::Leaf(_) => AddState::One(rhs.clone()),

     

       290
       264
        
                   Dna::TwoNode(node) => {

     

       291
       265
        
                       let (a, b) = &node.children;

     

       292
       292
       -
                       match add_helper(lhs, a.clone()) {

     

       266
       266
       +
                       match add_helper(lhs, a) {

     

       293
       267
        
                           AddState::One(x) => AddState::One(DnaRef::from_two_children(x, b.clone())),

     

       294
       268
        
                           AddState::Two(x, y) => {

     

       295
       269
        
                               AddState::One(DnaRef::from_three_children(x, y, b.clone()))

     
···

       298
       272
        
                   }

     

       299
       273
        
                   Dna::ThreeNode(node) => {

     

       300
       274
        
                       let (a, b, c) = &node.children;

     

       301
       301
       -
                       match add_helper(lhs, a.clone()) {

     

       275
       275
       +
                       match add_helper(lhs, a) {

     

       302
       276
        
                           AddState::One(x) => {

     

       303
       277
        
                               AddState::One(DnaRef::from_three_children(x, b.clone(), c.clone()))

     

       304
       278
        
                           }

     
···

       310
       284
        
                   }

     

       311
       285
        
               }

     

       312
       286
        
           } else {

     

       313
       313
       -
               match &*lhs {

     

       287
       287
       +
               match &**lhs {

     

       314
       288
        
                   Dna::Empty => unreachable!(),

     

       315
       289
        
                   Dna::Leaf(_) => AddState::One(lhs.clone()),

     

       316
       290
        
                   Dna::TwoNode(node) => {

     

       317
       291
        
                       let (a, b) = &node.children;

     

       318
       318
       -
                       match add_helper(b.clone(), rhs) {

     

       292
       292
       +
                       match add_helper(b, rhs) {

     

       319
       293
        
                           AddState::One(x) => AddState::One(DnaRef::from_two_children(a.clone(), x)),

     

       320
       294
        
                           AddState::Two(x, y) => {

     

       321
       295
        
                               AddState::One(DnaRef::from_three_children(a.clone(), x, y))

     
···

       324
       298
        
                   }

     

       325
       299
        
                   Dna::ThreeNode(node) => {

     

       326
       300
        
                       let (a, b, c) = &node.children;

     

       327
       327
       -
                       match add_helper(c.clone(), rhs) {

     

       301
       301
       +
                       match add_helper(c, rhs) {

     

       328
       302
        
                           AddState::One(x) => {

     

       329
       303
        
                               AddState::One(DnaRef::from_three_children(a.clone(), b.clone(), x))

     

       330
       304
        
                           }

     
···

       338
       312
        
           }

     

       339
       313
        
       }

     

       340
       314
        
       

     

       341
       341
       -
       impl Add for DnaRef {

     

       342
       342
       -
           type Output = Self;

     

       315
       315
       +
       impl Add<DnaRef> for DnaRef {

     

       316
       316
       +
           type Output = DnaRef;

     

       317
       317
       +
       

     

       318
       318
       +
           fn add(self, other: DnaRef) -> DnaRef {

     

       319
       319
       +
               match add_helper(&self, &other) {

     

       320
       320
       +
                   AddState::One(a) => a,

     

       321
       321
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       322
       322
       +
               }

     

       323
       323
       +
           }

     

       324
       324
       +
       }

     

       325
       325
       +
       

     

       326
       326
       +
       impl Add<&DnaRef> for DnaRef {

     

       327
       327
       +
           type Output = DnaRef;

     

       328
       328
       +
       

     

       329
       329
       +
           fn add(self, other: &DnaRef) -> DnaRef {

     

       330
       330
       +
               match add_helper(&self, other) {

     

       331
       331
       +
                   AddState::One(a) => a,

     

       332
       332
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       333
       333
       +
               }

     

       334
       334
       +
           }

     

       335
       335
       +
       }

     

       343
       336
        
       

     

       344
       344
       -
           fn add(self, other: Self) -> Self {

     

       337
       337
       +
       impl Add<DnaRef> for &DnaRef {

     

       338
       338
       +
           type Output = DnaRef;

     

       339
       339
       +
       

     

       340
       340
       +
           fn add(self, other: DnaRef) -> DnaRef {

     

       341
       341
       +
               match add_helper(self, &other) {

     

       342
       342
       +
                   AddState::One(a) => a,

     

       343
       343
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       344
       344
       +
               }

     

       345
       345
       +
           }

     

       346
       346
       +
       }

     

       347
       347
       +
       

     

       348
       348
       +
       impl Add<&DnaRef> for &DnaRef {

     

       349
       349
       +
           type Output = DnaRef;

     

       350
       350
       +
       

     

       351
       351
       +
           fn add(self, other: &DnaRef) -> DnaRef {

     

       345
       352
        
               match add_helper(self, other) {

     

       346
       353
        
                   AddState::One(a) => a,

     

       347
       347
       -
                   AddState::Two(a, b) => Self::from_two_children(a, b),

     

       354
       354
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       355
       355
       +
               }

     

       356
       356
       +
           }

     

       357
       357
       +
       }

     

       358
       358
       +
       

     

       359
       359
       +
       impl AddAssign<DnaRef> for DnaRef {

     

       360
       360
       +
           fn add_assign(&mut self, other: DnaRef) {

     

       361
       361
       +
               match add_helper(self, &other) {

     

       362
       362
       +
                   AddState::One(a) => {

     

       363
       363
       +
                       *self = a;

     

       364
       364
       +
                   }

     

       365
       365
       +
                   AddState::Two(a, b) => {

     

       366
       366
       +
                       *self = Self::from_two_children(a, b);

     

       367
       367
       +
                   }

     

       368
       368
       +
               }

     

       369
       369
       +
           }

     

       370
       370
       +
       }

     

       371
       371
       +
       

     

       372
       372
       +
       impl AddAssign<&DnaRef> for DnaRef {

     

       373
       373
       +
           fn add_assign(&mut self, other: &DnaRef) {

     

       374
       374
       +
               match add_helper(self, other) {

     

       375
       375
       +
                   AddState::One(a) => {

     

       376
       376
       +
                       *self = a;

     

       377
       377
       +
                   }

     

       378
       378
       +
                   AddState::Two(a, b) => {

     

       379
       379
       +
                       *self = Self::from_two_children(a, b);

     

       380
       380
       +
                   }

     

       348
       381
        
               }

     

       349
       382
        
           }

     

       350
       383
        
       }

+45 -5

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
       -
       mod parser;

     

       3
       3
       -
       mod pattern;

     

       4
       4
       -
       mod template;

     

       2
       2
       +
       mod match_replace;

     

       3
       3
       +
       

     

       4
       4
       +
       use std::env;

     

       5
       5
       +
       use std::fs;

     

       6
       6
       +
       use std::fs::File;

     

       7
       7
       +
       use std::io::Write;

     

       5
       8
        
       

     

       6
       9
        
       fn main() {

     

       7
       7
       -
           let dna = dna::DnaRef::from_string("ICFP");

     

       8
       8
       -
           println!("Back to string: {}", dna.to_string());

     

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

     

       11
       11
       +
           if args.len() < 4 {

     

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

     

       13
       13
       +
               return;

     

       14
       14
       +
           }

     

       15
       15
       +
       

     

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

     

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

     

       18
       18
       +
               return;

     

       19
       19
       +
           };

     

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

     

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

     

       22
       22
       +
               return;

     

       23
       23
       +
           };

     

       24
       24
       +
       

     

       25
       25
       +
           let mut dna = dna::DnaRef::from_string(&prefix) + dna::DnaRef::from_string(&dna);

     

       26
       26
       +
           let Ok(mut rna_file) = File::create(&args[3]) else {

     

       27
       27
       +
               println!("Failed to create rna output file at {}", &args[3]);

     

       28
       28
       +
               return;

     

       29
       29
       +
           };

     

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

     

       31
       31
       +
           loop {

     

       32
       32
       +
               if let Some(new_dna) = match_replace::match_replace(dna, &mut rna) {

     

       33
       33
       +
                   dna = new_dna;

     

       34
       34
       +
               } else {

     

       35
       35
       +
                   break;

     

       36
       36
       +
               }

     

       37
       37
       +
       

     

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

     

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

     

       40
       40
       +
                   // Just tolerate a write error.

     

       41
       41
       +
                   let _ = rna_file.write(rna_str.as_bytes());

     

       42
       42
       +
                   let _ = rna_file.write(b"\n");

     

       43
       43
       +
               }

     

       44
       44
       +
       

     

       45
       45
       +
               rna.clear();

     

       46
       46
       +
           }

     

       47
       47
       +
       

     

       48
       48
       +
           return;

     

       9
       49
        
       }

+280

dna2rna/src/match_replace.rs

···

       1
       1
       +
       use crate::dna::DnaRef;

     

       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> {

     

       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.into_iter() {

     

       19
       19
       +
               match p {

     

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

     

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

     

       22
       22
       +
                           return None;

     

       23
       23
       +
                       }

     

       24
       24
       +
       

     

       25
       25
       +
                       index += 1;

     

       26
       26
       +
                   }

     

       27
       27
       +
                   PatternItem::Skip(n) => {

     

       28
       28
       +
                       index += n;

     

       29
       29
       +
                       if index > dna.len() {

     

       30
       30
       +
                           return None;

     

       31
       31
       +
                       }

     

       32
       32
       +
                   }

     

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

     

       34
       34
       +
                       let mut fallback = Vec::new();

     

       35
       35
       +
                       fallback.reserve(s.len());

     

       36
       36
       +
                       fallback.push(0);

     

       37
       37
       +
                       fallback.push(0);

     

       38
       38
       +
                       for i in 2..s.len() {

     

       39
       39
       +
                           let mut j = fallback[i - 1];

     

       40
       40
       +
                           while j > 0 && s[j] != s[i - 1] {

     

       41
       41
       +
                               j = fallback[j];

     

       42
       42
       +
                           }

     

       43
       43
       +
                           if s[i - 1] == s[j] {

     

       44
       44
       +
                               fallback.push(j + 1);

     

       45
       45
       +
                           } else {

     

       46
       46
       +
                               fallback.push(0);

     

       47
       47
       +
                           }

     

       48
       48
       +
                       }

     

       49
       49
       +
       

     

       50
       50
       +
                       let mut cur = 0;

     

       51
       51
       +
                       loop {

     

       52
       52
       +
                           if cur == s.len() {

     

       53
       53
       +
                               break;

     

       54
       54
       +
                           } else if index >= dna.len() {

     

       55
       55
       +
                               return None;

     

       56
       56
       +
                           } else if dna[index] == s[cur] {

     

       57
       57
       +
                               index += 1;

     

       58
       58
       +
                               cur += 1;

     

       59
       59
       +
                           } else if cur == 0 {

     

       60
       60
       +
                               index += 1;

     

       61
       61
       +
                           } else {

     

       62
       62
       +
                               cur = fallback[cur];

     

       63
       63
       +
                           }

     

       64
       64
       +
                       }

     

       65
       65
       +
                   }

     

       66
       66
       +
                   PatternItem::Open => {

     

       67
       67
       +
                       opens.push(index);

     

       68
       68
       +
                   }

     

       69
       69
       +
                   PatternItem::Close => {

     

       70
       70
       +
                       let start = opens.pop()?;

     

       71
       71
       +
                       env.push((start, index));

     

       72
       72
       +
                   }

     

       73
       73
       +
               }

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           return Some(MatchResult {

     

       77
       77
       +
               end: index,

     

       78
       78
       +
               groups: env,

     

       79
       79
       +
           });

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       pub fn protect(dna: DnaRef, level: usize) -> DnaRef {

     

       83
       83
       +
           if level == 0 {

     

       84
       84
       +
               return dna;

     

       85
       85
       +
           }

     

       86
       86
       +
       

     

       87
       87
       +
           let mut cur = dna.clone();

     

       88
       88
       +
           for _ in 0..level {

     

       89
       89
       +
               cur = cur

     

       90
       90
       +
                   .iter()

     

       91
       91
       +
                   .flat_map(|b| match b {

     

       92
       92
       +
                       Base::I => [Base::C].iter(),

     

       93
       93
       +
                       Base::C => [Base::F].iter(),

     

       94
       94
       +
                       Base::F => [Base::P].iter(),

     

       95
       95
       +
                       Base::P => [Base::I, Base::C].iter(),

     

       96
       96
       +
                   })

     

       97
       97
       +
                   .map(|b| DnaRef::from_base(*b))

     

       98
       98
       +
                   .collect::<DnaRef>();

     

       99
       99
       +
           }

     

       100
       100
       +
       

     

       101
       101
       +
           return cur;

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       pub fn asnat(n: usize) -> DnaRef {

     

       105
       105
       +
           let mut v = Vec::new();

     

       106
       106
       +
           let mut cur = n;

     

       107
       107
       +
           while cur > 0 {

     

       108
       108
       +
               if cur % 2 == 1 {

     

       109
       109
       +
                   v.push(Base::C);

     

       110
       110
       +
               } else {

     

       111
       111
       +
                   v.push(Base::I);

     

       112
       112
       +
               }

     

       113
       113
       +
       

     

       114
       114
       +
               cur /= 2;

     

       115
       115
       +
           }

     

       116
       116
       +
           v.push(Base::P);

     

       117
       117
       +
           return v.iter().map(|b| DnaRef::from_base(*b)).collect::<DnaRef>();

     

       118
       118
       +
       }

     

       119
       119
       +
       

     

       120
       120
       +
       pub fn match_replace(dna: DnaRef, rna: &mut Vec<Rna>) -> Option<DnaRef> {

     

       121
       121
       +
           let mut parser = Parser::new(dna.iter());

     

       122
       122
       +
           let pattern = parser.pattern(rna)?;

     

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

     

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

     

       128
       128
       +
               for t in template.into_iter() {

     

       129
       129
       +
                   match t {

     

       130
       130
       +
                       TemplateItem::Base(b) => {

     

       131
       131
       +
                           replace += DnaRef::from_base(b);

     

       132
       132
       +
                       }

     

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

     

       134
       134
       +
                           if n < matched.groups.len() {

     

       135
       135
       +
                               let (start, end) = matched.groups[n];

     

       136
       136
       +
                               let (_, rhs) = dna.split(start);

     

       137
       137
       +
                               let (group, _) = rhs.split(end - start);

     

       138
       138
       +
                               replace += protect(group, l);

     

       139
       139
       +
                           } else {

     

       140
       140
       +
                               replace += protect(DnaRef::new(), l);

     

       141
       141
       +
                           }

     

       142
       142
       +
                       }

     

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

     

       144
       144
       +
                           if n < matched.groups.len() {

     

       145
       145
       +
                               let (start, end) = matched.groups[n];

     

       146
       146
       +
                               replace += asnat(end - start);

     

       147
       147
       +
                           } else {

     

       148
       148
       +
                               replace += asnat(0);

     

       149
       149
       +
                           }

     

       150
       150
       +
                       }

     

       151
       151
       +
                   }

     

       152
       152
       +
               }

     

       153
       153
       +
               let (_, remainder) = dna.split(matched.end);

     

       154
       154
       +
               return Some(replace + remainder);

     

       155
       155
       +
           } else {

     

       156
       156
       +
               let (_, rhs) = dna.split(index);

     

       157
       157
       +
               return Some(rhs);

     

       158
       158
       +
           }

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       161
       161
       +
       #[cfg(test)]

     

       162
       162
       +
       mod tests {

     

       163
       163
       +
           use super::*;

     

       164
       164
       +
       

     

       165
       165
       +
           #[test]

     

       166
       166
       +
           fn test_match_bases() {

     

       167
       167
       +
               // ICFP -> III on ICFP

     

       168
       168
       +
               let dna = DnaRef::from_string("CFPICIIC CCCIIC ICFP");

     

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

     

       170
       170
       +
               let res = match_replace(dna, &mut rna);

     

       171
       171
       +
               assert!(res.is_some());

     

       172
       172
       +
               assert_eq!(res.unwrap().to_string(), "III");

     

       173
       173
       +
           }

     

       174
       174
       +
       

     

       175
       175
       +
           #[test]

     

       176
       176
       +
           fn test_match_skip() {

     

       177
       177
       +
               // !{10} -> III on ICFPICFPICFP

     

       178
       178
       +
               let dna = DnaRef::from_string("IPICICPIIC CCCIIC ICFPICFPICFP");

     

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

     

       180
       180
       +
               let res = match_replace(dna, &mut rna);

     

       181
       181
       +
               assert!(res.is_some());

     

       182
       182
       +
               assert_eq!(res.unwrap().to_string(), "IIIFP");

     

       183
       183
       +
           }

     

       184
       184
       +
       

     

       185
       185
       +
           #[test]

     

       186
       186
       +
           fn test_match_search() {

     

       187
       187
       +
               // ?{IIIC} -> <empty> on ICIICIIICICFP

     

       188
       188
       +
               let dna = DnaRef::from_string("IFFCCCFIIC IIC ICIICIIICICFP");

     

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

     

       190
       190
       +
               let res = match_replace(dna, &mut rna);

     

       191
       191
       +
               assert!(res.is_some());

     

       192
       192
       +
               assert_eq!(res.unwrap().to_string(), "ICFP");

     

       193
       193
       +
           }

     

       194
       194
       +
       

     

       195
       195
       +
           #[test]

     

       196
       196
       +
           fn test_match_groups() {

     

       197
       197
       +
               // (!{1})(!{1})(!{1})(!{1}) -> {3}{2}{1}{0} on ICFP

     

       198
       198
       +
               let dna = DnaRef::from_string(

     

       199
       199
       +
                   "IIPIPCPIICIIPIPCPIICIIPIPCPIICIIPIPCPIICIIC IPPCCPIPPICPIPPCPIPPPIIC ICFP",

     

       200
       200
       +
               );

     

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

     

       202
       202
       +
               let res = match_replace(dna, &mut rna);

     

       203
       203
       +
               assert!(res.is_some());

     

       204
       204
       +
               assert_eq!(res.unwrap().to_string(), "PFCI");

     

       205
       205
       +
           }

     

       206
       206
       +
       

     

       207
       207
       +
           #[test]

     

       208
       208
       +
           fn test_match_protect() {

     

       209
       209
       +
               // (!{4}) -> {0}{0,1}{0,2}{0,3} on ICFP

     

       210
       210
       +
               let dna = DnaRef::from_string("IIPIPIICPIICIIC IPPPIPCPPIPICPPIPCCPPIIC ICFP");

     

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

     

       212
       212
       +
               let res = match_replace(dna, &mut rna);

     

       213
       213
       +
               assert!(res.is_some());

     

       214
       214
       +
               assert_eq!(res.unwrap().to_string(), "ICFPCFPICFPICCFPICCFFP");

     

       215
       215
       +
           }

     

       216
       216
       +
       

     

       217
       217
       +
           #[test]

     

       218
       218
       +
           fn test_match_asnat() {

     

       219
       219
       +
               // (!{10}) -> |0| on ICFPICFPICFP

     

       220
       220
       +
               let dna = DnaRef::from_string("IIPIPICICPIICIIC IIPPIIC ICFPICFPICFP");

     

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

     

       222
       222
       +
               let res = match_replace(dna, &mut rna);

     

       223
       223
       +
               assert!(res.is_some());

     

       224
       224
       +
               assert_eq!(res.unwrap().to_string(), "ICICPFP");

     

       225
       225
       +
           }

     

       226
       226
       +
       

     

       227
       227
       +
           #[test]

     

       228
       228
       +
           fn test_match_rna() {

     

       229
       229
       +
               // RIPIPIPI -> RCFCFCFC on ICFP

     

       230
       230
       +
               let dna = DnaRef::from_string("IIIIPIPIPIIIC IIICFCFCFCIIC ICFP");

     

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

     

       232
       232
       +
               let res = match_replace(dna, &mut rna);

     

       233
       233
       +
               assert!(res.is_some());

     

       234
       234
       +
               assert_eq!(res.unwrap().to_string(), "ICFP");

     

       235
       235
       +
               assert_eq!(

     

       236
       236
       +
                   rna,

     

       237
       237
       +
                   vec![

     

       238
       238
       +
                       [

     

       239
       239
       +
                           Base::I,

     

       240
       240
       +
                           Base::P,

     

       241
       241
       +
                           Base::I,

     

       242
       242
       +
                           Base::P,

     

       243
       243
       +
                           Base::I,

     

       244
       244
       +
                           Base::P,

     

       245
       245
       +
                           Base::I

     

       246
       246
       +
                       ],

     

       247
       247
       +
                       [

     

       248
       248
       +
                           Base::C,

     

       249
       249
       +
                           Base::F,

     

       250
       250
       +
                           Base::C,

     

       251
       251
       +
                           Base::F,

     

       252
       252
       +
                           Base::C,

     

       253
       253
       +
                           Base::F,

     

       254
       254
       +
                           Base::C

     

       255
       255
       +
                       ]

     

       256
       256
       +
                   ]

     

       257
       257
       +
               )

     

       258
       258
       +
           }

     

       259
       259
       +
       

     

       260
       260
       +
           #[test]

     

       261
       261
       +
           fn test_from_task() {

     

       262
       262
       +
               let dna = DnaRef::from_string("IIPIPICPIICICIIFICCIFPPIICCFPC");

     

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

     

       264
       264
       +
               let res = match_replace(dna, &mut rna);

     

       265
       265
       +
               assert!(res.is_some());

     

       266
       266
       +
               assert_eq!(res.unwrap().to_string(), "PICFC");

     

       267
       267
       +
       

     

       268
       268
       +
               let dna = DnaRef::from_string("IIPIPICPIICICIIFICCIFCCCPPIICCFPC");

     

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

     

       270
       270
       +
               let res = match_replace(dna, &mut rna);

     

       271
       271
       +
               assert!(res.is_some());

     

       272
       272
       +
               assert_eq!(res.unwrap().to_string(), "PIICCFCFFPC");

     

       273
       273
       +
       

     

       274
       274
       +
               let dna = DnaRef::from_string("IIPIPIICPIICIICCIICFCFC");

     

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

     

       276
       276
       +
               let res = match_replace(dna, &mut rna);

     

       277
       277
       +
               assert!(res.is_some());

     

       278
       278
       +
               assert_eq!(res.unwrap().to_string(), "I");

     

       279
       279
       +
           }

     

       280
       280
       +
       }

-236

dna2rna/src/parser.rs

···

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

     

       2
       2
       -
       use crate::dna::DnaRef;

     

       3
       3
       -
       use crate::pattern::Pattern;

     

       4
       4
       -
       use crate::pattern::PatternItem;

     

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

     

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

     

       7
       7
       -
       

     

       8
       8
       -
       struct Parser<'a> {

     

       9
       9
       -
           buf: &'a DnaRef,

     

       10
       10
       -
           index: usize,

     

       11
       11
       -
       }

     

       12
       12
       -
       

     

       13
       13
       -
       impl<'a> Parser<'a> {

     

       14
       14
       -
           pub fn new(buf: &'a DnaRef) -> Parser<'a> {

     

       15
       15
       -
               Parser { buf: buf, index: 0 }

     

       16
       16
       -
           }

     

       17
       17
       -
       

     

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

     

       19
       19
       -
               if self.index + next.len() > self.buf.len() {

     

       20
       20
       -
                   return false;

     

       21
       21
       -
               }

     

       22
       22
       -
       

     

       23
       23
       -
               for i in 0..next.len() {

     

       24
       24
       -
                   if self.buf[self.index + i] != next[i] {

     

       25
       25
       -
                       return false;

     

       26
       26
       -
                   }

     

       27
       27
       -
               }

     

       28
       28
       -
       

     

       29
       29
       -
               return true;

     

       30
       30
       -
           }

     

       31
       31
       -
       

     

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

     

       33
       33
       -
               let mut ret = 0;

     

       34
       34
       -
               let mut bit = 1;

     

       35
       35
       -
               loop {

     

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

     

       37
       37
       -
                       self.index += 1;

     

       38
       38
       -
                       return Some(ret);

     

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

     

       40
       40
       -
                       self.index += 1;

     

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

     

       42
       42
       -
                       ret += bit;

     

       43
       43
       -
                       self.index += 1;

     

       44
       44
       -
                   } else {

     

       45
       45
       -
                       return None;

     

       46
       46
       -
                   }

     

       47
       47
       -
       

     

       48
       48
       -
                   bit *= 2;

     

       49
       49
       -
               }

     

       50
       50
       -
           }

     

       51
       51
       -
       

     

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

     

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

     

       54
       54
       -
               loop {

     

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

     

       56
       56
       -
                       self.index += 1;

     

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

     

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

     

       59
       59
       -
                       self.index += 1;

     

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

     

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

     

       62
       62
       -
                       self.index += 1;

     

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

     

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

     

       65
       65
       -
                       self.index += 2;

     

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

     

       67
       67
       -
                   } else {

     

       68
       68
       -
                       return ret;

     

       69
       69
       -
                   }

     

       70
       70
       -
               }

     

       71
       71
       -
           }

     

       72
       72
       -
       

     

       73
       73
       -
           pub fn pattern(&mut self) -> Option<Pattern> {

     

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

     

       75
       75
       -
               let mut level = 0;

     

       76
       76
       -
               loop {

     

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

     

       78
       78
       -
                       self.index += 1;

     

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

     

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

     

       81
       81
       -
                       self.index += 1;

     

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

     

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

     

       84
       84
       -
                       self.index += 1;

     

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

     

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

     

       87
       87
       -
                       self.index += 2;

     

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

     

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

     

       90
       90
       -
                       self.index += 2;

     

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

     

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

     

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

     

       94
       94
       -
                       self.index += 3;

     

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

     

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

     

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

     

       98
       98
       -
                       self.index += 3;

     

       99
       99
       -
                       level += 1;

     

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

     

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

     

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

     

       103
       103
       -
                   {

     

       104
       104
       -
                       self.index += 3;

     

       105
       105
       -
                       if level == 0 {

     

       106
       106
       -
                           return Some(ret);

     

       107
       107
       -
                       }

     

       108
       108
       -
                       level -= 1;

     

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

     

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

     

       111
       111
       -
                       self.index += 10;

     

       112
       112
       -
                       // TODO: RNA output

     

       113
       113
       -
                   } else {

     

       114
       114
       -
                       return None;

     

       115
       115
       -
                   }

     

       116
       116
       -
               }

     

       117
       117
       -
           }

     

       118
       118
       -
       

     

       119
       119
       -
           pub fn template(&mut self) -> Option<Template> {

     

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

     

       121
       121
       -
               loop {

     

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

     

       123
       123
       -
                       self.index += 1;

     

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

     

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

     

       126
       126
       -
                       self.index += 1;

     

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

     

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

     

       129
       129
       -
                       self.index += 1;

     

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

     

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

     

       132
       132
       -
                       self.index += 2;

     

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

     

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

     

       135
       135
       -
                       self.index += 2;

     

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

     

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

     

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

     

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

     

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

     

       141
       141
       -
                   {

     

       142
       142
       -
                       self.index += 3;

     

       143
       143
       -
                       return Some(ret);

     

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

     

       145
       145
       -
                       self.index += 3;

     

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

     

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

     

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

     

       149
       149
       -
                       self.index += 10;

     

       150
       150
       -
                       // TODO: RNA output

     

       151
       151
       -
                   } else {

     

       152
       152
       -
                       return None;

     

       153
       153
       -
                   }

     

       154
       154
       -
               }

     

       155
       155
       -
           }

     

       156
       156
       -
       }

     

       157
       157
       -
       

     

       158
       158
       -
       #[cfg(test)]

     

       159
       159
       -
       mod tests {

     

       160
       160
       -
           use super::*;

     

       161
       161
       -
       

     

       162
       162
       -
           #[test]

     

       163
       163
       -
           fn test_base() {

     

       164
       164
       -
               let dna = DnaRef::from_string("ICFP");

     

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

     

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

     

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

     

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

     

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

     

       170
       170
       -
           }

     

       171
       171
       -
       

     

       172
       172
       -
           #[test]

     

       173
       173
       -
           fn test_nat() {

     

       174
       174
       -
               let dna = DnaRef::from_string("CP");

     

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

     

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

     

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

     

       178
       178
       -
       

     

       179
       179
       -
               let dna = DnaRef::from_string("ICICP");

     

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

     

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

     

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

     

       183
       183
       -
       

     

       184
       184
       -
               let dna = DnaRef::from_string("III");

     

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

     

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

     

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

     

       188
       188
       -
           }

     

       189
       189
       -
       

     

       190
       190
       -
           #[test]

     

       191
       191
       -
           fn test_consts() {

     

       192
       192
       -
               let dna = DnaRef::from_string("CFPICIIC");

     

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

     

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

     

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

     

       196
       196
       -
           }

     

       197
       197
       -
       

     

       198
       198
       -
           #[test]

     

       199
       199
       -
           fn test_pattern() {

     

       200
       200
       -
               let dna = DnaRef::from_string("CIIC");

     

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

     

       202
       202
       -
               assert_eq!(parser.pattern(), Some(vec![PatternItem::Base(Base::I)]));

     

       203
       203
       -
               assert_eq!(parser.ijndex, 4);

     

       204
       204
       -
       

     

       205
       205
       -
               let dna = DnaRef::from_string("IIPIPICPIICICIIF");

     

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

     

       207
       207
       -
               assert_eq!(

     

       208
       208
       -
                   parser.pattern(),

     

       209
       209
       -
                   Some(vec![

     

       210
       210
       -
                       PatternItem::Open,

     

       211
       211
       -
                       PatternItem::Skip(2),

     

       212
       212
       -
                       PatternItem::Close,

     

       213
       213
       -
                       PatternItem::Base(Base::P)

     

       214
       214
       -
                   ])

     

       215
       215
       -
               );

     

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

     

       217
       217
       -
           }

     

       218
       218
       -
       

     

       219
       219
       -
           #[test]

     

       220
       220
       -
           fn test_template() {

     

       221
       221
       -
               let dna = DnaRef::from_string("CFPICIFCPICPIIPIICPIIC");

     

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

     

       223
       223
       -
               assert_eq!(

     

       224
       224
       -
                   parser.template(),

     

       225
       225
       -
                   Some(vec![

     

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

     

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

     

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

     

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

     

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

     

       231
       231
       -
                       TemplateItem::Len(4)

     

       232
       232
       -
                   ])

     

       233
       233
       -
               );

     

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

     

       235
       235
       -
           }

     

       236
       236
       -
       }

-12

dna2rna/src/pattern.rs

···

       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>;

-10

dna2rna/src/template.rs

···

       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

dna_parsing/.dir-locals.el

···

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

+7

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"

+6

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

+5

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

+3

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

+1

rna2bmp/.dir-locals.el

···

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

+7

rna2bmp/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 = "rna2bmp"

     

       7
       7
       +
       version = "0.1.0"

+6

rna2bmp/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "rna2bmp"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+95

rna2bmp/src/bitmap.rs

···

       1
       1
       +
       pub const SIZE: usize = 600;

     

       2
       2
       +
       

     

       3
       3
       +
       pub type Point = (usize, usize);

     

       4
       4
       +
       pub type Pixel = (u8, u8, u8, u8);

     

       5
       5
       +
       // A bitmap is large enough that it will stack overflow. The Box isn't

     

       6
       6
       +
       // strictly necessary if I can just be careful everywhere, but it's nice

     

       7
       7
       +
       // to have.

     

       8
       8
       +
       pub struct Bitmap {

     

       9
       9
       +
           data: Box<[[Pixel; SIZE]; SIZE]>,

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       impl Bitmap {

     

       13
       13
       +
           pub fn new() -> Bitmap {

     

       14
       14
       +
               Bitmap {

     

       15
       15
       +
                   data: Box::new([[(0, 0, 0, 0); SIZE]; SIZE]),

     

       16
       16
       +
               }

     

       17
       17
       +
           }

     

       18
       18
       +
       

     

       19
       19
       +
           pub fn pixel_mut(&mut self, p: Point) -> &mut Pixel {

     

       20
       20
       +
               let (x, y) = p;

     

       21
       21
       +
               &mut self.data[x][y]

     

       22
       22
       +
           }

     

       23
       23
       +
       

     

       24
       24
       +
           pub fn pixel(&self, p: Point) -> &Pixel {

     

       25
       25
       +
               let (x, y) = p;

     

       26
       26
       +
               &self.data[x][y]

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
           pub fn to_data(&self) -> Vec<u8> {

     

       30
       30
       +
               let mut writer = Writer::new();

     

       31
       31
       +
               let row_padding = (4 - (3 * SIZE) % 4) % 4;

     

       32
       32
       +
               let pix_size: u32 = (SIZE * (3 * SIZE + row_padding)) as u32;

     

       33
       33
       +
               writer.output_u16(0x4d42); // BM 

     

       34
       34
       +
               writer.output_u32(0x36 + pix_size); // Size

     

       35
       35
       +
               writer.output_u16(0x0); // Reserved

     

       36
       36
       +
               writer.output_u16(0x0); // Reserved

     

       37
       37
       +
               writer.output_u32(0x36); // Offset of pixel array

     

       38
       38
       +
               writer.output_u32(0x28); // Length of DIB header

     

       39
       39
       +
               writer.output_u32(SIZE as u32); // Width

     

       40
       40
       +
               writer.output_u32(SIZE as u32); // Height

     

       41
       41
       +
               writer.output_u16(0x1); // Color planes

     

       42
       42
       +
               writer.output_u16(0x18); // Bits per pixel

     

       43
       43
       +
               writer.output_u32(0x0); // No pixel array compression

     

       44
       44
       +
               writer.output_u32(pix_size); // Pixel data size

     

       45
       45
       +
               writer.output_u32(0x0); // Horizontal resolution

     

       46
       46
       +
               writer.output_u32(0x0); // Vertical resolution

     

       47
       47
       +
               writer.output_u32(0x0); // Colors in the palette

     

       48
       48
       +
               writer.output_u32(0x0); // All colors are important

     

       49
       49
       +
       

     

       50
       50
       +
               for y in (0..SIZE).rev() {

     

       51
       51
       +
                   for x in 0..SIZE {

     

       52
       52
       +
                       let (r, g, b, _) = self.data[x][y];

     

       53
       53
       +
                       writer.output_u8(b);

     

       54
       54
       +
                       writer.output_u8(g);

     

       55
       55
       +
                       writer.output_u8(r);

     

       56
       56
       +
                   }

     

       57
       57
       +
       

     

       58
       58
       +
                   for _ in 0..row_padding {

     

       59
       59
       +
                       writer.output_u8(0);

     

       60
       60
       +
                   }

     

       61
       61
       +
               }

     

       62
       62
       +
       

     

       63
       63
       +
               return writer.output();

     

       64
       64
       +
           }

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       struct Writer {

     

       68
       68
       +
           output: Vec<u8>,

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       impl Writer {

     

       72
       72
       +
           fn new() -> Writer {

     

       73
       73
       +
               Writer { output: Vec::new() }

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           fn output_u8(&mut self, n: u8) {

     

       77
       77
       +
               self.output.push(n);

     

       78
       78
       +
           }

     

       79
       79
       +
       

     

       80
       80
       +
           fn output_u16(&mut self, n: u16) {

     

       81
       81
       +
               self.output.push(n as u8);

     

       82
       82
       +
               self.output.push((n >> 8) as u8);

     

       83
       83
       +
           }

     

       84
       84
       +
       

     

       85
       85
       +
           fn output_u32(&mut self, n: u32) {

     

       86
       86
       +
               self.output.push(n as u8);

     

       87
       87
       +
               self.output.push((n >> 8) as u8);

     

       88
       88
       +
               self.output.push((n >> 16) as u8);

     

       89
       89
       +
               self.output.push((n >> 24) as u8);

     

       90
       90
       +
           }

     

       91
       91
       +
       

     

       92
       92
       +
           fn output(self) -> Vec<u8> {

     

       93
       93
       +
               self.output

     

       94
       94
       +
           }

     

       95
       95
       +
       }

+30

rna2bmp/src/main.rs

···

       1
       1
       +
       mod bitmap;

     

       2
       2
       +
       mod rna_processor;

     

       3
       3
       +
       

     

       4
       4
       +
       use crate::rna_processor::RnaProcessor;

     

       5
       5
       +
       use std::env;

     

       6
       6
       +
       use std::fs;

     

       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: {} <rna file> <bmp file>", args[0]);

     

       12
       12
       +
               return;

     

       13
       13
       +
           }

     

       14
       14
       +
       

     

       15
       15
       +
           let contents = fs::read_to_string(&args[1]);

     

       16
       16
       +
           if let Ok(rna) = contents {

     

       17
       17
       +
               let mut processor = RnaProcessor::new();

     

       18
       18
       +
               processor.process_rna(rna.lines().collect());

     

       19
       19
       +
               if let Some(bmp) = processor.bitmap() {

     

       20
       20
       +
                   if fs::write(&args[2], bmp.to_data()).is_err() {

     

       21
       21
       +
                       println!("Could not write to {}", args[2]);

     

       22
       22
       +
                   }

     

       23
       23
       +
               } else {

     

       24
       24
       +
                   println!("No bitmap after RNA processing");

     

       25
       25
       +
               }

     

       26
       26
       +
           } else {

     

       27
       27
       +
               println!("Could not open {}", args[1]);

     

       28
       28
       +
               return;

     

       29
       29
       +
           }

     

       30
       30
       +
       }

+226

rna2bmp/src/rna_processor.rs

···

       1
       1
       +
       use crate::bitmap::Bitmap;

     

       2
       2
       +
       use crate::bitmap::Pixel;

     

       3
       3
       +
       use crate::bitmap::Point;

     

       4
       4
       +
       use crate::bitmap::SIZE;

     

       5
       5
       +
       use std::cmp::max;

     

       6
       6
       +
       

     

       7
       7
       +
       struct Bucket {

     

       8
       8
       +
           total_r: usize,

     

       9
       9
       +
           total_g: usize,

     

       10
       10
       +
           total_b: usize,

     

       11
       11
       +
           total_a: usize,

     

       12
       12
       +
           count_rgb: usize,

     

       13
       13
       +
           count_a: usize,

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       pub struct RnaProcessor {

     

       17
       17
       +
           bucket: Bucket,

     

       18
       18
       +
           position: Point,

     

       19
       19
       +
           mark: Point,

     

       20
       20
       +
           dir: Point,

     

       21
       21
       +
           bitmaps: Vec<Bitmap>,

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       impl Bucket {

     

       25
       25
       +
           fn new() -> Bucket {

     

       26
       26
       +
               Bucket {

     

       27
       27
       +
                   total_r: 0,

     

       28
       28
       +
                   total_g: 0,

     

       29
       29
       +
                   total_b: 0,

     

       30
       30
       +
                   total_a: 0,

     

       31
       31
       +
                   count_rgb: 0,

     

       32
       32
       +
                   count_a: 0,

     

       33
       33
       +
               }

     

       34
       34
       +
           }

     

       35
       35
       +
       

     

       36
       36
       +
           fn current_pixel(&self) -> Pixel {

     

       37
       37
       +
               let (r, g, b) = if self.count_rgb == 0 {

     

       38
       38
       +
                   (0, 0, 0)

     

       39
       39
       +
               } else {

     

       40
       40
       +
                   (

     

       41
       41
       +
                       self.total_r / self.count_rgb,

     

       42
       42
       +
                       self.total_g / self.count_rgb,

     

       43
       43
       +
                       self.total_b / self.count_rgb,

     

       44
       44
       +
                   )

     

       45
       45
       +
               };

     

       46
       46
       +
               let a = if self.count_a == 0 {

     

       47
       47
       +
                   255

     

       48
       48
       +
               } else {

     

       49
       49
       +
                   self.total_a / self.count_a

     

       50
       50
       +
               };

     

       51
       51
       +
       

     

       52
       52
       +
               return (

     

       53
       53
       +
                   (r * a / 255) as u8,

     

       54
       54
       +
                   (g * a / 255) as u8,

     

       55
       55
       +
                   (b * a / 255) as u8,

     

       56
       56
       +
                   a as u8,

     

       57
       57
       +
               );

     

       58
       58
       +
           }

     

       59
       59
       +
       

     

       60
       60
       +
           fn add_rgb(&mut self, r: usize, g: usize, b: usize) {

     

       61
       61
       +
               self.total_r += r;

     

       62
       62
       +
               self.total_g += g;

     

       63
       63
       +
               self.total_b += b;

     

       64
       64
       +
               self.count_rgb += 1;

     

       65
       65
       +
           }

     

       66
       66
       +
       

     

       67
       67
       +
           fn add_a(&mut self, a: usize) {

     

       68
       68
       +
               self.total_a += a;

     

       69
       69
       +
               self.count_a += 1;

     

       70
       70
       +
           }

     

       71
       71
       +
       

     

       72
       72
       +
           fn clear(&mut self) {

     

       73
       73
       +
               self.total_r = 0;

     

       74
       74
       +
               self.total_g = 0;

     

       75
       75
       +
               self.total_b = 0;

     

       76
       76
       +
               self.total_a = 0;

     

       77
       77
       +
               self.count_rgb = 0;

     

       78
       78
       +
               self.count_a = 0;

     

       79
       79
       +
           }

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       impl RnaProcessor {

     

       83
       83
       +
           pub fn new() -> RnaProcessor {

     

       84
       84
       +
               RnaProcessor {

     

       85
       85
       +
                   bucket: Bucket::new(),

     

       86
       86
       +
                   position: (0, 0),

     

       87
       87
       +
                   mark: (0, 0),

     

       88
       88
       +
                   dir: (1, 0),

     

       89
       89
       +
                   bitmaps: vec![Bitmap::new()],

     

       90
       90
       +
               }

     

       91
       91
       +
           }

     

       92
       92
       +
       

     

       93
       93
       +
           fn set_pixel(&mut self, p: Point) {

     

       94
       94
       +
               if let Some(b) = self.bitmaps.last_mut() {

     

       95
       95
       +
                   *b.pixel_mut(p) = self.bucket.current_pixel();

     

       96
       96
       +
               }

     

       97
       97
       +
           }

     

       98
       98
       +
       

     

       99
       99
       +
           pub fn process_rna(&mut self, rna: Vec<&str>) {

     

       100
       100
       +
               for r in rna {

     

       101
       101
       +
                   if r == "PIPIIIC" {

     

       102
       102
       +
                       self.bucket.add_rgb(0, 0, 0);

     

       103
       103
       +
                   } else if r == "PIPIIIP" {

     

       104
       104
       +
                       self.bucket.add_rgb(255, 0, 0);

     

       105
       105
       +
                   } else if r == "PIPIICC" {

     

       106
       106
       +
                       self.bucket.add_rgb(0, 255, 0);

     

       107
       107
       +
                   } else if r == "PIPIICF" {

     

       108
       108
       +
                       self.bucket.add_rgb(255, 255, 0);

     

       109
       109
       +
                   } else if r == "PIPIICP" {

     

       110
       110
       +
                       self.bucket.add_rgb(0, 0, 255);

     

       111
       111
       +
                   } else if r == "PIPIIFC" {

     

       112
       112
       +
                       self.bucket.add_rgb(255, 0, 255);

     

       113
       113
       +
                   } else if r == "PIPIIFF" {

     

       114
       114
       +
                       self.bucket.add_rgb(0, 255, 255);

     

       115
       115
       +
                   } else if r == "PIPIIPC" {

     

       116
       116
       +
                       self.bucket.add_rgb(255, 255, 255);

     

       117
       117
       +
                   } else if r == "PIPIIPF" {

     

       118
       118
       +
                       self.bucket.add_a(0);

     

       119
       119
       +
                   } else if r == "PIPIIPP" {

     

       120
       120
       +
                       self.bucket.add_a(255);

     

       121
       121
       +
                   } else if r == "PIIPICP" {

     

       122
       122
       +
                       self.bucket.clear();

     

       123
       123
       +
                   } else if r == "PIIIIIP" {

     

       124
       124
       +
                       let (x, y) = self.position;

     

       125
       125
       +
                       let (dx, dy) = self.dir;

     

       126
       126
       +
                       self.position = ((x + dx) % SIZE, (y + dy) % SIZE);

     

       127
       127
       +
                   } else if r == "PCCCCCP" {

     

       128
       128
       +
                       let (dx, dy) = self.dir;

     

       129
       129
       +
                       self.dir = (dy, SIZE - dx);

     

       130
       130
       +
                   } else if r == "PFFFFFP" {

     

       131
       131
       +
                       let (dx, dy) = self.dir;

     

       132
       132
       +
                       self.dir = (SIZE - dy, dx);

     

       133
       133
       +
                   } else if r == "PCCIFFP" {

     

       134
       134
       +
                       self.mark = self.position;

     

       135
       135
       +
                   } else if r == "PFFICCP" {

     

       136
       136
       +
                       let x0 = self.position.0 as isize;

     

       137
       137
       +
                       let y0 = self.position.1 as isize;

     

       138
       138
       +
                       let x1 = self.mark.0 as isize;

     

       139
       139
       +
                       let y1 = self.mark.1 as isize;

     

       140
       140
       +
                       let dx = x1 - x0;

     

       141
       141
       +
                       let dy = y1 - y0;

     

       142
       142
       +
                       let d = max(dx.abs(), dy.abs());

     

       143
       143
       +
                       let c = if dx * dy <= 0 { 1 } else { 0 };

     

       144
       144
       +
                       let mut x = x0 * d + (d - c) / 2;

     

       145
       145
       +
                       let mut y = y0 * d + (d - c) / 2;

     

       146
       146
       +
                       for _ in 0..d {

     

       147
       147
       +
                           self.set_pixel(((x / d) as usize, (y / d) as usize));

     

       148
       148
       +
                           x += dx;

     

       149
       149
       +
                           y += dy;

     

       150
       150
       +
                       }

     

       151
       151
       +
                       self.set_pixel((x1 as usize, y1 as usize));

     

       152
       152
       +
                   } else if r == "PIIPIIP" {

     

       153
       153
       +
                       if let Some(b) = self.bitmaps.last_mut() {

     

       154
       154
       +
                           let old = *b.pixel(self.position);

     

       155
       155
       +
                           let new = self.bucket.current_pixel();

     

       156
       156
       +
                           if new == old {

     

       157
       157
       +
                               continue;

     

       158
       158
       +
                           }

     

       159
       159
       +
                           let mut to_fill = Vec::new();

     

       160
       160
       +
                           to_fill.push(self.position);

     

       161
       161
       +
                           while let Some(p) = to_fill.pop() {

     

       162
       162
       +
                               if *b.pixel(p) == old {

     

       163
       163
       +
                                   *b.pixel_mut(p) = new;

     

       164
       164
       +
       

     

       165
       165
       +
                                   let (x, y) = p;

     

       166
       166
       +
                                   if x > 0 {

     

       167
       167
       +
                                       to_fill.push((x - 1, y));

     

       168
       168
       +
                                   }

     

       169
       169
       +
                                   if x < SIZE - 1 {

     

       170
       170
       +
                                       to_fill.push((x + 1, y));

     

       171
       171
       +
                                   }

     

       172
       172
       +
                                   if y > 0 {

     

       173
       173
       +
                                       to_fill.push((x, y - 1));

     

       174
       174
       +
                                   }

     

       175
       175
       +
                                   if y < SIZE - 1 {

     

       176
       176
       +
                                       to_fill.push((x, y + 1));

     

       177
       177
       +
                                   }

     

       178
       178
       +
                               }

     

       179
       179
       +
                           }

     

       180
       180
       +
                       }

     

       181
       181
       +
                   } else if r == "PCCPFFP" {

     

       182
       182
       +
                       if self.bitmaps.len() < 10 {

     

       183
       183
       +
                           self.bitmaps.push(Bitmap::new());

     

       184
       184
       +
                       }

     

       185
       185
       +
                   } else if r == "PFFPCCP" {

     

       186
       186
       +
                       if self.bitmaps.len() >= 2 {

     

       187
       187
       +
                           let bmp0 = self.bitmaps.pop().unwrap();

     

       188
       188
       +
                           let mut bmp1 = self.bitmaps.pop().unwrap();

     

       189
       189
       +
                           for x in 0..SIZE {

     

       190
       190
       +
                               for y in 0..SIZE {

     

       191
       191
       +
                                   let (r0, g0, b0, a0) = *bmp0.pixel((x, y));

     

       192
       192
       +
                                   let (r1, g1, b1, a1) = *bmp1.pixel((x, y));

     

       193
       193
       +
                                   let r = r0 + ((r1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       194
       194
       +
                                   let g = g0 + ((g1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       195
       195
       +
                                   let b = b0 + ((b1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       196
       196
       +
                                   let a = a0 + ((a1 as usize) * (255 - a0 as usize) / 255) as u8;

     

       197
       197
       +
                                   *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       198
       198
       +
                               }

     

       199
       199
       +
                           }

     

       200
       200
       +
                           self.bitmaps.push(bmp1);

     

       201
       201
       +
                       }

     

       202
       202
       +
                   } else if r == "PFFICCF" {

     

       203
       203
       +
                       if self.bitmaps.len() >= 2 {

     

       204
       204
       +
                           let bmp0 = self.bitmaps.pop().unwrap();

     

       205
       205
       +
                           let mut bmp1 = self.bitmaps.pop().unwrap();

     

       206
       206
       +
                           for x in 0..SIZE {

     

       207
       207
       +
                               for y in 0..SIZE {

     

       208
       208
       +
                                   let (_, _, _, a0) = *bmp0.pixel((x, y));

     

       209
       209
       +
                                   let (r1, g1, b1, a1) = *bmp1.pixel((x, y));

     

       210
       210
       +
                                   let r = ((r1 as usize) * (a0 as usize) / 255) as u8;

     

       211
       211
       +
                                   let g = ((g1 as usize) * (a0 as usize) / 255) as u8;

     

       212
       212
       +
                                   let b = ((b1 as usize) * (a0 as usize) / 255) as u8;

     

       213
       213
       +
                                   let a = ((a1 as usize) * (a0 as usize) / 255) as u8;

     

       214
       214
       +
                                   *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       215
       215
       +
                               }

     

       216
       216
       +
                           }

     

       217
       217
       +
                           self.bitmaps.push(bmp1);

     

       218
       218
       +
                       }

     

       219
       219
       +
                   }

     

       220
       220
       +
               }

     

       221
       221
       +
           }

     

       222
       222
       +
       

     

       223
       223
       +
           pub fn bitmap(&self) -> Option<&Bitmap> {

     

       224
       224
       +
               self.bitmaps.last()

     

       225
       225
       +
           }

     

       226
       226
       +
       }

Compare changes