def ns_data_create(self):
res = LXB.Res("lxb_ns_data_t", self.ns_res_data, False,
self.ns_last_entry_name)
res_prefix = LXB.Res("lxb_ns_prefix_data_t", self.ns_res_prefix_data,
False, self.ns_last_entry_name)
for name in self.ns_list:
str_name = ''
if len(self.ns[name]["link"]) > 16:
str_name = ".u.long_str = (lxb_char_t *) \"{}\"".format(
self.ns[name]["link"])
else:
str_name = ".u.short_str = \"{}\"".format(
self.ns[name]["link"])
res.append(
"{{{{{}, .length = {}, .next = NULL}}, {}, 1, true}}".format(
str_name, len(self.ns[name]["link"]),
self.ns[name]["c_name"]))
if len(self.ns[name]["name"]) > 16:
str_name = ".u.long_str = (lxb_char_t *) \"{}\"".format(
self.ns[name]["name"].lower())
else:
str_name = ".u.short_str = \"{}\"".format(
self.ns[name]["name"].lower())
res_prefix.append(
"{{{{{}, .length = {}, .next = NULL}}, {}, 1, true}}".format(
str_name, len(self.ns[name]["name"]),
self.ns[name]["c_name"]))
return [res.create(1, True), res_prefix.create(1, True)]
def make(self, name, temp_file_h, temp_file_c, save_to, save_to_c):
tags = self.tags.enum_list
res = LXB.Res("lxb_html_tree_insertion_mode_f", "{}_{}_res".format(self.prefix, name), False)
res_closed = LXB.Res("lxb_html_tree_insertion_mode_f", "{}_{}_closed_res".format(self.prefix, name), False)
for entry in tags:
res.append("{}_{}_{} /* {} */".format(self.prefix, name, self.anything_else, entry["c_name"]))
res_closed.append("{}_{}_{} /* {} */".format(self.prefix, name, self.anything_else_closed, entry["c_name"]))
res_data = res.create(1, True)
res_closed_data = res_closed.create(1, True)
lxb_temp = LXB.Temp(temp_file_h, save_to)
lxb_temp.pattern_append("%%NAME%%", name.upper())
lxb_temp.pattern_append("%%HASH%%", self.tags.enum_hash_ifdef())
lxb_temp.pattern_append("%%BODY-OPEN%%", ''.join(res_data))
lxb_temp.pattern_append("%%BODY-CLOSED%%", ''.join(res_closed_data))
lxb_temp.build()
lxb_temp.save()
lxb_temp = LXB.Temp(temp_file_c, save_to_c)
lxb_temp.pattern_append("%%NAME%%", name)
lxb_temp.build()
lxb_temp.save()
def tag_data_create_default(self):
res = LXB.Res("lxb_tag_data_t", self.tag_res_data, False,
self.tag_last_entry_name)
res_upper = LXB.Res("lxb_tag_data_t", self.tag_res_data_upper, False,
self.tag_last_entry_name)
for entry in self.enum_list:
# res.append("{{{{.u.long_str = (lxb_char_t *) \"{}\", .length = {}, .next = NULL}},\n (const lxb_char_t *) \"{}\", {}, 1, true}}".format(entry["name"], len(entry["name"]), entry["name"].upper(), entry["c_name"]))
if len(entry["name"]) > 16:
res.append(
"{{{{.u.long_str = (lxb_char_t *) \"{}\", .length = {}, .next = NULL}}, {}, 1, true}}"
.format(entry["name"], len(entry["name"]),
entry["c_name"]))
res_upper.append(
"{{{{.u.long_str = (lxb_char_t *) \"{}\", .length = {}, .next = NULL}}, {}, 1, true}}"
.format(entry["name"].upper(), len(entry["name"]),
entry["c_name"]))
else:
res.append(
"{{{{.u.short_str = \"{}\", .length = {}, .next = NULL}}, {}, 1, true}}"
.format(entry["name"], len(entry["name"]),
entry["c_name"]))
res_upper.append(
"{{{{.u.short_str = \"{}\", .length = {}, .next = NULL}}, {}, 1, true}}"
.format(entry["name"].upper(), len(entry["name"]),
entry["c_name"]))
return [res.create(1, True), res_upper.create(1, True)]
def shs_create_and_save_html(self, temp_file, save_to, temp_file_interface,
save_to_interface):
data_list = self.tag_data_create_html()
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%CHECK_TAG_VERSION%%",
self.enum_hash_ifdef())
lxb_temp.pattern_append("%%CHECK_NS_VERSION%%", self.ns_hash_ifdef())
lxb_temp.pattern_append("%%TAG_DATA%%", ''.join(data_list[0]))
lxb_temp.pattern_append("%%FIXNAME_SVG_DATA%%", ''.join(data_list[4]))
lxb_temp.build()
lxb_temp.save()
lxb_temp = LXB.Temp(temp_file_interface, save_to_interface)
lxb_temp.pattern_append("%%CHECK_TAG_VERSION%%",
self.enum_hash_ifdef())
lxb_temp.pattern_append("%%CHECK_NS_VERSION%%", self.ns_hash_ifdef())
lxb_temp.pattern_append("%%INCLUDES%%", '\n'.join(data_list[1]))
lxb_temp.pattern_append("%%CONSTRUCTOR%%", ''.join(data_list[2]))
lxb_temp.pattern_append("%%DESTRUCTOR%%", ''.join(data_list[3]))
lxb_temp.build()
lxb_temp.save()
print(self.shs_stat(self.shs))
print("Save to {}".format(save_to))
print("Done")
def save_res(self, temp_file_h, save_to_h, temp_file_c, save_to_c):
res = self.make()
lxb_temp = LXB.Temp(temp_file_h, save_to_h)
lxb_temp.pattern_append("%%EXTERNS%%", '\n'.join(res[1]))
lxb_temp.pattern_append("%%SIZES%%", '\n'.join(res[2]))
lxb_temp.build()
lxb_temp.save()
lxb_temp = LXB.Temp(temp_file_c, save_to_c)
lxb_temp.pattern_append("%%INDEX%%", '\n\n'.join(res[0]))
lxb_temp.build()
lxb_temp.save()
def shs_create(self):
attrs = []
for name in attributes_name:
if name == '_undef':
var = "#undef"
else:
var = name
attrs.append({
"key":
var,
"value":
"(void *) &{}[{}]".format(self.data_name,
self.make_enum_name(name))
})
shs = LXB.SHS(attrs, 0, False)
test = shs.make_test(5, 128)
shs.table_size_set(test[0][2])
res = shs.create(self.shs_name, rate=1)
print(self.shs_stat(shs))
return res
def make_flat_index(self, name, values):
buffer_size = self.buffer_size(values)
print("Flat buffer size:", buffer_size)
res = LXB.Res(self.flat_index_typename,
self.make_var_name(name) + '[{}]'.format(buffer_size),
False, None, 'LXB_API')
for idx in range(0, buffer_size):
if idx in values:
entries = values[idx]
res.append('{{(lxb_char_t *) "{}", {}, {}}}'.format(
toHex(entries[2].decode('utf-8')), entries[3],
entries[1].decode('utf-8')))
res.append('/* {} */'.format(entries[4].decode('utf-8')),
is_comment=True)
else:
res.append('{NULL, 0, LXB_ENCODING_ERROR_CODEPOINT}')
res.append('/* Not defined */', is_comment=True)
buf = res.create()
return buf
def ns_shs_link_create(self, name):
self.ns_shs_link = LXB.SHS(self.ns_shs_link_list, 0, True)
test = self.ns_shs_link.make_test(5, 128)
self.ns_shs_link.table_size_set(test[0][2])
return self.ns_shs_link.create(name)
def shs_create(self, name):
self.shs = LXB.SHS(self.shs_list, 0, True)
test = self.shs.make_test(128, 1024)
self.shs.table_size_set(test[0][2])
return self.shs.create(name)
def ns_shs_create(self, name):
self.ns_shs = LXB.SHS(self.ns_shs_list, 0, False)
test = self.ns_shs.make_test(5, 128)
self.ns_shs.table_size_set(test[0][2])
return self.ns_shs.create(name)
def make_const(self):
idx = 0
fconst = LXB.FormatEnum(self.const_typename)
fconst.append(self.make_name_upper("DEFAULT"), "0x{0:02x}".format(idx))
fconst.append(self.make_name_upper("AUTO"),
"0x{0:02x}".format(idx + 1))
fconst.append(self.make_name_upper("UNDEFINED"),
"0x{0:02x}".format(idx + 2))
idx += 2
for encode in self.strict:
idx += 1
name = encode['name']
fconst.append(self.make_name_upper(name), "0x{0:02x}".format(idx))
fconst.append(self.make_name_upper(self.last_entry_name),
"0x{0:02x}".format(idx + 1))
buf = fconst.build()
if not self.silent:
print('\n'.join(buf))
return buf
def make_shs(self, shs_name, data_name):
idx = 2 # Skip first three data position (DEFAULT, AUTO, UNDEFINED)
tlist = []
for encode in self.strict:
idx += 1
for name in encode['labels']:
value = '(void *) &{}[{}]'.format(data_name, idx)
tlist.append({'key': name.lower(), 'value': value})
shs = LXB.SHS(tlist, 0, False, '')
test = shs.make_test(20, 2048)
shs.table_size_set(test[0][2])
if not self.silent:
print('Table size: ' + str(test[0][2]))
print('Max deep: ' + str(test[0][0]))
buf = shs.create(shs_name)
if not self.silent:
print(''.join(buf))
return buf
def save_res(self, temp_file_h, save_to_h, temp_file_c, save_to_c):
data = self.make_data('lxb_encoding_res_map')
shs = self.make_shs('lxb_encoding_res_shs_entities',
'lxb_encoding_res_map')
lxb_temp = LXB.Temp(temp_file_h, save_to_h)
lxb_temp.pattern_append("%%MAX%%",
self.make_name_upper(self.last_entry_name))
lxb_temp.build()
lxb_temp.save()
lxb_temp = LXB.Temp(temp_file_c, save_to_c)
lxb_temp.pattern_append("%%DATA%%", ''.join(data))
lxb_temp.pattern_append("%%SHS%%", ''.join(shs))
lxb_temp.build()
lxb_temp.save()
def tag_data_create_default(self):
result = []
res = LXB.Res("lxb_tag_data_t", self.tag_res_data, True, self.tag_last_entry_name)
for entry in self.enum_list:
res.append("{{(const lxb_char_t *) \"{}\", (const lxb_char_t *) \"{}\", {}, {}}}".format(entry["name"], entry["name"].upper(), len(entry["name"]), entry["c_name"]))
return res.create(1, False)
def save_const(self, temp_file, save_to):
buf = self.make_const()
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%CONST%%", '\n'.join(buf))
lxb_temp.build()
lxb_temp.save()
def save(self, const_temp_file, const_save_to, res_temp_file, res_save_to):
res_class = ps.make("pseudo_class", pseudo_classes)
res_class_function = ps.make("pseudo_class_function", pseudo_class_functions, pseudo_class_functions_dict)
res_element = ps.make("pseudo_element", pseudo_elements)
res_element_function = ps.make("pseudo_element_function", pseudo_element_functions, pseudo_element_functions_dict)
# const
lxb_temp = LXB.Temp(const_temp_file, const_save_to)
lxb_temp.pattern_append("%%BODY%%",
"{}\n\n{}\n\n{}\n\n{}".format('\n'.join(res_class[0]),
'\n'.join(res_class_function[0]),
'\n'.join(res_element[0]),
'\n'.join(res_element_function[0])))
lxb_temp.build()
lxb_temp.save()
print("Const saved to {}".format(const_save_to))
# res
lxb_temp = LXB.Temp(res_temp_file, res_save_to)
lxb_temp.pattern_append("%%SHS_DATA%%",
"{}\n\n{}\n\n{}\n\n{}".format(''.join(res_class[1]),
''.join(res_class_function[1]),
''.join(res_element[1]),
''.join(res_element_function[1])))
lxb_temp.pattern_append("%%SHS%%",
"{}\n\n{}\n\n{}\n\n{}".format(''.join(res_class[2]),
''.join(res_class_function[2]),
''.join(res_element[2]),
''.join(res_element_function[2])))
lxb_temp.build()
lxb_temp.save()
print("Res saved to {}".format(res_save_to))
print("Done")
yn = input("Print declarations? (y - yes, n - no): ")
if yn.lower() == 'y':
print('LXB_API ', ';\n\nLXB_API '.join(res_class_function[3]), ';', sep='')
print('LXB_API ', ';\n\nLXB_API '.join(res_element_function[3]), ';', sep='')
print('\n\n'.join(res_class_function[4]))
print('\n\n'.join(res_element_function[4]))
def save_test(self, data, const_name, name):
save_to_c = os.path.join(self.save_to, name + ".c")
lxb_temp = LXB.Temp(self.temp_file_c, save_to_c)
lxb_temp.pattern_append("%%DATA%%", data)
lxb_temp.pattern_append("%%CONST_NAME%%", const_name)
lxb_temp.pattern_append("%%NAME%%", name)
lxb_temp.build()
lxb_temp.save()
def tag_test_create_and_save(self, temp_file, save_to):
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%TEST_NAMES%%", "\n".join(self.tag_test_name_create()))
lxb_temp.build()
lxb_temp.save()
print("Test saved to {}".format(save_to))
def save_res(self, filename, buf, hash_buf):
save_to_c = os.path.join(self.save_to, filename + ".c")
print("Save to:", save_to_c)
lxb_temp = LXB.Temp(self.temp_file_c, save_to_c)
lxb_temp.pattern_append("%%INDEX%%", buf)
lxb_temp.pattern_append("%%HASH%%", hash_buf)
lxb_temp.build()
lxb_temp.save()
def enum_save(self, data, temp_file, save_to):
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%HASH%%", self.enum_hash)
lxb_temp.pattern_append("%%BODY%%", "\n".join(data))
lxb_temp.build()
lxb_temp.save()
print("\n".join(data))
print("Save to {}".format(save_to))
print("Done")
def enum_create(self):
result = []
frmt_enum = LXB.FormatEnum("{}_id_enum_t".format(self.tag_prefix))
for idx in range(0, len(self.enum_list)):
frmt_enum.append(self.enum_list[idx]["c_name"], "0x{0:04x}".format(idx))
frmt_enum.append(self.tag_last_entry_name, "0x{0:04x}".format(idx + 1))
return frmt_enum.build()
def const_create(self):
frmt_enum = LXB.FormatEnum("{}id_enum_t".format(self.prefix.lower()))
for idx in range(0, len(attributes_name)):
frmt_enum.append(self.make_enum_name(attributes_name[idx]),
"0x{0:04x}".format(idx))
frmt_enum.append(self.make_enum_name("_LAST_ENTRY"),
"0x{0:04x}".format(idx + 1))
return frmt_enum.build()
def create(name, enum_tokens):
tlist = []
for (key, value) in enum_tokens.items():
tlist.append({'key': key, 'value': "(void *) " + value})
shs = LXB.SHS(tlist, 0, True)
test = shs.make_test(5, 128)
shs.table_size_set(test[0][2])
return shs.create(name)
def ns_create(self):
result = []
frmt_ns = LXB.FormatEnum("{}_id_enum_t".format(self.ns_prefix))
for idx in range(0, len(self.ns_list)):
name = self.ns_list[idx]
frmt_ns.append(self.ns[name]["c_name"], "0x{0:02x}".format(idx))
frmt_ns.append(self.ns_last_entry_name, "0x{0:02x}".format(idx + 1))
return frmt_ns.build()
def ns_data_create(self):
result = []
res = LXB.Res("lxb_ns_data_t", self.ns_res_data, True,
self.ns_last_entry_name)
for name in self.ns_list:
res.append("{{\"{0}\", \"{1}\", {2}, \"{3}\", {4}, {5}}}".format(
self.ns[name]["name"], self.ns[name]["name"].lower(),
len(self.ns[name]["name"]), self.ns[name]["link"],
len(self.ns[name]["link"]), self.ns[name]["c_name"]))
return res.create(1, False)
def make_range_index(self, name, values):
res = LXB.Res(self.range_index_typename,
self.make_range_name(name) + '[{}]'.format(len(values)),
False, None, 'LXB_API')
for entry in values:
res.append('{{{}, {}}}'.format(entry[0].decode('utf-8'),
entry[1].decode('utf-8')))
buf = res.create(rate=4)
return buf
def const_save(self, temp_file, save_to):
res = self.const_create()
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%BODY%%", '\n'.join(res))
lxb_temp.build()
lxb_temp.save()
print("\n".join(res))
print("Save to {}".format(save_to))
print("Done")
def make_hash_index(self, name, values):
name = self.make_hash_name(name)
hash_key = LXB.HashKey(412, name, 'LXB_API')
for idx in range(0, self.buffer_size):
if idx in values:
entries = values[idx]
key_id = entries[1].decode('utf-8')
hash_key.append(key_id, '(void *) {}'.format(idx + 0x80))
return hash_key.create(rate=1)
def shs_save(self, data, temp_file, save_to):
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%CHECK_TAG_VERSION%%", self.enum_hash_ifdef())
lxb_temp.pattern_append("%%TAG_DATA%%", ''.join(self.tag_data_create_default()))
lxb_temp.pattern_append("%%SHS_DATA%%", ''.join(data))
lxb_temp.build()
lxb_temp.save()
print("".join(data))
print(self.shs_stat(self.shs))
print("Save to {}".format(save_to))
print("Done")
def ns_shs_save(self, data, data_link, temp_file, save_to):
lxb_temp = LXB.Temp(temp_file, save_to)
lxb_temp.pattern_append("%%CHECK_NS_VERSION%%", self.ns_hash_ifdef())
lxb_temp.pattern_append("%%NS_DATA%%", ''.join(self.ns_data_create()))
# lxb_temp.pattern_append("%%SHS_DATA%%", ''.join(data))
lxb_temp.pattern_append("%%SHS_DATA_LINK%%", ''.join(data_link))
lxb_temp.build()
lxb_temp.save()
print("".join(data))
print(self.shs_stat(self.ns_shs))
print("Save to {}".format(save_to))
print("Done")