def gen_getter(setting, sgrp, fmt): # type: (Setting, SettingGroup, srcgen.Formatter) -> None """ Emit a getter function for `setting`. """ fmt.doc_comment(setting.__doc__) if isinstance(setting, BoolSetting): proto = 'pub fn {}(&self) -> bool'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line( 'self.numbered_predicate({})' .format(sgrp.predicate_number[setting])) elif isinstance(setting, NumSetting): proto = 'pub fn {}(&self) -> u8'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line('self.bytes[{}]'.format(setting.byte_offset)) elif isinstance(setting, EnumSetting): ty = camel_case(setting.name) proto = 'pub fn {}(&self) -> {}'.format(setting.name, ty) with fmt.indented(proto + ' {', '}'): with fmt.indented( 'match self.bytes[{}] {{' .format(setting.byte_offset), '}'): for i, v in enumerate(setting.values): fmt.line('{} => {}::{},'.format(i, ty, camel_case(v))) fmt.line('_ => panic!("Invalid enum value"),') else: raise AssertionError("Unknown setting kind")
def gen_getter(setting, sgrp, fmt): # type: (Setting, SettingGroup, srcgen.Formatter) -> None """ Emit a getter function for `setting`. """ fmt.doc_comment(setting.__doc__) if isinstance(setting, BoolSetting): proto = 'pub fn {}(&self) -> bool'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line( 'self.numbered_predicate({})' .format(sgrp.predicate_number[setting])) elif isinstance(setting, NumSetting): proto = 'pub fn {}(&self) -> u8'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line('self.bytes[{}]'.format(setting.byte_offset)) elif isinstance(setting, EnumSetting): ty = camel_case(setting.name) proto = 'pub fn {}(&self) -> {}'.format(setting.name, ty) with fmt.indented(proto + ' {', '}'): m = srcgen.Match('self.bytes[{}]'.format(setting.byte_offset)) for i, v in enumerate(setting.values): m.arm(str(i), [], '{}::{}'.format(ty, camel_case(v))) m.arm('_', [], 'panic!("Invalid enum value")') fmt.match(m) else: raise AssertionError("Unknown setting kind")
def gen_getter(setting, sgrp, fmt): """ Emit a getter function for `setting`. """ fmt.doc_comment(setting.__doc__) if isinstance(setting, BoolSetting): proto = 'pub fn {}(&self) -> bool'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line('self.numbered_predicate({})'.format( sgrp.predicate_number[setting])) elif isinstance(setting, NumSetting): proto = 'pub fn {}(&self) -> u8'.format(setting.name) with fmt.indented(proto + ' {', '}'): fmt.line('self.bytes[{}]'.format(setting.byte_offset)) elif isinstance(setting, EnumSetting): ty = camel_case(setting.name) proto = 'pub fn {}(&self) -> {}'.format(setting.name, ty) with fmt.indented(proto + ' {', '}'): with fmt.indented( 'match self.bytes[{}] {{'.format(setting.byte_offset), '}'): for i, v in enumerate(setting.values): fmt.line('{} => {}::{},'.format(i, ty, camel_case(v))) fmt.line('_ => panic!("Invalid enum value")') else: raise AssertionError("Unknown setting kind")
def gen_enum_types(sgrp, fmt): """ Emit enum types for any enum settings. """ for setting in sgrp.settings: if not isinstance(setting, EnumSetting): continue ty = camel_case(setting.name) fmt.doc_comment("Values for {}.".format(setting)) fmt.line("#[derive(Debug, PartialEq, Eq)]") with fmt.indented("pub enum {} {{".format(ty), "}"): for v in setting.values: fmt.doc_comment("`{}`.".format(v)) fmt.line(camel_case(v) + ",")
def gen_enum_types(sgrp, fmt): """ Emit enum types for any enum settings. """ for setting in sgrp.settings: if not isinstance(setting, EnumSetting): continue ty = camel_case(setting.name) fmt.doc_comment('Values for {}.'.format(setting)) fmt.line('#[derive(Debug, PartialEq, Eq)]') with fmt.indented('pub enum {} {{'.format(ty), '}'): for v in setting.values: fmt.doc_comment('`{}`.'.format(v)) fmt.line(camel_case(v) + ',')
def gen_enum_types(sgrp, fmt): # type: (SettingGroup, srcgen.Formatter) -> None """ Emit enum types for any enum settings. """ for setting in sgrp.settings: if not isinstance(setting, EnumSetting): continue ty = camel_case(setting.name) fmt.doc_comment('Values for {}.'.format(setting)) fmt.line('#[derive(Debug, PartialEq, Eq)]') with fmt.indented('pub enum {} {{'.format(ty), '}'): for v in setting.values: fmt.doc_comment('`{}`.'.format(v)) fmt.line(camel_case(v) + ',')
def get_constraint(op, ctrl_typevar, type_sets): # type: (Operand, TypeVar, UniqueTable) -> str """ Get the value type constraint for an SSA value operand, where `ctrl_typevar` is the controlling type variable. Each operand constraint is represented as a string, one of: - `Concrete(vt)`, where `vt` is a value type name. - `Free(idx)` where `idx` is an index into `type_sets`. - `Same`, `Lane`, `AsBool` for controlling typevar-derived constraints. """ assert op.is_value() tv = op.typevar # A concrete value type. if tv.singleton_type(): return 'Concrete({})'.format(tv.singleton_type().rust_name()) if tv.free_typevar() is not ctrl_typevar: assert not tv.is_derived return 'Free({})'.format(type_sets.add(tv.type_set)) if tv.is_derived: assert tv.base is ctrl_typevar, "Not derived from ctrl_typevar" return camel_case(tv.derived_func) assert tv is ctrl_typevar return 'Same'
def gen_enum_types(sgrp, fmt): # type: (SettingGroup, srcgen.Formatter) -> None """ Emit enum types for any enum settings. """ for setting in sgrp.settings: if not isinstance(setting, EnumSetting): continue ty = camel_case(setting.name) fmt.doc_comment('Values for `{}`.'.format(setting)) fmt.line('#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]') with fmt.indented('pub enum {} {{'.format(ty), '}'): for v in setting.values: fmt.doc_comment('`{}`.'.format(v)) fmt.line(camel_case(v) + ',') gen_to_and_from_str(ty, setting.values, fmt)
def gen_to_and_from_str(ty, values, fmt): # type: (str, Tuple[str, ...], srcgen.Formatter) -> None """ Emit Display and FromStr implementations for enum settings. """ with fmt.indented('impl fmt::Display for {} {{'.format(ty), '}'): with fmt.indented( 'fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {', '}'): with fmt.indented('f.write_str(match *self {', '})'): for v in values: fmt.line('{}::{} => "{}",'.format(ty, camel_case(v), v)) with fmt.indented('impl str::FromStr for {} {{'.format(ty), '}'): fmt.line('type Err = ();') with fmt.indented('fn from_str(s: &str) -> Result<Self, Self::Err> {', '}'): with fmt.indented('match s {', '}'): for v in values: fmt.line('"{}" => Ok({}::{}),'.format( v, ty, camel_case(v))) fmt.line('_ => Err(()),')
def gen_getter(setting, sgrp, fmt): """ Emit a getter function for `setting`. """ fmt.doc_comment(setting.__doc__) if isinstance(setting, BoolSetting): proto = "pub fn {}(&self) -> bool".format(setting.name) with fmt.indented(proto + " {", "}"): fmt.line("self.numbered_predicate({})".format(sgrp.predicate_number[setting])) elif isinstance(setting, NumSetting): proto = "pub fn {}(&self) -> u8".format(setting.name) with fmt.indented(proto + " {", "}"): fmt.line("self.bytes[{}]".format(setting.byte_offset)) elif isinstance(setting, EnumSetting): ty = camel_case(setting.name) proto = "pub fn {}(&self) -> {}".format(setting.name, ty) with fmt.indented(proto + " {", "}"): with fmt.indented("match self.bytes[{}] {{".format(setting.byte_offset), "}"): for i, v in enumerate(setting.values): fmt.line("{} => {}::{},".format(i, ty, camel_case(v))) fmt.line('_ => panic!("Invalid enum value")') else: raise AssertionError("Unknown setting kind")