| #!/usr/bin/env python3 |
| |
| # Copyright (c) 2021, Arm Limited |
| # SPDX-License-Identifier: Apache-2.0 |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import sys |
| import tabulate as tbl |
| import argparse |
| import csv |
| import doctest |
| |
| |
| def quote_literal(val): |
| if len(val) > 0: |
| return f"``{val}``" |
| return val |
| |
| |
| rst_header_levels = ['=', '~', '-', '_', '@'] |
| __CSV_SECTION_PREFIX = '<SECTION>' |
| __CSV_COMMENT_PREFIX = '<COMMENT>' |
| __CSV_HEADER_PREFIX = '<HEADER>' |
| __intrinsic_table_header = ['Intrinsic', 'Argument preparation', |
| 'AArch64 Instruction', 'Result', 'Supported architectures'] |
| |
| __INTRINSIC_TABLE_KEYWORD = '__intrinsic_table' |
| __SECTION_TEXT_KEYWORD = '__section_text' |
| |
| __SECTION_KEYWORDS = [__INTRINSIC_TABLE_KEYWORD, __SECTION_TEXT_KEYWORD] |
| |
| |
| def rst_literal_quote(mapping): |
| r""" |
| >>> rst_literal_quote('a; b') |
| ' ::\n\n a \n b \n\n' |
| |
| >>> rst_literal_quote('a b') |
| ' ::\n\n a b \n\n' |
| |
| >>> rst_literal_quote('') |
| '' |
| """ |
| if mapping == "": |
| return "" |
| |
| lines = mapping.split(';') |
| indented_lines = [f" {line.strip()} " for line in lines] |
| lines = [" ::", ""] + indented_lines + ["\n"] |
| return '\n'.join(lines) |
| |
| |
| def quote_split_intrinsics(intrinsic): |
| r""" |
| >>> quote_split_intrinsics('int f(int x, float y)') |
| '.. code:: c\n\n int f(\n int x,\n float y)' |
| |
| >>> quote_split_intrinsics('int f(int x)') |
| '.. code:: c\n\n int f(int x)\n' |
| """ |
| # Remove the suffix ')' from the intrinsic string. |
| intrinsic_without_ending = intrinsic[:-1] |
| ret_def, par, signature = intrinsic_without_ending.partition('(') |
| split_signature = signature.split(',') |
| if len(split_signature) > 1: |
| return f".. code:: c\n\n {ret_def}(\n " + ',\n '.join(split_signature) + ")" |
| else: |
| return f".. code:: c\n\n {intrinsic}\n" |
| |
| |
| def get_intrinsic_name(signature): |
| """ |
| Get the intrinsic name from the signature of the intrinsic. |
| |
| >>> get_intrinsic_name("int8x8_t vadd_s8(int8x8_t a, int8x8_t b)") |
| 'vadd_s8' |
| |
| >>> get_intrinsic_name("int32x4_t vaddl_high_s16(int16x8_t a, int16x8_t b)") |
| 'vaddl_high_s16' |
| |
| >>> get_intrinsic_name("float64x2_t vfmsq_lane_f64(float64x2_t a, float64x2_t b, float64x1_t v, __builtin_constant_p(lane))") |
| 'vfmsq_lane_f64' |
| |
| >>> get_intrinsic_name("poly16x8_t vsriq_n_p16(poly16x8_t a, poly16x8_t b, __builtin_constant_p(n))") |
| 'vsriq_n_p16' |
| |
| >>> get_intrinsic_name("uint8x16_t [__arm_]vddupq_m[_n_u8](uint8x16_t inactive, uint32_t a, const int imm, mve_pred16_t p)") |
| '[__arm_]vddupq_m[_n_u8]' |
| """ |
| tmp = signature.split(' ') |
| |
| tmp = tmp[1].split('(') |
| return tmp[0] |
| |
| |
| def clear_builtin_constant(s): |
| """ |
| >>> clear_builtin_constant("__builtin_constant_p(lane)") |
| 'const int lane' |
| >>> clear_builtin_constant("__builtin_constant_p(n)") |
| 'const int n' |
| >>> clear_builtin_constant("__builtin_constant_p(lane1)") |
| 'const int lane1' |
| >>> clear_builtin_constant("__builtin_constant_p(lane2)") |
| 'const int lane2' |
| >>> clear_builtin_constant("__builtin_constant_p(x), __builtin_constant_p(y)") |
| 'const int x, const int y' |
| """ |
| import re |
| return re.sub(r'__builtin_constant_p\(([a-zA-Z0-9]+)\)', r'const int \1', s) |
| |
| |
| class Intrinsic: |
| |
| def __init__(self, signature, parameter_mapping, asm, result_mapping, arch, classification): |
| self.signature = clear_builtin_constant(signature.strip()) |
| self.parameter_mapping = parameter_mapping |
| self.asm = asm.strip() |
| self.result_mapping = result_mapping |
| self.arch = arch.strip() |
| self.asm_mnemonic = self.asm.split(' ')[0].strip() |
| self.classification = classification |
| |
| def table_row(self): |
| return [quote_split_intrinsics(self.signature), rst_literal_quote(self.parameter_mapping), rst_literal_quote(self.asm), rst_literal_quote(self.result_mapping), quote_literal(self.arch)] |
| |
| |
| def recurse_set(parent, section_levels, value, object_type_target): |
| """Recursively fills the dictinoary `parent` with the keys provided in |
| `section_levels`. The innermost key is mapped to a list object to which |
| the value of `value` is appened. |
| |
| For example, given parent={}, section_levels=['a','b','c'] and value = |
| 'text', it creates the entry |
| `parent['a']['b']['c']=['text']`. Another invocation with |
| value='text2' updates the list as |
| `parent['a']['b']['c']=['text', 'text2']` |
| |
| >>> import json |
| >>> jprint = lambda x: print(json.dumps(x, indent = 2)) |
| |
| >>> parent = {} |
| >>> intrinsic_sample = lambda x : [f'intr{x}', f'arg_prep{x}', f'inst{x}', f'res{x}', f'sup_arch{x}'] |
| >>> recurse_set(parent, ['Section 1'], intrinsic_sample(0), '__intrinsic_table') |
| >>> jprint(parent) |
| { |
| "Section 1": { |
| "__intrinsic_table": [ |
| [ |
| "intr0", |
| "arg_prep0", |
| "inst0", |
| "res0", |
| "sup_arch0" |
| ] |
| ] |
| } |
| } |
| >>> recurse_set(parent, ['Section 1'], intrinsic_sample(1), '__intrinsic_table') |
| >>> jprint(parent) |
| { |
| "Section 1": { |
| "__intrinsic_table": [ |
| [ |
| "intr0", |
| "arg_prep0", |
| "inst0", |
| "res0", |
| "sup_arch0" |
| ], |
| [ |
| "intr1", |
| "arg_prep1", |
| "inst1", |
| "res1", |
| "sup_arch1" |
| ] |
| ] |
| } |
| } |
| |
| >>> recurse_set(parent, ['Section 2', 'Section 2.1'], intrinsic_sample(3), '__intrinsic_table') |
| >>> recurse_set(parent, ['Section 2', 'Section 2.1'], intrinsic_sample(4), '__intrinsic_table') |
| >>> recurse_set(parent, ['Section 2', 'Section 2.1'], intrinsic_sample(5), '__intrinsic_table') |
| >>> jprint(parent) |
| { |
| "Section 1": { |
| "__intrinsic_table": [ |
| [ |
| "intr0", |
| "arg_prep0", |
| "inst0", |
| "res0", |
| "sup_arch0" |
| ], |
| [ |
| "intr1", |
| "arg_prep1", |
| "inst1", |
| "res1", |
| "sup_arch1" |
| ] |
| ] |
| }, |
| "Section 2": { |
| "Section 2.1": { |
| "__intrinsic_table": [ |
| [ |
| "intr3", |
| "arg_prep3", |
| "inst3", |
| "res3", |
| "sup_arch3" |
| ], |
| [ |
| "intr4", |
| "arg_prep4", |
| "inst4", |
| "res4", |
| "sup_arch4" |
| ], |
| [ |
| "intr5", |
| "arg_prep5", |
| "inst5", |
| "res5", |
| "sup_arch5" |
| ] |
| ] |
| } |
| } |
| } |
| |
| >>> recurse_set(parent, ['Section 2', 'Section 2.2'], intrinsic_sample(6), '__intrinsic_table') |
| >>> jprint(parent) |
| { |
| "Section 1": { |
| "__intrinsic_table": [ |
| [ |
| "intr0", |
| "arg_prep0", |
| "inst0", |
| "res0", |
| "sup_arch0" |
| ], |
| [ |
| "intr1", |
| "arg_prep1", |
| "inst1", |
| "res1", |
| "sup_arch1" |
| ] |
| ] |
| }, |
| "Section 2": { |
| "Section 2.1": { |
| "__intrinsic_table": [ |
| [ |
| "intr3", |
| "arg_prep3", |
| "inst3", |
| "res3", |
| "sup_arch3" |
| ], |
| [ |
| "intr4", |
| "arg_prep4", |
| "inst4", |
| "res4", |
| "sup_arch4" |
| ], |
| [ |
| "intr5", |
| "arg_prep5", |
| "inst5", |
| "res5", |
| "sup_arch5" |
| ] |
| ] |
| }, |
| "Section 2.2": { |
| "__intrinsic_table": [ |
| [ |
| "intr6", |
| "arg_prep6", |
| "inst6", |
| "res6", |
| "sup_arch6" |
| ] |
| ] |
| } |
| } |
| } |
| |
| >>> recurse_set(parent, ['Section 1', 'Section 1.1'], intrinsic_sample(7), '__intrinsic_table') |
| >>> jprint(parent) |
| { |
| "Section 1": { |
| "__intrinsic_table": [ |
| [ |
| "intr0", |
| "arg_prep0", |
| "inst0", |
| "res0", |
| "sup_arch0" |
| ], |
| [ |
| "intr1", |
| "arg_prep1", |
| "inst1", |
| "res1", |
| "sup_arch1" |
| ] |
| ], |
| "Section 1.1": { |
| "__intrinsic_table": [ |
| [ |
| "intr7", |
| "arg_prep7", |
| "inst7", |
| "res7", |
| "sup_arch7" |
| ] |
| ] |
| } |
| }, |
| "Section 2": { |
| "Section 2.1": { |
| "__intrinsic_table": [ |
| [ |
| "intr3", |
| "arg_prep3", |
| "inst3", |
| "res3", |
| "sup_arch3" |
| ], |
| [ |
| "intr4", |
| "arg_prep4", |
| "inst4", |
| "res4", |
| "sup_arch4" |
| ], |
| [ |
| "intr5", |
| "arg_prep5", |
| "inst5", |
| "res5", |
| "sup_arch5" |
| ] |
| ] |
| }, |
| "Section 2.2": { |
| "__intrinsic_table": [ |
| [ |
| "intr6", |
| "arg_prep6", |
| "inst6", |
| "res6", |
| "sup_arch6" |
| ] |
| ] |
| } |
| } |
| } |
| |
| >>> recurse_set(parent, ['Section X', 'Section X.X'], 'somethign', '__unhandled_keyword') |
| Traceback (most recent call last): |
| ... |
| Exception: Target is unsupported. |
| |
| >>> new = {} |
| >>> recurse_set(new, ['Section X'], intrinsic_sample('001'), '__intrinsic_table') |
| >>> recurse_set(new, ['Section X'], 'Description of Section X', '__section_text') |
| >>> recurse_set(new, ['Section X', 'Section X.X'], 'somethign', '__section_text') |
| >>> recurse_set(new, ['Section X', 'Section X.X'], 'Description of Section X.X', '__section_text') |
| >>> jprint(new) |
| { |
| "Section X": { |
| "__intrinsic_table": [ |
| [ |
| "intr001", |
| "arg_prep001", |
| "inst001", |
| "res001", |
| "sup_arch001" |
| ] |
| ], |
| "__section_text": "Description of Section X", |
| "Section X.X": { |
| "__section_text": "Description of Section X.X" |
| } |
| } |
| } |
| """ |
| if object_type_target not in __SECTION_KEYWORDS: |
| raise Exception("Target is unsupported.") |
| current_section, *rest = section_levels |
| |
| # No more headers to traverse: insert the value under the |
| # `object_type_target`. |
| if not rest: |
| if object_type_target == __INTRINSIC_TABLE_KEYWORD: |
| parent[current_section] = parent.get( |
| current_section, {__INTRINSIC_TABLE_KEYWORD: []}) |
| parent[current_section][__INTRINSIC_TABLE_KEYWORD].append(value) |
| return |
| |
| if object_type_target == __SECTION_TEXT_KEYWORD: |
| parent[current_section] = parent.get(current_section, {}) |
| parent[current_section][__SECTION_TEXT_KEYWORD] = value |
| return |
| |
| # If we are still traversing the section headers, we are dealing |
| # with a new section. |
| parent.setdefault(current_section, {}) |
| recurse_set(parent[current_section], rest, value, object_type_target) |
| |
| |
| def start_new_section(item): |
| """We start a new section when `key` is not handled in |
| `__SECTION_KEYWORDS` and `value` is a `dict` object. |
| """ |
| key, value = item |
| return isinstance(value, dict) and key not in __SECTION_KEYWORDS |
| |
| |
| def is_intrinsic_table(item): |
| """ |
| Determines whether a key/value pair is a table of intrinsics. |
| |
| >>> is_intrinsic_table(('__intrinsic_table', [[1,2,3,4,5],['a', 'b','c', 'd', 'f']])) |
| True |
| |
| >>> is_intrinsic_table(('__intrinsic_table', [[1,2,3,4,5],['a', 'b','c', 'd']])) |
| False |
| |
| >>> is_intrinsic_table(('__intrinsic_tabl', [[1,2,3,4,5],['a', 'b','c', 'd', 'f']])) |
| False |
| |
| """ |
| key, value = item |
| return key == __INTRINSIC_TABLE_KEYWORD and isinstance(value, list) and all(len(row) == 5 and isinstance(row, list) for row in value) |
| |
| |
| def is_section_text(item): |
| """ |
| Determines whether a key/value pair is a table of intrinsics. |
| |
| >>> is_section_text(('__intrinsic_table', [[1,2,3,4,5],['a', 'b','c', 'd', 'f']])) |
| False |
| |
| >>> is_section_text(('__section_text', "")) |
| True |
| |
| |
| """ |
| key, value = item |
| return key == __SECTION_TEXT_KEYWORD |
| |
| |
| def recurse_print_to_rst(item, section_level_list, headers=__intrinsic_table_header, tablefmt="rst"): |
| """ |
| >>> table_item = ('__intrinsic_table', [[1,2,3,4,5], [6,7,8,9, 10]]) |
| >>> print(recurse_print_to_rst(table_item, ['='])) |
| <BLANKLINE> |
| =========== ====================== ===================== ======== ========================= |
| Intrinsic Argument preparation AArch64 Instruction Result Supported architectures |
| =========== ====================== ===================== ======== ========================= |
| 1 2 3 4 5 |
| 6 7 8 9 10 |
| =========== ====================== ===================== ======== ========================= |
| |
| >>> item = ('New section', {'__intrinsic_table': [[1,2,3,4,5], [6,7,8,9, 10]]}) |
| >>> print(recurse_print_to_rst(item, ['='])) |
| <BLANKLINE> |
| New section |
| =========== |
| <BLANKLINE> |
| =========== ====================== ===================== ======== ========================= |
| Intrinsic Argument preparation AArch64 Instruction Result Supported architectures |
| =========== ====================== ===================== ======== ========================= |
| 1 2 3 4 5 |
| 6 7 8 9 10 |
| =========== ====================== ===================== ======== ========================= |
| |
| >>> item = ('Section 1', {'Section 1.1': {'__intrinsic_table': [[1,2,3,4,5], [6,7,8,9, 10]]}}) |
| >>> print(recurse_print_to_rst(item, ['=','~'])) |
| <BLANKLINE> |
| Section 1 |
| ========= |
| <BLANKLINE> |
| Section 1.1 |
| ~~~~~~~~~~~ |
| <BLANKLINE> |
| =========== ====================== ===================== ======== ========================= |
| Intrinsic Argument preparation AArch64 Instruction Result Supported architectures |
| =========== ====================== ===================== ======== ========================= |
| 1 2 3 4 5 |
| 6 7 8 9 10 |
| =========== ====================== ===================== ======== ========================= |
| |
| >>> item = ('Section 1', {'Section 1.1': { '__section_text': "Text for Section 1.1", '__intrinsic_table': [[1,2,3,4,5]]}}) |
| >>> print(recurse_print_to_rst(item, ['=','~'])) |
| <BLANKLINE> |
| Section 1 |
| ========= |
| <BLANKLINE> |
| Section 1.1 |
| ~~~~~~~~~~~ |
| <BLANKLINE> |
| Text for Section 1.1 |
| <BLANKLINE> |
| =========== ====================== ===================== ======== ========================= |
| Intrinsic Argument preparation AArch64 Instruction Result Supported architectures |
| =========== ====================== ===================== ======== ========================= |
| 1 2 3 4 5 |
| =========== ====================== ===================== ======== ========================= |
| |
| >>> item = ('Section 1', {'Section 1.1': { '__intrinsic_table': [[1,2,3,4,5]], '__section_text': "Text for Section 1.1" }}) |
| >>> print(recurse_print_to_rst(item, ['=','~'])) |
| <BLANKLINE> |
| Section 1 |
| ========= |
| <BLANKLINE> |
| Section 1.1 |
| ~~~~~~~~~~~ |
| <BLANKLINE> |
| Text for Section 1.1 |
| <BLANKLINE> |
| =========== ====================== ===================== ======== ========================= |
| Intrinsic Argument preparation AArch64 Instruction Result Supported architectures |
| =========== ====================== ===================== ======== ========================= |
| 1 2 3 4 5 |
| =========== ====================== ===================== ======== ========================= |
| """ |
| key, value = item |
| if is_intrinsic_table(item): |
| return "\n" + str(tbl.tabulate(value, headers=headers, tablefmt=tablefmt)) |
| |
| body = "" |
| if start_new_section(item): |
| title, *rest = section_level_list |
| body += f"\n{key}" |
| body += "\n" + title * len(key)+"" |
| # Print the value of the text for the section right after the |
| # section title. |
| if __SECTION_TEXT_KEYWORD in value: |
| body += "\n\n" + value[__SECTION_TEXT_KEYWORD] |
| for k, v in value.items(): |
| # Skip the section text because it has already been processed right |
| # after the section title. |
| if k == __SECTION_TEXT_KEYWORD: |
| continue |
| body += "\n"+recurse_print_to_rst((k, v), rest, headers, tablefmt) |
| return body |
| |
| |
| def is_section_command(row): |
| """CSV rows are cosidered new section commands if they start with |
| <SECTION> and consist of at least two columns column. |
| |
| >>> is_section_command('<SECTION>\tSection name'.split('\t')) |
| True |
| |
| >>> is_section_command('<other>\tSection name'.split('\t')) |
| False |
| |
| >>> is_section_command(['<SECTION>', 'Section name', 'some more']) |
| True |
| |
| """ |
| return len(row) >= 2 and row[0] == __CSV_SECTION_PREFIX |
| |
| |
| def is_comment_line(row): |
| """CSV rows are cosidered new section commands if they start with |
| <COMMENT> |
| |
| >>> is_comment_line('<COMMENT>\tSome text'.split('\t')) |
| True |
| |
| >>> is_comment_line('<other>\tSome text'.split('\t')) |
| False |
| |
| >>> is_comment_line('Some text'.split('\t')) |
| False |
| |
| >>> is_comment_line('<COMMENT>\tSome text\tsome more'.split('\t')) |
| True |
| """ |
| return len(row) >= 2 and row[0] == __CSV_COMMENT_PREFIX |
| |
| |
| def is_table_header(row): |
| """Table headers are 6-columns with the first one being |
| __CSV_HEADER_PREFIX. |
| |
| >>> is_table_header(['<HEADER>', '', '', '', '', '']) |
| True |
| |
| >>> is_table_header(['<EADER>', '', '', '', '', '']) |
| False |
| """ |
| return len(row) == 6 and row[0] == __CSV_HEADER_PREFIX |
| |
| |
| def is_intrinsic_definition(row): |
| return len(row) == 5 |
| |
| |
| def get_section_data(row): |
| section_text = row[2] if len(row) == 3 else None |
| return [row[1], section_text] |
| |
| |
| def process_db(db, classification_db): |
| """Processes a list of intrinsics and their mappings to the |
| classification into a sequence of sections and RST tables. |
| |
| >>> intrinsics = [ |
| ... ['<HEADER>', 'T1', 'T2', 'T3', 'T4', 'T5'], |
| ... ['<SECTION>','Section 1 title', 'Section 1 description.'], |
| ... ['a A01()','a','aa','aaa','aaaa'], |
| ... ['b B01()','b','bb','bbb','bbbb'], |
| ... ['<SECTION>','Section 2 title', 'Section 2 description.'], |
| ... ['c C01()','c','cc','ccc','cccc'], |
| ... ] |
| >>> classification = { |
| ... 'B01': 'Section 1.1|Section 1.1.1', |
| ... 'C01': 'classX|subclassY' |
| ... } |
| >>> print(process_db(intrinsics, classification)) |
| <BLANKLINE> |
| <BLANKLINE> |
| Section 1 title |
| =============== |
| <BLANKLINE> |
| Section 1 description. |
| <BLANKLINE> |
| No category |
| ~~~~~~~~~~~ |
| <BLANKLINE> |
| +-------------+-------+--------+---------+----------+ |
| | T1 | T2 | T3 | T4 | T5 | |
| +=============+=======+========+=========+==========+ |
| | .. code:: c | :: | :: | :: | ``aaaa`` | |
| | | | | | | |
| | a A01() | a | aa | aaa | | |
| +-------------+-------+--------+---------+----------+ |
| <BLANKLINE> |
| Section 1.1 |
| ~~~~~~~~~~~ |
| <BLANKLINE> |
| Section 1.1.1 |
| ------------- |
| <BLANKLINE> |
| +-------------+-------+--------+---------+----------+ |
| | T1 | T2 | T3 | T4 | T5 | |
| +=============+=======+========+=========+==========+ |
| | .. code:: c | :: | :: | :: | ``bbbb`` | |
| | | | | | | |
| | b B01() | b | bb | bbb | | |
| +-------------+-------+--------+---------+----------+ |
| <BLANKLINE> |
| Section 2 title |
| =============== |
| <BLANKLINE> |
| Section 2 description. |
| <BLANKLINE> |
| classX |
| ~~~~~~ |
| <BLANKLINE> |
| subclassY |
| --------- |
| <BLANKLINE> |
| +-------------+-------+--------+---------+----------+ |
| | T1 | T2 | T3 | T4 | T5 | |
| +=============+=======+========+=========+==========+ |
| | .. code:: c | :: | :: | :: | ``cccc`` | |
| | | | | | | |
| | c C01() | c | cc | ccc | | |
| +-------------+-------+--------+---------+----------+ |
| """ |
| filtered = {} |
| section, section_text, table_header = None, None, None |
| line_num = 0 |
| for row in db: |
| line_num += 1 |
| # Set section if the line in the file is starting with __CSV_SECTION_PREFIX. |
| if is_section_command(row): |
| section, section_text = get_section_data(row) |
| if section_text: |
| recurse_set(filtered, [section], |
| section_text, __SECTION_TEXT_KEYWORD) |
| |
| print( |
| f"Activating {__CSV_SECTION_PREFIX} command at line {line_num}, '{section}'", file=sys.stderr) |
| continue |
| |
| # Skip comment lines. |
| if is_comment_line(row): |
| continue |
| |
| if is_table_header(row): |
| # Only one <HEADER> command is allowed. |
| assert(table_header is None) |
| # Set the header. |
| table_header = row[1:] |
| assert(len(table_header) == 5) |
| continue |
| |
| if is_intrinsic_definition(row): |
| classification = classification_db.get( |
| get_intrinsic_name(row[0]), "No category") |
| intrinsic = Intrinsic( |
| row[0], row[1], row[2], row[3], row[4], classification) |
| classification_list = intrinsic.classification.split('|') |
| if section: |
| classification_list = [section]+classification_list |
| recurse_set(filtered, classification_list, |
| intrinsic.table_row(), __INTRINSIC_TABLE_KEYWORD) |
| |
| continue |
| |
| print(f"Skipping line {line_num}: row = {row}", file=sys.stderr) |
| # Make sure that the CSV has at a row that have set the tale |
| # header. |
| assert(table_header is not None) |
| body = "" |
| for k, v in filtered.items(): |
| body += "\n" + \ |
| recurse_print_to_rst((k, v), rst_header_levels, |
| headers=table_header, tablefmt="grid") |
| return body |
| |
| |
| def get_classification_map(classification_file): |
| classification_map = {} |
| with open(classification_file) as csvclassificationfile: |
| classification_db = csv.reader(csvclassificationfile, delimiter='\t') |
| classification_map = {} |
| for row in classification_db: |
| if len(row) == 2: |
| classification_map[row[0]] = row[1] |
| continue |
| |
| # Skip comment lines. |
| if is_comment_line(row): |
| continue |
| |
| print( |
| f"{classification_file}: skipping line {classification_db.line_num}: row = {row}", file=sys.stderr) |
| |
| return classification_map |
| |
| |
| def read_template(path): |
| with open(path) as f: |
| return f.read() |
| |
| |
| def get_intrinsics_db(path): |
| with open(path) as csvfile: |
| return list(csv.reader(csvfile, delimiter='\t')) |
| |
| |
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser( |
| description="Generate an RST file for the intrinsics specifications.") |
| parser.add_argument("--intrinsic-defs", metavar="<path>", type=str, |
| help="CSV file with the database of the intrinsics.", required=True) |
| parser.add_argument("--template", metavar="<path>", type=str, |
| help="Template file for generating the RST of the specificaion.", required=True) |
| parser.add_argument("--classification", metavar="<path>", type=str, |
| help="CSV file that map the intrinsics to their classification.", required=True) |
| parser.add_argument("--outfile", metavar="<path>", type=str, |
| help="Output file where the RST of the specs is written.", required=True) |
| cli_args = parser.parse_args() |
| |
| |
| # We require version 0.8.6 to be able to print multi-line records |
| # in tables. |
| if tbl.__version__ < "0.8.6": |
| print(f"Your version of package tabulate is too old ({tbl.__version__}). " |
| "Update it to be greater or equal to 0.8.6.", file=sys.stderr) |
| exit(1) |
| |
| classification_map = get_classification_map(cli_args.classification) |
| intrinsics_db = get_intrinsics_db(cli_args.intrinsic_defs) |
| doc_template = read_template(cli_args.template) |
| intrinsic_table = process_db(intrinsics_db, classification_map) |
| rst_output = doc_template.format(intrinsic_table=intrinsic_table) |
| with (open(cli_args.outfile, 'w')) as f: |
| f.write(rst_output) |
| # Always run the unit tests. |
| doctest.NORMALIZE_WHITESPACE |
| doctest.testmod() |
