Add settings::Stringwise.

This trait allows settings to be manipulated as strings, using descriptors and
constant hash-table lookups.

Amend gen_settings.py to generate the necessary constant tables.

meta/gen_settings.py

@@ -3,6 +3,8 @@ Generate sources with settings.
 """
 
 import srcgen
+from unique_table import UniqueSeqTable
+import constant_hash
 from cretonne import BoolSetting, NumSetting, settings
 
 
@@ -84,6 +86,114 @@ def gen_default(sgrp, byte_size, fmt):
                 fmt.line('bytes: [ {} ],'.format(vs))
 
 
+def gen_descriptors(sgrp, fmt):
+    """
+    Generate the DESCRIPTORS and ENUMERATORS tables.
+    """
+
+    enums = UniqueSeqTable()
+
+    with fmt.indented(
+            'const DESCRIPTORS: [Descriptor; {}] = ['
+            .format(len(sgrp.settings)),
+            '];'):
+        for idx, setting in enumerate(sgrp.settings):
+            setting.descriptor_index = idx
+            with fmt.indented('Descriptor {', '},'):
+                fmt.line('name: "{}",'.format(setting.name))
+                fmt.line('offset: {},'.format(setting.byte_offset))
+                if isinstance(setting, BoolSetting):
+                    fmt.line(
+                            'detail: Detail::Bool {{ bit: {} }},'
+                            .format(setting.bit_offset))
+                elif isinstance(setting, NumSetting):
+                    fmt.line('detail: Detail::Num,')
+                else:
+                    raise AssertionError("Unknown setting kind")
+
+    with fmt.indented(
+            'const ENUMERATORS: [&\'static str; {}] = ['
+            .format(len(enums.table)),
+            '];'):
+        for txt in enums.table:
+            fmt.line('"{}",'.format(txt))
+
+    def hash_setting(s):
+        return constant_hash.simple_hash(s.name)
+
+    hash_table = constant_hash.compute_quadratic(sgrp.settings, hash_setting)
+    if len(sgrp.settings) > 0xffff:
+        ty = 'u32'
+    elif len(sgrp.settings) > 0xff:
+        ty = 'u16'
+    else:
+        ty = 'u8'
+
+    with fmt.indented(
+            'const HASH_TABLE: [{}; {}] = ['
+            .format(ty, len(hash_table)),
+            '];'):
+        for h in hash_table:
+            if h is None:
+                fmt.line('{},'.format(len(sgrp.settings)))
+            else:
+                fmt.line('{},'.format(h.descriptor_index))
+
+
+def gen_stringwise(sgrp, fmt):
+    """
+    Generate the Stringwise implementation and supporting tables.
+    """
+
+    with fmt.indented('impl Stringwise for Settings {', '}'):
+        with fmt.indented(
+                'fn lookup_mut(&mut self, name: &str)' +
+                '-> Result<(Detail, &mut u8)> {',
+                '}'):
+            fmt.line('use simple_hash::simple_hash;')
+            fmt.line('let tlen = HASH_TABLE.len();')
+            fmt.line('assert!(tlen.is_power_of_two());')
+            fmt.line('let mut idx = simple_hash(name) as usize;')
+            fmt.line('let mut step: usize = 0;')
+            with fmt.indented('loop {', '}'):
+                fmt.line('idx = idx % tlen;')
+                fmt.line('let entry = HASH_TABLE[idx] as usize;')
+                with fmt.indented('if entry >= DESCRIPTORS.len() {', '}'):
+                    fmt.line('return Err(Error::BadName)')
+                with fmt.indented('if DESCRIPTORS[entry].name == name {', '}'):
+                    fmt.line(
+                            'return Ok((DESCRIPTORS[entry].detail, ' +
+                            '&mut self.bytes[DESCRIPTORS[entry].offset ' +
+                            'as usize]))')
+                fmt.line('step += 1;')
+                fmt.line('assert!(step < tlen);')
+                fmt.line('idx += step;')
+
+        with fmt.indented(
+                'fn enumerator(&self, enums: u16, value: u8)' +
+                '-> &\'static str {',
+                '}'):
+            fmt.line('ENUMERATORS[enums as usize + value as usize]')
+
+
+def gen_display(sgrp, fmt):
+    """
+    Generate the Display impl for Settings.
+    """
+    with fmt.indented('impl fmt::Display for Settings {', '}'):
+        with fmt.indented(
+                'fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {',
+                '}'):
+            fmt.line('try!(writeln!(f, "[{}]"));'.format(sgrp.name))
+            with fmt.indented('for d in &DESCRIPTORS {', '}'):
+                fmt.line('try!(write!(f, "{} = ", d.name));')
+                fmt.line(
+                        'try!(self.format_toml_value(d.detail,' +
+                        'self.bytes[d.offset as usize], f));')
+                fmt.line('try!(writeln!(f, ""));')
+            fmt.line('Ok(())')
+
+
 def gen_group(sgrp, fmt):
     """
     Generate a Settings struct representing `sgrp`.
@@ -96,6 +206,9 @@ def gen_group(sgrp, fmt):
 
     gen_getters(sgrp, fmt)
     gen_default(sgrp, byte_size, fmt)
+    gen_descriptors(sgrp, fmt)
+    gen_stringwise(sgrp, fmt)
+    gen_display(sgrp, fmt)
 
 
 def generate(isas, out_dir):