commit 7dde1cae4ac07ca107bf8bad9edb6c99e9a733a7 · drubery.com/icfp2007

+14 -6

dna2rna/src/match_replace.rs

···

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

     

       132
       132
        
                       }

     

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

     

       134
       134
       -
                           let (start, end) = matched.groups[n];

     

       135
       135
       -
                           let (_, rhs) = dna.split(start);

     

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

     

       137
       137
       -
                           replace += protect(group, l);

     

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

     

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

     

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

     

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

     

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

     

       139
       139
       +
                           } else {

     

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

     

       141
       141
       +
                           }

     

       138
       142
        
                       }

     

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

     

       140
       140
       -
                           let (start, end) = matched.groups[n];

     

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

     

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

     

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

     

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

     

       147
       147
       +
                           } else {

     

       148
       148
       +
                               replace += asnat(0);

     

       149
       149
       +
                           }

     

       142
       150
        
                       }

     

       143
       151
        
                   }

     

       144
       152
        
               }

prefixes/startup.dna

···

       1
       1
       +
       IIPIFFCPICFPPICIICCIICIPPPFIIC

+9 -4

rna2bmp/src/bitmap.rs

···

       2
       2
        
       

     

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

     

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

     

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

     

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

     

       7
       7
       +
       // to have.

     

       5
       8
        
       pub struct Bitmap {

     

       6
       6
       -
           data: [[Pixel; SIZE]; SIZE],

     

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

     

       7
       10
        
       }

     

       8
       11
        
       

     

       9
       12
        
       impl Bitmap {

     

       10
       13
        
           pub fn new() -> Bitmap {

     

       11
       14
        
               Bitmap {

     

       12
       12
       -
                   data: [[(0, 0, 0, 0); SIZE]; SIZE],

     

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

     

       13
       16
        
               }

     

       14
       17
        
           }

     

       15
       18
        
       

     
···

       25
       28
        
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       30
       30
       -
               writer.output_u32((0x36 + SIZE * (3 * SIZE + row_padding)) as u32); // Size

     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

rna2bmp/src/main.rs

···

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

     

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

     

       22
       22
        
                   }

     

       23
       23
       +
               } else {

     

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

     

       23
       25
        
               }

     

       24
       26
        
           } else {

     

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

+18 -10

rna2bmp/src/rna_processor.rs

···

       51
       51
        
       

     

       52
       52
        
               return (

     

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

     

       54
       54
       -
                   (r * g / 255) as u8,

     

       55
       55
       -
                   (r * b / 255) as u8,

     

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

     

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

     

       56
       56
        
                   a as u8,

     

       57
       57
        
               );

     

       58
       58
        
           }

     
···

       86
       86
        
                   position: (0, 0),

     

       87
       87
        
                   mark: (0, 0),

     

       88
       88
        
                   dir: (1, 0),

     

       89
       89
       -
                   bitmaps: Vec::new(),

     

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

     

       90
       90
        
               }

     

       91
       91
        
           }

     

       92
       92
        
       

     
···

       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?

     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

       146
       146
       -
                       let mut y = x0 * d + (d - c) / 2;

     

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

     

       147
       147
        
                       for _ in 0..d {

     

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

     

       149
       149
        
                           x += dx;

     
···

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

     

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

     

       156
       156
        
                           let new = self.bucket.current_pixel();

     

       157
       157
       +
                           if new == old {

     

       158
       158
       +
                               continue;

     

       159
       159
       +
                           }

     

       157
       160
        
                           let mut to_fill = Vec::new();

     

       158
       161
        
                           to_fill.push(self.position);

     

       159
       162
        
                           while let Some(p) = to_fill.pop() {

     
···

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

     

       182
       185
        
                       }

     

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

     

       187
       187
       +
       	        // TODO: Better structure

     

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

     

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

     

       186
       190
        
                               for x in 0..SIZE {

     

       187
       191
        
                                   for y in 0..SIZE {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       195
       199
        
                                   }

     

       196
       200
        
                               }

     

       197
       201
        
                               self.bitmaps.push(bmp1);

     

       198
       198
       -
                           }

     

       202
       202
       +
                           } else {

     

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

     

       204
       204
       +
       		    }

     

       199
       205
        
                       }

     

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

     

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

     
···

       203
       209
        
                               for x in 0..SIZE {

     

       204
       210
        
                                   for y in 0..SIZE {

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       212
       218
        
                                   }

     

       213
       219
        
                               }

     

       214
       220
        
                               self.bitmaps.push(bmp1);

     

       215
       215
       -
                           }

     

       221
       221
       +
                           } else {

     

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

     

       223
       223
       +
       		    }

     

       216
       224
        
                       }

     

       217
       225
        
                   }

     

       218
       226
        
               }