blob: 24a2ff55b7dabb4e9cd7906d54614b742d23dbea [file] [log] [blame]
# Copyright 2015 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Module for parsing TCG TPM2 library specification in HTML format.
This module processes parts 2 and 3 of the specification, extracting
information related to tables defined in the documents, feeding the
information into the Table object for further processing and creating the
appropriate TPM2 objects.
from __future__ import print_function
import HTMLParser
import os
import re
import sys
import tpm_table
table_name = re.compile(r'^\s*Table\s+[0-9]+')
class SpecParser(HTMLParser.HTMLParser):
"""A class for parsing TCG specifications in html format."""
# The state machine of the parser could be in one of the following states.
ANCHOR = 0 # Look for table title anchor
TABLE_NAME = 1 # Look for table title in the data stream
TABLE_BODY = 2 # Scraping the actual table body
MAYBE_DONE = 3 # Could be over, unless a single spec table is split in
# multiple HTML tables (to continue on the next page)
SKIP_HEADER = 4 # Ignore the header of the split tables
def __init__(self):
"""Initialize a parser object to default state."""
self._state = self.ANCHOR
self._title = ''
self._table = tpm_table.Table()
self._previous_table_number = 0 # Used to check if there are skipped tables
def _Normalize(self, data):
"""Normalize HTML data.
HTML files generated from TCG specifications sometimes include utf8
characters (like long dashes), which appear only in comments/table titles
and can be safely ignored.
data: a string representing portion of data from the HTML being parsed.
a string, the input data with characters above ASCII printable range
return ' ' + ''.join(x for x in self.unescape(data) if ord(x) < 128)
def GetTable(self):
"""Return the Table object containing all information parsed so far."""
return self._table
def _SetState(self, new_state):
if self._state != new_state:
self._state = new_state
if new_state == self.TABLE_NAME:
self._title = ''
def handle_starttag(self, tag, attrs):
"""Invoked each time a new HTML tag is opened.
This method drives changes in the parser FSM states, its heuristics are
derived from the format of the HTML files the TCG specs get converted to.
Each specification table is preceded with a tittle. The title is wrapped
in an anchor tag with a property 'name' set to 'bookmark#xxx. The title
text starts with ' Table [0-9]+ '. Once the table title is detected,
the state machine switches to looking for the actual HTML table, i.e. tags
'table', 'tr' and 'td' (the generated specs do not use the 'th' tags).
Large specification tables can be split into multiple HTML tables (so that
they fit in a page). This is why the presence of the closing 'table' tag
is not enough to close the parsing of the current specification table.
In some cases the next table is defined in the spec immediately after the
current one - this is when the new anchor tag is used as a signal that the
previous table has been completely consumed.
tag: a string, the HTML tag
attrs: a tuple of zero or more two-string tuples, the first element -
the HTML tag's attribute, the second element - the attribute
if tag == 'a':
if [x for x in attrs if x[0] == 'name' and x[1].startswith('bookmark')]:
if self._state == self.ANCHOR:
elif self._state == self.MAYBE_DONE:
# Done indeed
elif self._state == self.TABLE_NAME:
self._title = ''
elif tag == 'p' and self._state == self.TABLE_NAME and not self._title:
# This was not a valid table start, back to looking for the right anchor.
elif self._state == self.TABLE_NAME and tag == 'table':
if not
# Table title does not match the expected format - back to square one.
return # will have to start over
table_number = int(self._title.split()[1])
self._previous_table_number += 1
if table_number > self._previous_table_number:
print('Table(s) %s missing' % ' '.join(
'%d' % x for x in
range(self._previous_table_number, table_number)), file=sys.stderr)
self._previous_table_number = table_number
elif self._state == self.MAYBE_DONE and tag == 'tr':
elif self._state == self.SKIP_HEADER and tag == 'tr':
elif self._state == self.TABLE_BODY:
if tag == 'tr':
elif tag == 'td':
def handle_endtag(self, tag):
"""Invoked each time an HTML tag is closed."""
if tag == 'table' and self._table.InProgress():
def handle_data(self, data):
"""Process data outside HTML tags."""
if self._state == self.TABLE_NAME:
self._title += ' %s' % self._Normalize(data)
elif self._state == self.TABLE_BODY:
elif self._state == self.MAYBE_DONE:
# Done indeed
def close(self):
"""Finish processing of the HTML buffer."""
if self._state in (self.TABLE_BODY, self.MAYBE_DONE):
self._state = self.ANCHOR
def handle_entityref(self, name):
"""Process HTML escape sequence."""
entmap = {
'amp': '&',
'gt': '>',
'lt': '<',
'quot': '"',
if name in entmap:
if self._state == self.TABLE_BODY:
elif self._state == self.TABLE_NAME:
self._title += entmap[name]
def main(structs_html_file_name):
"""When invoked standalone - dump .h file on the console."""
parser = SpecParser()
with open(structs_html_file_name) as input_file:
html_content =
if __name__ == '__main__':
if len(sys.argv) != 2:
print('%s: One parameter is required, the name of the html file '
'which is the TPM2 library Part 2 specification' %
os.path.basename(sys.argv[0]), file=sys.stderr)