comparing c42ee87b9b6d18e5481dfa2533bf6360d8d7d36b and main on drubery.com/icfp2007

+1 -6

.gitignore

···

       1
       1
        
       task/endo.dna

     

       2
       2
       -
       dna2rna/target/

     

       3
       3
       -
       rna2bmp/target/

     

       4
       4
       -
       rna/

     

       5
       5
       -
       bmp/

     

       6
       2
        
       .tup/

     

       7
       7
       -
       bin/

     

       8
       8
       -
       png/

     

       3
       3
       +
       /out/

-10

Tupfile

···

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

     

       2
       2
       -
       

     

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

     

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

     

       5
       5
       -
       

     

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

     

       7
       7
       -
       

     

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

     

       9
       9
       -
       

     

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

+64

Tupfile.lua

···

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

     

       2
       2
       +
           local inputs = {}

     

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

     

       4
       4
       +
       	table.insert(inputs, input)

     

       5
       5
       +
           end

     

       6
       6
       +
       

     

       7
       7
       +
           local input_rs

     

       8
       8
       +
           local output

     

       9
       9
       +
           if type == "bin" then

     

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

     

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

     

       12
       12
       +
           else

     

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

     

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

     

       15
       15
       +
           end

     

       16
       16
       +
           

     

       17
       17
       +
           local externs = {}

     

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

     

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

     

       20
       20
       +
               table.insert(inputs, rlib)

     

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

     

       22
       22
       +
           end

     

       23
       23
       +
       

     

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

     

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

     

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

     

       27
       27
       +
       end

     

       28
       28
       +
       

     

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

     

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

     

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

     

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

     

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

     

       34
       34
       +
       

     

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

     

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

     

       37
       37
       +
       tup.foreach_rule(

     

       38
       38
       +
         asm,

     

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

     

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

     

       41
       41
       +
       )

     

       42
       42
       +
       

     

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

     

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

     

       45
       45
       +
       tup.foreach_rule(

     

       46
       46
       +
         dna,

     

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

     

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

     

       49
       49
       +
       )

     

       50
       50
       +
       

     

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

     

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

     

       53
       53
       +
       tup.foreach_rule(

     

       54
       54
       +
         rna,

     

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

     

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

     

       57
       57
       +
       )

     

       58
       58
       +
       

     

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

     

       60
       60
       +
       tup.foreach_rule(

     

       61
       61
       +
         bmp,

     

       62
       62
       +
         "convert %f %o",

     

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

     

       64
       64
       +
       )

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

+1 -29

dna2rna/src/dna.rs

···

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

     

       1
       2
        
       use std::collections::VecDeque;

     

       2
       3
        
       use std::ops::Add;

     

       3
       4
        
       use std::ops::AddAssign;

     

       4
       5
        
       use std::ops::Deref;

     

       5
       6
        
       use std::ops::Index;

     

       6
       7
        
       use std::rc::Rc;

     

       7
       7
       -
       

     

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

     

       9
       9
       -
       pub enum Base {

     

       10
       10
       -
           I,

     

       11
       11
       -
           C,

     

       12
       12
       -
           F,

     

       13
       13
       -
           P,

     

       14
       14
       -
       }

     

       15
       8
        
       

     

       16
       9
        
       #[derive(Clone, Debug)]

     

       17
       10
        
       pub enum Dna {

     
···

       39
       32
        
           len: usize,

     

       40
       33
        
           depth: usize,

     

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

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       impl Base {

     

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

     

       46
       46
       -
               match c {

     

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

     

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

     

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

     

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

     

       51
       51
       -
                   _ => None,

     

       52
       52
       -
               }

     

       53
       53
       -
           }

     

       54
       54
       -
       

     

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

     

       56
       56
       -
               match self {

     

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

     

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

     

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

     

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

     

       61
       61
       -
               }

     

       62
       62
       -
           }

     

       63
       35
        
       }

     

       64
       36
        
       

     

       65
       37
        
       impl DnaRef {

+18 -14

dna2rna/src/main.rs

···

       1
       1
        
       mod dna;

     

       2
       2
        
       mod match_replace;

     

       3
       3
       -
       mod parser;

     

       4
       4
       -
       mod pattern;

     

       5
       5
       -
       mod rna;

     

       6
       6
       -
       mod template;

     

       7
       3
        
       

     

       8
       4
        
       use std::env;

     

       9
       5
        
       use std::fs;

     

       10
       6
        
       use std::fs::File;

     

       11
       11
       -
       use std::io;

     

       12
       7
        
       use std::io::Write;

     

       13
       8
        
       

     

       14
       14
       -
       fn main() -> io::Result<()> {

     

       9
       9
       +
       fn main() {

     

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

     

       16
       11
        
           if args.len() < 4 {

     

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

     

       18
       18
       -
               return Ok(());

     

       13
       13
       +
               return;

     

       19
       14
        
           }

     

       20
       15
        
       

     

       21
       21
       -
           // TODO: Better error messages

     

       22
       22
       -
           let prefix = fs::read_to_string(&args[1])?;

     

       23
       23
       -
           let dna = fs::read_to_string(&args[2])?;

     

       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 mut rna_file = File::create(&args[3])?;

     

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

     

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

     

       28
       31
        
           loop {

     

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

     
···

       34
       37
        
       

     

       35
       38
        
               for r in rna.iter() {

     

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

     

       37
       37
       -
                   rna_file.write(rna_str.as_bytes())?;

     

       38
       38
       -
                   rna_file.write(b"\n")?;

     

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

     

       39
       43
        
               }

     

       40
       44
        
       

     

       41
       45
        
               rna.clear();

     

       42
       46
        
           }

     

       43
       47
        
       

     

       44
       44
       -
           return Ok(());

     

       48
       48
       +
           return;

     

       45
       49
        
       }

+11 -11

dna2rna/src/match_replace.rs

···

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

     

       2
       1
        
       use crate::dna::DnaRef;

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       8
       8
        
       

     

       9
       9
        
       struct MatchResult {

     

       10
       10
        
           end: usize,

     

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

     

       12
       12
        
       }

     

       13
       13
        
       

     

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

     

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

     

       15
       15
        
           let mut index = start;

     

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

     

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

     

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

     

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

     

       19
       19
        
               match p {

     

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

     

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

     

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

     

       22
       22
        
                           return None;

     

       23
       23
        
                       }

     

       24
       24
        
       

     
···

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

     

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

     

       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 {

-307

dna2rna/src/parser.rs

···

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

     

       2
       2
       -
       use crate::dna::DnaIterator;

     

       3
       3
       -
       use crate::dna::DnaRef;

     

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

     

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

     

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

     

       7
       7
       -
       use crate::template::Template;

     

       8
       8
       -
       use crate::template::TemplateItem;

     

       9
       9
       -
       use std::mem;

     

       10
       10
       -
       

     

       11
       11
       -
       pub struct Parser<'a> {

     

       12
       12
       -
           iter: DnaIterator<'a>,

     

       13
       13
       -
           peeked: Vec<Base>,

     

       14
       14
       -
           index: usize,

     

       15
       15
       -
       }

     

       16
       16
       -
       

     

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

     

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

     

       19
       19
       -
               Parser {

     

       20
       20
       -
                   iter: buf.iter(),

     

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

     

       22
       22
       -
                   index: 0,

     

       23
       23
       -
               }

     

       24
       24
       -
           }

     

       25
       25
       -
       

     

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

     

       27
       27
       -
               self.index

     

       28
       28
       -
           }

     

       29
       29
       -
       

     

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

     

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

     

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

     

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

     

       34
       34
       -
                   } else {

     

       35
       35
       -
                       return;

     

       36
       36
       -
                   }

     

       37
       37
       -
               }

     

       38
       38
       -
           }

     

       39
       39
       -
       

     

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

     

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

     

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

     

       43
       43
       -
                   return false;

     

       44
       44
       -
               }

     

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

     

       46
       46
       -
           }

     

       47
       47
       -
       

     

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

     

       49
       49
       -
               self.peek_to(n);

     

       50
       50
       -
               self.index += n;

     

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

     

       52
       52
       -
           }

     

       53
       53
       -
       

     

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

     

       55
       55
       -
               let mut ret = 0;

     

       56
       56
       -
               let mut bit = 1;

     

       57
       57
       -
               loop {

     

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

     

       59
       59
       -
                       self.advance(1);

     

       60
       60
       -
                       return Some(ret);

     

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

     

       62
       62
       -
                       self.advance(1);

     

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

     

       64
       64
       -
                       ret += bit;

     

       65
       65
       -
                       self.advance(1);

     

       66
       66
       -
                   } else {

     

       67
       67
       -
                       return None;

     

       68
       68
       -
                   }

     

       69
       69
       -
       

     

       70
       70
       -
                   bit *= 2;

     

       71
       71
       -
               }

     

       72
       72
       -
           }

     

       73
       73
       -
       

     

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

     

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

     

       76
       76
       -
               loop {

     

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

     

       78
       78
       -
                       self.advance(1);

     

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

     

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

     

       81
       81
       -
                       self.advance(1);

     

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

     

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

     

       84
       84
       -
                       self.advance(1);

     

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

     

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

     

       87
       87
       -
                       self.advance(2);

     

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

     

       89
       89
       -
                   } else {

     

       90
       90
       -
                       return ret;

     

       91
       91
       -
                   }

     

       92
       92
       -
               }

     

       93
       93
       -
           }

     

       94
       94
       -
       

     

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

     

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

     

       97
       97
       -
               let mut level = 0;

     

       98
       98
       -
               loop {

     

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

     

       100
       100
       -
                       self.advance(1);

     

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

     

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

     

       103
       103
       -
                       self.advance(1);

     

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

     

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

     

       106
       106
       -
                       self.advance(1);

     

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

     

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

     

       109
       109
       -
                       self.advance(2);

     

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

     

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

     

       112
       112
       -
                       self.advance(2);

     

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

     

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

     

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

     

       116
       116
       -
                       self.advance(3);

     

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

     

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

     

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

     

       120
       120
       -
                       self.advance(3);

     

       121
       121
       -
                       level += 1;

     

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

     

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

     

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

     

       125
       125
       -
                   {

     

       126
       126
       -
                       self.advance(3);

     

       127
       127
       -
                       if level == 0 {

     

       128
       128
       -
                           return Some(ret);

     

       129
       129
       -
                       }

     

       130
       130
       -
                       level -= 1;

     

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

     

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

     

       133
       133
       -
                       self.advance(3);

     

       134
       134
       -
                       self.peek_to(7);

     

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

     

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

     

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

     

       138
       138
       -
                       self.index += 7;

     

       139
       139
       -
                   } else {

     

       140
       140
       -
                       return None;

     

       141
       141
       -
                   }

     

       142
       142
       -
               }

     

       143
       143
       -
           }

     

       144
       144
       -
       

     

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

     

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

     

       147
       147
       -
               loop {

     

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

     

       149
       149
       -
                       self.advance(1);

     

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

     

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

     

       152
       152
       -
                       self.advance(1);

     

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

     

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

     

       155
       155
       -
                       self.advance(1);

     

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

     

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

     

       158
       158
       -
                       self.advance(2);

     

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

     

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

     

       161
       161
       -
                       self.advance(2);

     

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

     

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

     

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

     

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

     

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

     

       167
       167
       -
                   {

     

       168
       168
       -
                       self.advance(3);

     

       169
       169
       -
                       return Some(ret);

     

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

     

       171
       171
       -
                       self.advance(3);

     

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

     

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

     

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

     

       175
       175
       -
                       self.advance(3);

     

       176
       176
       -
                       self.peek_to(7);

     

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

     

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

     

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

     

       180
       180
       -
                       self.index += 7;

     

       181
       181
       -
                   } else {

     

       182
       182
       -
                       return None;

     

       183
       183
       -
                   }

     

       184
       184
       -
               }

     

       185
       185
       -
           }

     

       186
       186
       -
       }

     

       187
       187
       -
       

     

       188
       188
       -
       #[cfg(test)]

     

       189
       189
       -
       mod tests {

     

       190
       190
       -
           use super::*;

     

       191
       191
       -
       

     

       192
       192
       -
           #[test]

     

       193
       193
       -
           fn test_base() {

     

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

     

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

     

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

     

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

     

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

     

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

     

       200
       200
       -
           }

     

       201
       201
       -
       

     

       202
       202
       -
           #[test]

     

       203
       203
       -
           fn test_nat() {

     

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

     

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

     

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

     

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

     

       208
       208
       -
       

     

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

     

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

     

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

     

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

     

       213
       213
       -
       

     

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

     

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

     

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

     

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

     

       218
       218
       -
           }

     

       219
       219
       -
       

     

       220
       220
       -
           #[test]

     

       221
       221
       -
           fn test_consts() {

     

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

     

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

     

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

     

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

     

       226
       226
       -
           }

     

       227
       227
       -
       

     

       228
       228
       -
           #[test]

     

       229
       229
       -
           fn test_pattern() {

     

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

     

       231
       231
       -
       

     

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

     

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

     

       234
       234
       -
               assert_eq!(

     

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

     

       236
       236
       -
                   Some(vec![PatternItem::Base(Base::I)])

     

       237
       237
       -
               );

     

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

     

       239
       239
       -
       

     

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

     

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

     

       242
       242
       -
               assert_eq!(

     

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

     

       244
       244
       -
                   Some(vec![

     

       245
       245
       -
                       PatternItem::Open,

     

       246
       246
       -
                       PatternItem::Skip(2),

     

       247
       247
       -
                       PatternItem::Close,

     

       248
       248
       -
                       PatternItem::Base(Base::P)

     

       249
       249
       -
                   ])

     

       250
       250
       -
               );

     

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

     

       252
       252
       -
       

     

       253
       253
       -
               let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

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

     

       255
       255
       -
               assert_eq!(parser.pattern(&mut rna), Some(vec![]));

     

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

     

       257
       257
       -
               assert_eq!(

     

       258
       258
       -
                   rna,

     

       259
       259
       -
                   vec![[

     

       260
       260
       -
                       Base::P,

     

       261
       261
       -
                       Base::F,

     

       262
       262
       -
                       Base::C,

     

       263
       263
       -
                       Base::I,

     

       264
       264
       -
                       Base::C,

     

       265
       265
       -
                       Base::F,

     

       266
       266
       -
                       Base::P

     

       267
       267
       -
                   ]]

     

       268
       268
       -
               );

     

       269
       269
       -
           }

     

       270
       270
       -
       

     

       271
       271
       -
           #[test]

     

       272
       272
       -
           fn test_template() {

     

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

     

       274
       274
       -
       

     

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

     

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

     

       277
       277
       -
               assert_eq!(

     

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

     

       279
       279
       -
                   Some(vec![

     

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

     

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

     

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

     

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

     

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

     

       285
       285
       -
                       TemplateItem::Len(4)

     

       286
       286
       -
                   ])

     

       287
       287
       -
               );

     

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

     

       289
       289
       -
       

     

       290
       290
       -
               let dna = DnaRef::from_string("IIIPFCICFPIIC");

     

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

     

       292
       292
       -
               assert_eq!(parser.template(&mut rna), Some(vec![]));

     

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

     

       294
       294
       -
               assert_eq!(

     

       295
       295
       -
                   rna,

     

       296
       296
       -
                   vec![[

     

       297
       297
       -
                       Base::P,

     

       298
       298
       -
                       Base::F,

     

       299
       299
       -
                       Base::C,

     

       300
       300
       -
                       Base::I,

     

       301
       301
       -
                       Base::C,

     

       302
       302
       -
                       Base::F,

     

       303
       303
       -
                       Base::P

     

       304
       304
       -
                   ]]

     

       305
       305
       -
               );

     

       306
       306
       -
           }

     

       307
       307
       -
       }

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

-3

dna2rna/src/rna.rs

···

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

     

       2
       2
       -
       

     

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

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

prefixes/empty.dna

This is a binary file and will not be displayed.

-1

prefixes/repair_guide.dna

···

       1
       1
       -
       IIPIFFCPICFPPICIICCCIICIPPPCFIIC

-1

prefixes/startup.dna

···

       1
       1
       -
       IIPIFFCPICFPPICIICCIICIPPPFIIC

-1

prefixes/sun.dna

···

       1
       1
       -
       IIPIFFCPICPCIICICIICIPPPPIIC

-1

prefixes/task.dna

···

       1
       1
       -
       IIPIFFCPICICIICPIICIPPPICIIC

+28 -34

rna2bmp/src/rna_processor.rs

···

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

     

       134
       134
        
                       self.mark = self.position;

     

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

     

       136
       136
       -
                       // TODO: Can I rework this to reduce casts or locals?

     

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

     

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

     

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

     
···

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

     

       185
       184
        
                       }

     

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

     

       187
       187
       -
       	        // TODO: Better structure

     

       188
       188
       -
                       if let Some(bmp0) = self.bitmaps.pop() {

     

       189
       189
       -
                           if let Some(mut bmp1) = self.bitmaps.pop() {

     

       190
       190
       -
                               for x in 0..SIZE {

     

       191
       191
       -
                                   for y in 0..SIZE {

     

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

     

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

     

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

     

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

     

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

     

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

     

       198
       198
       -
                                       *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       199
       199
       -
                                   }

     

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

     

       200
       198
        
                               }

     

       201
       201
       -
                               self.bitmaps.push(bmp1);

     

       202
       202
       -
                           } else {

     

       203
       203
       -
       		        self.bitmaps.push(bmp0);

     

       204
       204
       -
       		    }

     

       199
       199
       +
                           }

     

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

     

       205
       201
        
                       }

     

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

     

       207
       207
       -
                       if let Some(bmp0) = self.bitmaps.pop() {

     

       208
       208
       -
                           if let Some(mut bmp1) = self.bitmaps.pop() {

     

       209
       209
       -
                               for x in 0..SIZE {

     

       210
       210
       -
                                   for y in 0..SIZE {

     

       211
       211
       -
                                       let (_, _, _, a0) = *bmp0.pixel((x, y));

     

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

     

       213
       213
       -
                                       let r = ((r1 as usize) * (a0 as usize) / 255) as u8;

     

       214
       214
       -
                                       let g = ((g1 as usize) * (a0 as usize) / 255) as u8;

     

       215
       215
       -
                                       let b = ((b1 as usize) * (a0 as usize) / 255) as u8;

     

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

     

       217
       217
       -
                                       *bmp1.pixel_mut((x, y)) = (r, g, b, a);

     

       218
       218
       -
                                   }

     

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

     

       219
       215
        
                               }

     

       220
       220
       -
                               self.bitmaps.push(bmp1);

     

       221
       221
       -
                           } else {

     

       222
       222
       -
       		        self.bitmaps.push(bmp0);

     

       223
       223
       -
       		    }

     

       216
       216
       +
                           }

     

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

     

       224
       218
        
                       }

     

       225
       219
        
                   }

     

       226
       220
        
               }

Compare changes