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

src/libcretonne/isa/riscv/settings.rs

@@ -1,5 +1,24 @@
 //! RISC-V Settings.
 
+use settings::{Descriptor, Detail, Stringwise, Result, Error};
+use std::fmt;
+
 // Include code generated by `meta/gen_settings.py`. This file contains a public `Settings` struct
 // with an impl for all of the settings defined in `meta/cretonne/settings.py`.
 include!(concat!(env!("OUT_DIR"), "/settings-riscv.rs"));
+
+#[cfg(test)]
+mod tests {
+    use super::Settings;
+
+    #[test]
+    fn display_default() {
+        let s = Settings::default();
+        assert_eq!(s.to_string(),
+                   "[riscv]\n\
+                    supports_m = false\n\
+                    supports_a = false\n\
+                    supports_f = false\n\
+                    supports_d = false\n");
+    }
+}

src/libcretonne/settings.rs

@@ -1,7 +1,134 @@
 //! Shared settings module.
 //!
 //! This module defines data structures to access the settings defined in the meta language.
+//!
+//! Each settings group is translated to a `Settings` struct either in this module or in its
+//! ISA-specific `settings` module. The struct provides individual getter methods for all of the
+//! settings. It also implements the `Stringwise` trait which allows settings to be manipulated by
+//! name.
+
+use std::fmt;
+use std::result;
+
+/// A setting descriptor holds the information needed to generically set and print a setting.
+///
+/// Each settings group will be represented as a constant DESCRIPTORS array.
+pub struct Descriptor {
+    /// Lower snake-case name of setting as defined in meta.
+    pub name: &'static str,
+
+    /// Offset of byte containing this setting.
+    pub offset: u32,
+
+    /// Additional details, depending on the kind of setting.
+    pub detail: Detail,
+}
+
+/// The different kind of settings along with descriptor bits that depend on the kind.
+#[derive(Clone, Copy)]
+pub enum Detail {
+    /// A boolean setting only uses one bit, numbered from LSB.
+    Bool {
+        bit: u8,
+    },
+
+    /// A numerical setting uses the whole byte.
+    Num,
+
+    /// An Enum setting uses a range of enumerators.
+    Enum {
+        /// Numerical value of last enumerator, allowing for 1-256 enumerators.
+        last: u8,
+
+        /// First enumerator in the ENUMERATORS table.
+        enumerators: u16,
+    },
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Error {
+    /// No setting by this name exists.
+    BadName,
+
+    /// Type mismatch for setting (e.g., setting an enum setting as a bool).
+    BadType,
+
+    /// This is not a valid value for this setting.
+    BadValue,
+}
+
+pub type Result<T> = result::Result<T, Error>;
+
+/// Interface for working with a group of settings as strings.
+pub trait Stringwise {
+    /// Look up a setting by name, return the details of the setting along with a reference to the
+    /// byte holding the value of the setting.
+    fn lookup_mut(&mut self, name: &str) -> Result<(Detail, &mut u8)>;
+
+    /// Get an enumerator string from the `Detail::enumerators` value and an offset.
+    fn enumerator(&self, enums: u16, value: u8) -> &'static str;
+
+    /// Format a setting value as a TOML string. This is mostly for use by the generateed `Display`
+    /// implementation.
+    fn format_toml_value(&self, detail: Detail, byte: u8, f: &mut fmt::Formatter) -> fmt::Result {
+        match detail {
+            Detail::Bool { bit } => write!(f, "{}", (byte & (1 << bit)) != 0),
+            Detail::Num => write!(f, "{}", byte),
+            Detail::Enum { last, enumerators } => {
+                if byte <= last {
+                    write!(f, "\"{}\"", self.enumerator(enumerators, byte))
+                } else {
+                    write!(f, "{}", byte)
+                }
+            }
+        }
+    }
+
+    /// Set a boolean setting by name.
+    fn set_bool(&mut self, name: &str, value: bool) -> Result<()> {
+        let (detail, byte) = try!(self.lookup_mut(name));
+        if let Detail::Bool { bit } = detail {
+            let mask = 1 << bit;
+            if value {
+                *byte |= mask;
+            } else {
+                *byte &= !mask;
+            }
+            Ok(())
+        } else {
+            Err(Error::BadType)
+        }
+    }
+}
 
 // Include code generated by `meta/gen_settings.py`. This file contains a public `Settings` struct
 // with an impl for all of the settings defined in `meta/cretonne/settings.py`.
 include!(concat!(env!("OUT_DIR"), "/settings.rs"));
+
+#[cfg(test)]
+mod tests {
+    use super::Settings;
+    use super::Error::*;
+    use super::Stringwise;
+
+    #[test]
+    fn display_default() {
+        let s = Settings::default();
+        assert_eq!(s.to_string(),
+                   "[shared]\n\
+                    enable_simd = true\n");
+    }
+
+    #[test]
+    fn modify_bool() {
+        let mut s = Settings::default();
+        assert_eq!(s.enable_simd(), true);
+        assert_eq!(s.set_bool("not_there", true), Err(BadName));
+
+        assert_eq!(s.set_bool("enable_simd", true), Ok(()));
+        assert_eq!(s.enable_simd(), true);
+
+        assert_eq!(s.set_bool("enable_simd", false), Ok(()));
+        assert_eq!(s.enable_simd(), false);
+    }
+}