text: #encoding=utf-8
  
  from __future__ import (
      absolute_import, division, print_function, unicode_literals
  )
  import ast
  import xml.parsers.expat
  import re
  import sys
  import copy
  import textwrap
  
  license =  """/*
   * Copyright (C) 2016 Intel Corporation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice (including the next
   * paragraph) shall be included in all copies or substantial portions of the
   * Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   * IN THE SOFTWARE.
   */
  """
  
  pack_header = """%(license)s
  
  /* Instructions, enums and structures for %(platform)s.
   *
   * This file has been generated, do not hand edit.
   */
  
  #ifndef %(guard)s
  #define %(guard)s
  
  #include <stdio.h>
  #include <stdint.h>
  #include <stdbool.h>
  #include <assert.h>
  #include <math.h>
  
  #ifndef __gen_validate_value
  #define __gen_validate_value(x)
  #endif
  
  #ifndef __gen_field_functions
  #define __gen_field_functions
  
  union __gen_value {
     float f;
     uint32_t dw;
  };
  
  static inline uint64_t
  __gen_mbo(uint32_t start, uint32_t end)
  {
     return (~0ull >> (64 - (end - start + 1))) << start;
  }
  
  static inline uint64_t
  __gen_uint(uint64_t v, uint32_t start, uint32_t end)
  {
     __gen_validate_value(v);
  
  #if DEBUG
     const int width = end - start + 1;
     if (width < 64) {
        const uint64_t max = (1ull << width) - 1;
        assert(v <= max);
     }
  #endif
  
     return v << start;
  }
  
  static inline uint64_t
  __gen_sint(int64_t v, uint32_t start, uint32_t end)
  {
     const int width = end - start + 1;
  
     __gen_validate_value(v);
  
  #if DEBUG
     if (width < 64) {
        const int64_t max = (1ll << (width - 1)) - 1;
        const int64_t min = -(1ll << (width - 1));
        assert(min <= v && v <= max);
     }
  #endif
  
     const uint64_t mask = ~0ull >> (64 - width);
  
     return (v & mask) << start;
  }
  
  static inline uint64_t
  __gen_offset(uint64_t v, uint32_t start, uint32_t end)
  {
     __gen_validate_value(v);
  #if DEBUG
     uint64_t mask = (~0ull >> (64 - (end - start + 1))) << start;
  
     assert((v & ~mask) == 0);
  #endif
  
     return v;
  }
  
  static inline uint32_t
  __gen_float(float v)
  {
     __gen_validate_value(v);
     return ((union __gen_value) { .f = (v) }).dw;
  }
  
  static inline uint64_t
  __gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
  {
     __gen_validate_value(v);
  
     const float factor = (1 << fract_bits);
  
  #if DEBUG
     const float max = ((1 << (end - start)) - 1) / factor;
     const float min = -(1 << (end - start)) / factor;
     assert(min <= v && v <= max);
  #endif
  
     const int64_t int_val = llroundf(v * factor);
     const uint64_t mask = ~0ull >> (64 - (end - start + 1));
  
     return (int_val & mask) << start;
  }
  
  static inline uint64_t
  __gen_ufixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
  {
     __gen_validate_value(v);
  
     const float factor = (1 << fract_bits);
  
  #if DEBUG
     const float max = ((1 << (end - start + 1)) - 1) / factor;
     const float min = 0.0f;
     assert(min <= v && v <= max);
  #endif
  
     const uint64_t uint_val = llroundf(v * factor);
  
     return uint_val << start;
  }
  
  #ifndef __gen_address_type
  #error #define __gen_address_type before including this file
  #endif
  
  #ifndef __gen_user_data
  #error #define __gen_combine_address before including this file
  #endif
  
  #endif
  
  """
  
  def to_alphanum(name):
      substitutions = {
          ' ': '',
          '/': '',
          '[': '',
          ']': '',
          '(': '',
          ')': '',
          '-': '',
          ':': '',
          '.': '',
          ',': '',
          '=': '',
          '>': '',
          '#': '',
          'α': 'alpha',
          '&': '',
          '*': '',
          '"': '',
          '+': '',
          '\'': '',
      }
  
      for i, j in substitutions.items():
          name = name.replace(i, j)
  
      return name
  
  def safe_name(name):
      name = to_alphanum(name)
      if not name[0].isalpha():
          name = '_' + name
  
      return name
  
  def num_from_str(num_str):
      if num_str.lower().startswith('0x'):
          return int(num_str, base=16)
      else:
          assert(not num_str.startswith('0') and 'octals numbers not allowed')
          return int(num_str)
  
  class Field(object):
      ufixed_pattern = re.compile(r"u(\d+)\.(\d+)")
      sfixed_pattern = re.compile(r"s(\d+)\.(\d+)")
  
      def __init__(self, parser, attrs):
          self.parser = parser
          if "name" in attrs:
              self.name = safe_name(attrs["name"])
          self.start = int(attrs["start"])
          self.end = int(attrs["end"])
          self.type = attrs["type"]
  
          if "prefix" in attrs:
              self.prefix = attrs["prefix"]
          else:
              self.prefix = None
  
          if "default" in attrs:
              self.default = int(attrs["default"])
          else:
              self.default = None
  
          ufixed_match = Field.ufixed_pattern.match(self.type)
          if ufixed_match:
              self.type = 'ufixed'
              self.fractional_size = int(ufixed_match.group(2))
  
          sfixed_match = Field.sfixed_pattern.match(self.type)
          if sfixed_match:
              self.type = 'sfixed'
              self.fractional_size = int(sfixed_match.group(2))
  
      def emit_template_struct(self, dim):
          if self.type == 'address':
              type = '__gen_address_type'
          elif self.type == 'bool':
              type = 'bool'
          elif self.type == 'float':
              type = 'float'
          elif self.type == 'ufixed':
              type = 'float'
          elif self.type == 'sfixed':
              type = 'float'
          elif self.type == 'uint' and self.end - self.start > 32:
              type = 'uint64_t'
          elif self.type == 'offset':
              type = 'uint64_t'
          elif self.type == 'int':
              type = 'int32_t'
          elif self.type == 'uint':
              type = 'uint32_t'
          elif self.type in self.parser.structs:
              type = 'struct ' + self.parser.gen_prefix(safe_name(self.type))
          elif self.type in self.parser.enums:
              type = 'enum ' + self.parser.gen_prefix(safe_name(self.type))
          elif self.type == 'mbo':
              return
          else:
              print("#error unhandled type: %s" % self.type)
              return
  
          print("   %-36s %s%s;" % (type, self.name, dim))
  
          prefix = ""
          if len(self.values) > 0 and self.default == None:
              if self.prefix:
                  prefix = self.prefix + "_"
  
          for value in self.values:
              print("#define %-40s %d" % (prefix + value.name, value.value))
  
  class Group(object):
      def __init__(self, parser, parent, start, count, size):
          self.parser = parser
          self.parent = parent
          self.start = start
          self.count = count
          self.size = size
          self.fields = []
  
      def emit_template_struct(self, dim):
          if self.count == 0:
              print("   /* variable length fields follow */")
          else:
              if self.count > 1:
                  dim = "%s[%d]" % (dim, self.count)
  
              for field in self.fields:
                  field.emit_template_struct(dim)
  
      class DWord:
          def __init__(self):
              self.size = 32
              self.fields = []
              self.address = None
  
      def collect_dwords(self, dwords, start, dim):
          for field in self.fields:
              if type(field) is Group:
                  if field.count == 1:
                      field.collect_dwords(dwords, start + field.start, dim)
                  else:
                      for i in range(field.count):
                          field.collect_dwords(dwords,
                                               start + field.start + i * field.size,
                                               "%s[%d]" % (dim, i))
                  continue
  
              index = (start + field.start) // 32
              if not index in dwords:
                  dwords[index] = self.DWord()
  
              clone = copy.copy(field)
              clone.start = clone.start + start
              clone.end = clone.end + start
              clone.dim = dim
              dwords[index].fields.append(clone)
  
              if field.type == "address":
                  # assert dwords[index].address == None
                  dwords[index].address = field
  
              # Coalesce all the dwords covered by this field. The two cases we
              # handle are where multiple fields are in a 64 bit word (typically
              # and address and a few bits) or where a single struct field
              # completely covers multiple dwords.
              while index < (start + field.end) // 32:
                  if index + 1 in dwords and not dwords[index] == dwords[index + 1]:
                      dwords[index].fields.extend(dwords[index + 1].fields)
                  dwords[index].size = 64
                  dwords[index + 1] = dwords[index]
                  index = index + 1
  
      def collect_dwords_and_length(self):
          dwords = {}
          self.collect_dwords(dwords, 0, "")
  
          # Determine number of dwords in this group. If we have a size, use
          # that, since that'll account for MBZ dwords at the end of a group
          # (like dword 8 on BDW+ 3DSTATE_HS). Otherwise, use the largest dword
          # index we've seen plus one.
          if self.size > 0:
              length = self.size // 32
          elif dwords:
              length = max(dwords.keys()) + 1
          else:
              length = 0
  
          return (dwords, length)
  
      def emit_pack_function(self, dwords, length):
          for index in range(length):
              # Handle MBZ dwords
              if not index in dwords:
                  print("")
                  print("   dw[%d] = 0;" % index)
                  continue
  
              # For 64 bit dwords, we aliased the two dword entries in the dword
              # dict it occupies. Now that we're emitting the pack function,
              # skip the duplicate entries.
              dw = dwords[index]
              if index > 0 and index - 1 in dwords and dw == dwords[index - 1]:
                  continue
  
              # Special case: only one field and it's a struct at the beginning
              # of the dword. In this case we pack directly into the
              # destination. This is the only way we handle embedded structs
              # larger than 32 bits.
              if len(dw.fields) == 1:
                  field = dw.fields[0]
                  name = field.name + field.dim
                  if field.type in self.parser.structs and field.start % 32 == 0:
                      print("")
                      print("   %s_pack(data, &dw[%d], &values->%s);" %
                            (self.parser.gen_prefix(safe_name(field.type)), index, name))
                      continue
  
              # Pack any fields of struct type first so we have integer values
              # to the dword for those fields.
              field_index = 0
              for field in dw.fields:
                  if type(field) is Field and field.type in self.parser.structs:
                      name = field.name + field.dim
                      print("")
                      print("   uint32_t v%d_%d;" % (index, field_index))
                      print("   %s_pack(data, &v%d_%d, &values->%s);" %
                            (self.parser.gen_prefix(safe_name(field.type)), index, field_index, name))
                      field_index = field_index + 1
  
              print("")
              dword_start = index * 32
              if dw.address == None:
                  address_count = 0
              else:
                  address_count = 1
  
              if dw.size == 32 and dw.address == None:
                  v = None
                  print("   dw[%d] =" % index)
              elif len(dw.fields) > address_count:
                  v = "v%d" % index
                  print("   const uint%d_t %s =" % (dw.size, v))
              else:
                  v = "0"
  
              field_index = 0
              non_address_fields = []
              for field in dw.fields:
                  if field.type != "mbo":
                      name = field.name + field.dim
  
                  if field.type == "mbo":
                      non_address_fields.append("__gen_mbo(%d, %d)" % \
                          (field.start - dword_start, field.end - dword_start))
                  elif field.type == "address":
                      pass
                  elif field.type == "uint":
                      non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start))
                  elif field.type in self.parser.enums:
                      non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start))
                  elif field.type == "int":
                      non_address_fields.append("__gen_sint(values->%s, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start))
                  elif field.type == "bool":
                      non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start))
                  elif field.type == "float":
                      non_address_fields.append("__gen_float(values->%s)" % name)
                  elif field.type == "offset":
                      non_address_fields.append("__gen_offset(values->%s, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start))
                  elif field.type == 'ufixed':
                      non_address_fields.append("__gen_ufixed(values->%s, %d, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                  elif field.type == 'sfixed':
                      non_address_fields.append("__gen_sfixed(values->%s, %d, %d, %d)" % \
                          (name, field.start - dword_start, field.end - dword_start, field.fractional_size))
                  elif field.type in self.parser.structs:
                      non_address_fields.append("__gen_uint(v%d_%d, %d, %d)" % \
                          (index, field_index, field.start - dword_start, field.end - dword_start))
                      field_index = field_index + 1
                  else:
                      non_address_fields.append("/* unhandled field %s, type %s */\n" % \
                                                (name, field.type))
  
              if len(non_address_fields) > 0:
                  print(" |\n".join("      " + f for f in non_address_fields) + ";")
  
              if dw.size == 32:
                  if dw.address:
                      print("   dw[%d] = __gen_combine_address(data, &dw[%d], values->%s, %s);" % (index, index, dw.address.name + field.dim, v))
                  continue
  
              if dw.address:
                  v_address = "v%d_address" % index
                  print("   const uint64_t %s =\n      __gen_combine_address(data, &dw[%d], values->%s, %s);" %
                        (v_address, index, dw.address.name + field.dim, v))
                  v = v_address
  
              print("   dw[%d] = %s;" % (index, v))
              print("   dw[%d] = %s >> 32;" % (index + 1, v))
  
  class Value(object):
      def __init__(self, attrs):
          self.name = safe_name(attrs["name"])
          self.value = ast.literal_eval(attrs["value"])
  
  class Parser(object):
      def __init__(self):
          self.parser = xml.parsers.expat.ParserCreate()
          self.parser.StartElementHandler = self.start_element
          self.parser.EndElementHandler = self.end_element
  
          self.instruction = None
          self.structs = {}
          # Set of enum names we've seen.
          self.enums = set()
          self.registers = {}
  
      def gen_prefix(self, name):
          if name[0] == "_":
              return 'GEN%s%s' % (self.gen, name)
          else:
              return 'GEN%s_%s' % (self.gen, name)
  
      def gen_guard(self):
          return self.gen_prefix("PACK_H")
  
      def start_element(self, name, attrs):
          if name == "genxml":
              self.platform = attrs["name"]
              self.gen = attrs["gen"].replace('.', '')
              print(pack_header % {'license': license, 'platform': self.platform, 'guard': self.gen_guard()})
          elif name in ("instruction", "struct", "register"):
              if name == "instruction":
                  self.instruction = safe_name(attrs["name"])
                  self.length_bias = int(attrs["bias"])
              elif name == "struct":
                  self.struct = safe_name(attrs["name"])
                  self.structs[attrs["name"]] = 1
              elif name == "register":
                  self.register = safe_name(attrs["name"])
                  self.reg_num = num_from_str(attrs["num"])
                  self.registers[attrs["name"]] = 1
              if "length" in attrs:
                  self.length = int(attrs["length"])
                  size = self.length * 32
              else:
                  self.length = None
                  size = 0
              self.group = Group(self, None, 0, 1, size)
  
          elif name == "group":
              group = Group(self, self.group,
                            int(attrs["start"]), int(attrs["count"]), int(attrs["size"]))
              self.group.fields.append(group)
              self.group = group
          elif name == "field":
              self.group.fields.append(Field(self, attrs))
              self.values = []
          elif name == "enum":
              self.values = []
              self.enum = safe_name(attrs["name"])
              self.enums.add(attrs["name"])
              if "prefix" in attrs:
                  self.prefix = safe_name(attrs["prefix"])
              else:
                  self.prefix= None
          elif name == "value":
              self.values.append(Value(attrs))
  
      def end_element(self, name):
          if name  == "instruction":
              self.emit_instruction()
              self.instruction = None
              self.group = None
          elif name == "struct":
              self.emit_struct()
              self.struct = None
              self.group = None
          elif name == "register":
              self.emit_register()
              self.register = None
              self.reg_num = None
              self.group = None
          elif name == "group":
              self.group = self.group.parent
          elif name  == "field":
              self.group.fields[-1].values = self.values
          elif name  == "enum":
              self.emit_enum()
              self.enum = None
          elif name == "genxml":
              print('#endif /* %s */' % self.gen_guard())
  
      def emit_template_struct(self, name, group):
          print("struct %s {" % self.gen_prefix(name))
          group.emit_template_struct("")
          print("};\n")
  
      def emit_pack_function(self, name, group):
          name = self.gen_prefix(name)
          print(textwrap.dedent("""\
              static inline void
              %s_pack(__attribute__((unused)) __gen_user_data *data,
                    %s__attribute__((unused)) void * restrict dst,
                    %s__attribute__((unused)) const struct %s * restrict values)
              {""") % (name, ' ' * len(name), ' ' * len(name), name))
  
          (dwords, length) = group.collect_dwords_and_length()
          if length:
              # Cast dst to make header C++ friendly
              print("   uint32_t * restrict dw = (uint32_t * restrict) dst;")
  
              group.emit_pack_function(dwords, length)
  
          print("}\n")
  
      def emit_instruction(self):
          name = self.instruction
          if not self.length == None:
              print('#define %-33s %6d' %
                    (self.gen_prefix(name + "_length"), self.length))
          print('#define %-33s %6d' %
                (self.gen_prefix(name + "_length_bias"), self.length_bias))
  
          default_fields = []
          for field in self.group.fields:
              if not type(field) is Field:
                  continue
              if field.default == None:
                  continue
              default_fields.append("   .%-35s = %6d" % (field.name, field.default))
  
          if default_fields:
              print('#define %-40s\\' % (self.gen_prefix(name + '_header')))
              print(",  \\\n".join(default_fields))
              print('')
  
          self.emit_template_struct(self.instruction, self.group)
  
          self.emit_pack_function(self.instruction, self.group)
  
      def emit_register(self):
          name = self.register
          if not self.reg_num == None:
              print('#define %-33s 0x%04x' %
                    (self.gen_prefix(name + "_num"), self.reg_num))
  
          if not self.length == None:
              print('#define %-33s %6d' %
                    (self.gen_prefix(name + "_length"), self.length))
  
          self.emit_template_struct(self.register, self.group)
          self.emit_pack_function(self.register, self.group)
  
      def emit_struct(self):
          name = self.struct
          if not self.length == None:
              print('#define %-33s %6d' %
                    (self.gen_prefix(name + "_length"), self.length))
  
          self.emit_template_struct(self.struct, self.group)
          self.emit_pack_function(self.struct, self.group)
  
      def emit_enum(self):
          print('enum %s {' % self.gen_prefix(self.enum))
          for value in self.values:
              if self.prefix:
                  name = self.prefix + "_" + value.name
              else:
                  name = value.name
              print('   %-36s = %6d,' % (name.upper(), value.value))
          print('};\n')
  
      def parse(self, filename):
          file = open(filename, "rb")
          self.parser.ParseFile(file)
          file.close()
  
  if len(sys.argv) < 2:
      print("No input xml file specified")
      sys.exit(1)
  
  input_file = sys.argv[1]
  
  p = Parser()
  p.parse(input_file)
  