#!/usr/bin/env python import re import sys import argparse field_file = "nodes.ads" kind_file = "iirs.ads" node_file = "iirs.ads" template_file = "iirs.adb.in" meta_base_file = "nodes_meta" prefix_name = "Iir_Kind_" prefix_range_name = "Iir_Kinds_" type_name = "Iir_Kind" node_type = "Iir" conversions = ['uc', 'pos', 'grp'] class FuncDesc: def __init__(self, name, fields, conv, acc, pname, ptype, rname, rtype): self.name = name self.fields = fields # List of physical fields used self.conv = conv self.acc = acc # access: Chain, Chain_Next, Ref, Of_Ref, Maybe_Ref, # Forward_Ref, Maybe_Forward_Ref self.pname = pname # Parameter mame self.ptype = ptype # Parameter type self.rname = rname # value name (for procedure) self.rtype = rtype # value type class NodeDesc: def __init__(self, name, format, fields, attrs): self.name = name self.format = format self.fields = fields # {field: FuncDesc} dict, defined for all fields self.attrs = attrs # A {attr: FuncDesc} dict self.order = [] # List of fields name, in order of appearance. class line: def __init__(self, string, no): self.l = string self.n = no class EndOfFile(Exception): def __init__(self, filename): self.filename = filename def __str__(self): return "end of file " + self.filename class linereader: def __init__(self, filename): self.filename = filename self.f = open(filename) self.lineno = 0 self.l = '' def get(self): self.l = self.f.readline() if not self.l: raise EndOfFile(self.filename) self.lineno = self.lineno + 1 return self.l class ParseError(Exception): def __init__(self, lr, msg): self.lr = lr self.msg = msg def __str__(self): return 'Error: ' + self.msg return 'Parse error at ' + self.lr.filname + ':' + self.lr.lineno + \ ': ' + self.msg # Return fields description. # This is a dictionary. The keys represent the possible format of a node. # The values are dictionnaries representing fields. Keys are fields name, and # values are fields type. def read_fields(file): fields = {} formats = [] lr = linereader(file) # Search for 'type Format_Type is' while lr.get() != ' type Format_Type is\n': pass # Skip '(' if lr.get() != ' (\n': raise 'no open parenthesis after Format_Type' # Read formats l = lr.get() pat_field_name = re.compile(' Format_(\w+),?\n') while l != ' );\n': m = pat_field_name.match(l) if m is None: print l raise 'bad literal within Format_Type' name = m.group(1) formats.append(name) fields[name] = {} l = lr.get() # Read fields l = lr.get() pat_fields = re.compile(' -- Fields of Format_(\w+):\n') pat_field_desc = re.compile(' -- (\w+) : (\w+).*\n') format_name = '' common_desc = {} # Read until common fields. while l != ' -- Common fields are:\n': l = lr.get() format_name = 'Common' nbr_formats = 0 while True: # 1) Read field description l = lr.get() desc = common_desc.copy() while True: m = pat_field_desc.match(l) if m is None: break desc[m.group(1)] = m.group(2) l = lr.get() # print 'For: ' + format_name + ': ' + m.group(1) # 2) Disp if format_name == 'Common': common_desc = desc else: fields[format_name] = desc # 3) Read next format if l == '\n': if nbr_formats == len(fields): break else: l = lr.get()

# Atmel AVR

QMK should run on any Atmel AVR processor with enough Flash. It has been tested on the following:

* ATmega32U4 ([PJRC Teensy 2.0](http://www.pjrc.com/teensy/))
* AT90USB1286 ([PJRC Teensy++ 2.0](http://www.pjrc.com/teensy/))
* AT90USB1287 ([Atmel USBKEY](http://www.atmel.com/tools/AT90USBKEY.aspx))
* ATmega168P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
* ATmega328P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
* ATmega32U2
* AT90USB1286, 646, 647 should work
* AT90USB162 testing...

NOTE: To enable full features of firmware you'll need 32KB flash size.

Please add any tested microcontrollers to this list.

# ARM

You can also use any ARM processor that [ChibiOS](http://www.chibios.org) supports. The following processors have been tested:

* [Kinetis MKL26Z64](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/l-series-ultra-low-power-m0-plus/kinetis-kl2x-48-mhz-usb-ultra-low-power-microcontrollers-mcus-based-on-arm-cortex-m0-plus-core:KL2x)
* [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
* [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
* [Kinetis MK20DX256](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/k-series-performance-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)

odes # Skip comments while pat_comment.match(l): l = lr.get() # Handle field: '-- Get/Set_FUNC (Alias? FIELD)' m = pat_field.match(l) if not m: if pat_only_bad.match(l): raise ParseError(lr, "misleading 'Only for' comment") else: raise ParseError(lr, 'bad line in node description') func = m.group(1) alias = m.group(2) fields = m.group(3).split(',') # Check the function exists and if the field is correct. if func not in funcs_dict: raise ParseError(lr, 'unknown function') func = funcs_dict[func] if func.fields != fields: raise ParseError(lr, 'fields mismatch') for c in only_nodes: for f in fields: if f not in c.fields: raise ParseError( lr, 'field ' + f + ' does not exist in node') if not alias: for f in fields: if c.fields[f]: raise ParseError( lr, 'field ' + f + ' already used') c.fields[f] = func c.order.append(f) c.attrs[func.name] = func l = lr.get() def read_nodes(filename, kinds, kinds_ranges, fields, funcs): """Read description for all nodes.""" lr = linereader(filename) funcs_dict = {x.name: x for x in funcs} nodes = {} # Skip until start while lr.get() != ' -- Start of ' + type_name + '.\n': pass pat_decl = re.compile(' -- ' + prefix_name + '(\w+) \((\w+)\)\n') pat_decls = re.compile(' -- ' + prefix_range_name + '(\w+) \((\w+)\)\n') pat_comment_line = re.compile(' --+\n') pat_comment_box = re.compile(' --( .*)?\n') while True: l = lr.get() if l == ' -- End of ' + type_name + '.\n': break if l == '\n': continue m = pat_decl.match(l) if m: # List of nodes being described by the current description. names = [] # Declaration of the first node while True: name = m.group(1) if name not in kinds: raise ParseError(lr, 'unknown node') fmt = m.group(2) names.append((name, fmt)) if name in nodes: raise ParseError( lr, 'node {} already described'.format(name)); # There might be several nodes described at once. l = lr.get() m = pat_decl.match(l) if not m: break read_nodes_fields(lr, names, fields, nodes, funcs_dict) continue m = pat_decls.match(l) if m: # List of nodes being described by the current description. name = m.group(1) fmt = m.group(2) names = [(k, fmt) for k in kinds_ranges[name]] l = lr.get() read_nodes_fields(lr, names, fields, nodes, funcs_dict) continue if pat_comment_line.match(l) or pat_comment_box.match(l): continue raise ParseError(lr, 'bad line in node description') for k in kinds: if k not in nodes: raise ParseError(lr, 'no desription for "{}"'.format(k)) return nodes def gen_choices(choices): """Generate a choice 'when A | B ... Z =>' using elements of CHOICES.""" is_first = True for c in choices: if is_first: print ' ', print 'when', else: print print ' ', print ' |', print prefix_name + c, is_first = False print '=>' def gen_get_format(formats, nodes, kinds): """Generate the Get_Format function.""" print ' function Get_Format (Kind : ' + type_name + ') ' + \ 'return Format_Type is' print ' begin' print ' case Kind is' for f in formats: choices = [k for k in kinds if nodes[k].format == f] gen_choices(choices) print ' return Format_' + f + ';' print ' end case;' print ' end Get_Format;' def gen_subprg_header(decl): if len(decl) < 76: print decl + ' is' else: print decl print ' is' print ' begin' def gen_assert(func): print ' pragma Assert (' + func.pname + ' /= Null_' + node_type + ');' cond = '(Has_' + func.name + ' (Get_Kind (' + func.pname + ')),' msg = '"no field ' + func.name + '");' if len(cond) < 60: print ' pragma Assert ' + cond print ' ' + msg else: print ' pragma Assert' print ' ' + cond print ' ' + msg def get_field_type(fields, f): for fld in fields.values(): if f in fld: return fld[f] return None def gen_get_set(func, nodes, fields): """Generate Get_XXX/Set_XXX subprograms for FUNC.""" rtype = func.rtype # If the function needs several fields, it must be user defined if func.conv == 'grp': print ' type %s_Conv is record' % rtype for f in func.fields: print ' %s: %s;' % (f, get_field_type(fields, f)) print ' end record;' print ' pragma Pack (%s_Conv);' % rtype print " pragma Assert (%s_Conv'Size = %s'Size);" % (rtype, rtype) print else: f = func.fields[0] g = 'Get_' + f + ' (' + func.pname + ')' s = func.rname if func.conv: if func.conv == 'uc': field_type = get_field_type(fields, f) g = field_type + '_To_' + rtype + ' (' + g + ')' s = rtype + '_To_' + field_type + ' (' + s + ')' elif func.conv == 'pos': g = rtype + "'Val (" + g + ')' s = rtype + "'Pos (" + s + ')' subprg = ' function Get_' + func.name + ' (' + func.pname \ + ' : ' + func.ptype + ') return ' + rtype if func.conv == 'grp': print subprg print ' is' print ' function To_%s is new Ada.Unchecked_Conversion' % \ func.rtype print ' (%s_Conv, %s);' % (rtype, rtype) print ' Conv : %s_Conv;' % rtype print ' begin' else: gen_subprg_header(subprg) gen_assert(func) if func.conv == 'grp': for f in func.fields: print ' Conv.%s := Get_%s (%s);' % (f, f, func.pname) g = 'To_%s (Conv)' % rtype print ' return ' + g + ';' print ' end Get_' + func.name + ';' print subprg = ' procedure Set_' + func.name + ' (' \ + func.pname + ' : ' + func.ptype + '; ' \ + func.rname + ' : ' + func.rtype + ')' if func.conv == 'grp': print subprg print ' is' print ' function To_%s_Conv is new Ada.Unchecked_Conversion' % \ func.rtype print ' (%s, %s_Conv);' % (rtype, rtype) print ' Conv : %s_Conv;' % rtype print ' begin' else: gen_subprg_header(subprg) gen_assert(func) if func.conv == 'grp': print ' Conv := To_%s_Conv (%s);' % (rtype, func.rname) for f in func.fields: print ' Set_%s (%s, Conv.%s);' % (f, func.pname, f) else: print ' Set_' + f + ' (' + func.pname + ', ' + s + ');' print ' end Set_' + func.name + ';' print def funcs_of_node(n): return sorted([fv.name for fv in n.fields.values() if fv]) def gen_has_func_spec(name, suff): spec = ' function Has_' + name + ' (K : ' + type_name + ')' ret = ' return Boolean' + suff if len(spec) < 60: print spec + ret else: print spec print ' ' + ret def do_disp_formats(): for fmt in fields: print "Fields of Format_"+fmt fld = fields[fmt] for k in fld: print ' ' + k + ' (' + fld[k] + ')' def do_disp_kinds(): print "Kinds are:" for k in kinds: print ' ' + prefix_name + k def do_disp_funcs(): print "Functions are:" for f in funcs: s = '{0} ({1}: {2}'.format(f.name, f.field, f.rtype) if f.acc: s += ' acc:' + f.acc if f.conv: s += ' conv:' + f.conv s += ')' print s def do_disp_types(): print "Types are:" s = set([]) for f in funcs: s |= set([f.rtype]) for t in sorted(s): print ' ' + t def do_disp_nodes(): for k in kinds: v = nodes[k] print prefix_name + k + ' (' + v.format + ')' flds = [fk for fk, fv in v.fields.items() if fv] for fk in sorted(flds): print ' ' + fk + ': ' + v.fields[fk].name def do_get_format(): gen_get_format(formats, nodes) def do_body(): lr = linereader(template_file) while True: l = lr.get().rstrip() print l if l == ' -- Subprograms': gen_get_format(formats, nodes, kinds) print for f in funcs: gen_get_set(f, nodes, fields) if l[0:3] == 'end': break def get_types(): s = set([]) for f in funcs: s |= set([f.rtype]) return [t for t in sorted(s)] def get_attributes(): s = set([]) for f in funcs: if f.acc: s |= set([f.acc]) res = [t for t in sorted(s)] res.insert(0, 'None') return res def gen_enum(prefix, vals): last = None for v in vals: if last: print last + ',' last = prefix + v print last def do_meta_specs(): lr = linereader(meta_base_file + '.ads.in') types = get_types() while True: l = lr.get().rstrip() if l == ' -- TYPES': gen_enum(' Type_', types) elif l == ' -- FIELDS': gen_enum(' Field_', [f.name for f in funcs]) elif l == ' -- ATTRS': gen_enum(' Attr_', get_attributes()) elif l == ' -- FUNCS': for t in types: print ' function Get_' + t print ' (N : ' + node_type + '; F : Fields_Enum) return '\ + t + ';' print ' procedure Set_' + t print ' (N : ' + node_type + '; F : Fields_Enum; V: ' \ + t + ');' print for f in funcs: gen_has_func_spec(f.name, ';') elif l[0:3] == 'end': print l break else: print l def do_meta_body(): lr = linereader(meta_base_file + '.adb.in') while True: l = lr.get().rstrip() if l == ' -- FIELDS_TYPE': last = None for f in funcs: if last: print last + ',' last = ' Field_' + f.name + ' => Type_' + f.rtype print last elif l == ' -- FIELD_IMAGE': for f in funcs: print ' when Field_' + f.name + ' =>' print ' return "' + f.name.lower() + '";' elif l == ' -- IIR_IMAGE': for k in kinds: print ' when ' + prefix_name + k + ' =>' print ' return "' + k.lower() + '";' elif l == ' -- FIELD_ATTRIBUTE': for f in funcs: print ' when Field_' + f.name + ' =>' if f.acc: attr = f.acc else: attr = 'None' print ' return Attr_' + attr + ';' elif l == ' -- FIELDS_ARRAY': last = None nodes_types = [node_type, node_type + '_List', node_type + '_Flist'] for k in kinds: v = nodes[k] if last: print last + ',' last = None print ' -- ' + prefix_name + k # Get list of physical fields for V, in some order. if flag_keep_order: flds = v.order else: # First non Iir and no Iir_List. flds = sorted([fk for fk, fv in v.fields.items() if fv and fv.rtype not in nodes_types]) # Then Iir and Iir_List in order of appearance flds += (fv for fv in v.order if v.fields[fv].rtype in nodes_types) # Print the corresponding node field, but remove duplicate due # to 'grp'. fldsn = [] for fk in flds: if last: print last + ',' # Remove duplicate fn = v.fields[fk].name if fn not in fldsn: last = ' Field_' + fn fldsn.append(fn) else: last = None if last: print last elif l == ' -- FIELDS_ARRAY_POS': pos = -1 last = None for k in kinds: v = nodes[k] # Create a set to remove duplicate for 'grp'. flds = set([fv.name for fk, fv in v.fields.items() if fv]) pos += len(flds) if last: print last + ',' last = ' ' + prefix_name + k + ' => {}'.format(pos) print last elif l == ' -- FUNCS_BODY': # Build list of types s = set([]) for f in funcs: s |= set([f.rtype]) types = [t for t in sorted(s)] for t in types: print ' function Get_' + t print ' (N : ' + node_type + '; F : Fields_Enum) return '\ + t + ' is' print ' begin' print ' pragma Assert (Fields_Type (F) = Type_' + t + ');' print ' case F is' for f in funcs: if f.rtype == t: print ' when Field_' + f.name + ' =>' print ' return Get_' + f.name + ' (N);' print ' when others =>' print ' raise Internal_Error;' print ' end case;' print ' end Get_' + t + ';' print print ' procedure Set_' + t print ' (N : ' + node_type + '; F : Fields_Enum; V: ' \ + t + ') is' print ' begin' print ' pragma Assert (Fields_Type (F) = Type_' + t + ');' print ' case F is' for f in funcs: if f.rtype == t: print ' when Field_' + f.name + ' =>' print ' Set_' + f.name + ' (N, V);' print ' when others =>' print ' raise Internal_Error;' print ' end case;' print ' end Set_' + t + ';' print for f in funcs: gen_has_func_spec(f.name, ' is') choices = [k for k in kinds if f.name in nodes[k].attrs] if len(choices) == 0: print ' pragma Unreferenced (K);' print ' begin' if len(choices) == 0: print ' return False;' elif len(choices) == 1: print ' return K = ' + prefix_name + choices[0] + ';' else: print ' case K is' gen_choices(choices) print ' return True;' print ' when others =>' print ' return False;' print ' end case;' print ' end Has_' + f.name + ';' print elif l[0:3] == 'end': print l break else: print l actions = {'disp-nodes': do_disp_nodes, 'disp-kinds': do_disp_kinds, 'disp-formats': do_disp_formats, 'disp-funcs': do_disp_funcs, 'disp-types': do_disp_types, 'get_format': do_get_format, 'body': do_body, 'meta_specs': do_meta_specs, 'meta_body': do_meta_body} def main(): parser = argparse.ArgumentParser(description='Meta-grammar processor') parser.add_argument('action', choices=actions.keys(), default='disp-nodes') parser.add_argument('--field-file', dest='field_file', default='nodes.ads', help='specify file which defines fields') parser.add_argument('--kind-file', dest='kind_file', default='iirs.ads', help='specify file which defines nodes kind') parser.add_argument('--node-file', dest='node_file', default='iirs.ads', help='specify file which defines nodes and methods') parser.add_argument('--template-file', dest='template_file', default='iirs.adb.in', help='specify template body file') parser.add_argument('--meta-basename', dest='meta_basename', default='nodes_meta', help='specify base name of meta files') parser.add_argument('--kind-type', dest='kind_type', default='Iir_Kind', help='name of kind type') parser.add_argument('--kind-prefix', dest='kind_prefix', default='Iir_Kind_', help='prefix for kind literals') parser.add_argument('--kind-range-prefix', dest='kind_range_prefix', default='Iir_Kinds_', help='prefix for kind subtype (range)') parser.add_argument('--node-type', dest='node_type', default='Iir', help='name of the node type') parser.add_argument('--keep-order', dest='flag_keep_order', action='store_true', help='keep field order of nodes') parser.set_defaults(flag_keep_order=False) args = parser.parse_args() # At some point, it would be simpler to create a class... global formats, fields, nodes, kinds, kinds_ranges, funcs global type_name, prefix_name, template_file, node_type, meta_base_file global prefix_range_name, flag_keep_order, kind_file type_name = args.kind_type prefix_name = args.kind_prefix prefix_range_name = args.kind_range_prefix template_file = args.template_file node_type = args.node_type meta_base_file = args.meta_basename flag_keep_order = args.flag_keep_order field_file = args.field_file kind_file = args.kind_file node_file = args.node_file try: (formats, fields) = read_fields(field_file) (kinds, kinds_ranges) = read_kinds(kind_file) funcs = read_methods(node_file) nodes = read_nodes(node_file, kinds, kinds_ranges, fields, funcs) except ParseError as e: print >> sys.stderr, e print >> sys.stderr, \ "in {0}:{1}:{2}".format(e.lr.filename, e.lr.lineno, e.lr.l) sys.exit(1) f = actions.get(args.action, None) if not f: print >> sys.stderr, "Action {0} is unknown".format(args.action) sys.exit(1) f() if __name__ == '__main__': main()