-#!/usr/bin/env python3
+#encoding=utf-8
+from __future__ import (
+ absolute_import, division, print_function, unicode_literals
+)
+import ast
import xml.parsers.expat
import re
import sys
* This file has been generated, do not hand edit.
*/
-#pragma once
+#ifndef %(guard)s
+#define %(guard)s
#include <stdio.h>
#include <stdint.h>
assert(min <= v && v <= max);
#endif
- const int32_t int_val = roundf(v * factor);
+ const int64_t int_val = llroundf(v * factor);
const uint64_t mask = ~0ull >> (64 - (end - start + 1));
return (int_val & mask) << start;
assert(min <= v && v <= max);
#endif
- const uint32_t uint_val = roundf(v * factor);
+ const uint64_t uint_val = llroundf(v * factor);
return uint_val << start;
}
def safe_name(name):
name = to_alphanum(name)
- if not str.isalpha(name[0]):
+ if not name[0].isalpha():
name = '_' + name
return name
assert(not num_str.startswith('0') and 'octals numbers not allowed')
return int(num_str)
-class Field:
- ufixed_pattern = re.compile("u(\d+)\.(\d+)")
- sfixed_pattern = re.compile("s(\d+)\.(\d+)")
+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
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:
for value in self.values:
print("#define %-40s %d" % (prefix + value.name, value.value))
-class Group:
+class Group(object):
def __init__(self, parser, parent, start, count, size):
self.parser = parser
self.parent = parent
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":
- s = "__gen_mbo(%d, %d)" % \
- (field.start - dword_start, field.end - dword_start)
+ non_address_fields.append("__gen_mbo(%d, %d)" % \
+ (field.start - dword_start, field.end - dword_start))
elif field.type == "address":
- s = None
+ pass
elif field.type == "uint":
- s = "__gen_uint(values->%s, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start)
+ 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":
- s = "__gen_sint(values->%s, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start)
+ non_address_fields.append("__gen_sint(values->%s, %d, %d)" % \
+ (name, field.start - dword_start, field.end - dword_start))
elif field.type == "bool":
- s = "__gen_uint(values->%s, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start)
+ non_address_fields.append("__gen_uint(values->%s, %d, %d)" % \
+ (name, field.start - dword_start, field.end - dword_start))
elif field.type == "float":
- s = "__gen_float(values->%s)" % name
+ non_address_fields.append("__gen_float(values->%s)" % name)
elif field.type == "offset":
- s = "__gen_offset(values->%s, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start)
+ non_address_fields.append("__gen_offset(values->%s, %d, %d)" % \
+ (name, field.start - dword_start, field.end - dword_start))
elif field.type == 'ufixed':
- s = "__gen_ufixed(values->%s, %d, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start, field.fractional_size)
+ 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':
- s = "__gen_sfixed(values->%s, %d, %d, %d)" % \
- (name, field.start - dword_start, field.end - dword_start, field.fractional_size)
+ 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:
- s = "__gen_uint(v%d_%d, %d, %d)" % \
- (index, field_index, field.start - dword_start, field.end - dword_start)
+ 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:
- print("/* unhandled field %s, type %s */\n" % (name, field.type))
- s = None
+ non_address_fields.append("/* unhandled field %s, type %s */\n" % \
+ (name, field.type))
- if not s == None:
- if field == dw.fields[-1]:
- print(" %s;" % s)
- else:
- print(" %s |" % s)
+ 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] = %s;" % (index, v))
print(" dw[%d] = %s >> 32;" % (index + 1, v))
-class Value:
+class Value(object):
def __init__(self, attrs):
self.name = safe_name(attrs["name"])
- self.value = int(attrs["value"])
+ self.value = ast.literal_eval(attrs["value"])
-class Parser:
+class Parser(object):
def __init__(self):
self.parser = xml.parsers.expat.ParserCreate()
self.parser.StartElementHandler = self.start_element
self.instruction = None
self.structs = {}
+ self.enums = {}
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})
+ 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"])
elif name == "enum":
self.values = []
self.enum = safe_name(attrs["name"])
+ self.enums[attrs["name"]] = 1
if "prefix" in attrs:
self.prefix = safe_name(attrs["prefix"])
else:
elif name == "enum":
self.emit_enum()
self.enum = None
-
- def gen_prefix(self, name):
- if name[0] == "_":
- return 'GEN%s%s' % (self.gen, name)
- else:
- return 'GEN%s_%s' % (self.gen, name)
+ elif name == "genxml":
+ print('#endif /* %s */' % self.gen_guard())
def emit_template_struct(self, name, group):
print("struct %s {" % self.gen_prefix(name))
self.emit_pack_function(self.struct, self.group)
def emit_enum(self):
- print('/* enum %s */' % self.gen_prefix(self.enum))
+ 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('#define %-36s %6d' % (name.upper(), value.value))
- print('')
+ print(' %-36s = %6d,' % (name.upper(), value.value))
+ print('};\n')
def parse(self, filename):
file = open(filename, "rb")