path: root/src/select/select_generator.py

# This file is part of LibCSS.
# Licensed under the MIT License,
# http://www.opensource.org/licenses/mit-license.php
# Copyright 2017 Lucas Neves <lcneves@gmail.com>

import math
import string
from select_config import values, groups
from assets import assets

def get_tuple(from_var):
    'Accepts tuples, strings and None; returns a tuple.'
    if type(from_var) is tuple:
        return from_var
    elif type(from_var) is str:
        return (from_var,)
    elif from_var is None:
        return ()
    else:
        raise TypeError('Value should be either tuple, string or None, ' +
                        'received: ' + type(from_var).__name__)

def shift_star(value_type, prop_name):
    '''Shifts the asterisks from a pointer type to its name.
    i.e. `lwc_string** str_array` would become `lwc_string **str_array`'''
    star_i = value_type.find('*')
    v_type = value_type if star_i is -1 else value_type[:star_i]
    v_name = prop_name if star_i is -1 else value_type[star_i:] + prop_name
    return (v_type, v_name)

class Text:
    def __init__(self):
        self._lines = []
        self._comment = False
        self._esc_nl = False
        self._indent = 0

    name_width = 31
    bits_width = 16

    def indent(self, value, absolute=False):
        if absolute:
            self._indent = value
        else:
            self._indent += value

    def comment(self):
        comm = self._comment
        self._comment = False
        self.append(' */' if comm else '/*')
        self._comment = not comm

    def escape_newline(self):
        self._esc_nl = not self._esc_nl

    def append(self, text=None, pre_formatted=False):
        if not text:
            self._lines.append('{}{}{}'.format(
                '\t' * self._indent,
                ' * ' if self._comment else '',
                '\t' * (9 - self._indent) + '\\' if self._esc_nl else ''))
            return

        if isinstance(text, list):
            for t in text:
                self.append(t, pre_formatted)
            return

        if pre_formatted:
            self._lines.append(text)
            return

        column_max = 72 if self._esc_nl else 80
        multiline = False

        while text:
            line = '\t' * self._indent
            if self._comment:
                line += ' * '
            prefix_size = (3 if self._comment else 0) + 8 * self._indent
            if prefix_size + len(text) <= column_max:
                line += text
                text = ''
            else:
                space_index = text[:column_max - prefix_size].rfind(' ')
                paren_index = text[:column_max - prefix_size].rfind('(')
                break_index = max(space_index, paren_index + 1)
                line += text[:break_index].rstrip()
                text = text[break_index:].lstrip()
            if self._esc_nl:
                n_tabs = 9 - self._indent - math.floor(len(line.lstrip()) / 8)
                line += '\t' * n_tabs + '\\'
            self._lines.append(line)
            if text and not self._comment and not multiline:
                self.indent(2)
                multiline = True

        if multiline:
            self.indent(-2)

    def table_line(self):
        self.append('{0:{n}}{0:{b}}{0}'.format(
            '---', n=self.name_width, b=self.bits_width))

    def table_header(self):
        self.append('{:{n}}{:{b}}{}'.format(
            'Property', 'Size (bits)', 'Size (bytes)', 
            n=self.name_width, b=self.bits_width))
        self.table_line()

    def result_line(self):
        self.append(' ' * self.name_width + '=' * (self.bits_width + 3))

    def to_string(self):
        return '\n'.join(self._lines)

class CSSValue:
    'Values to be associated with properties.'
    def __init__(self, name, css_type, size=None, defaults='NULL',
                 bits_name=None, bits_type=None,
                 bits_size=None, bits_default='0'):
        self.name = name
        self.type = css_type
        self.size = size #  `None` means sizeof(ptr)
        self.defaults = get_tuple(defaults)
        self.bits = None if bits_size is None else {
            'name': bits_name,
            'type': bits_type,
            'size': bits_size,
            'default': bits_default
        }

class CSSProperty:
    def __init__(self, name, type_size, values=None, condition=None,
             defaults=None, comments=None, override=None):
        self.name = name
        self.type_size = type_size
        self.values = self.make_values(values)
        self.defaults = get_tuple(defaults)
        self.condition = condition
        self.override = get_tuple(override)
        self.comments = comments
        self.__index = None
        self.__shift = None
        self.__mask = None

    def make_values(self, vals, for_list=False):
        if vals is None:
            return []
        elif type(vals) is str:
            val_list = [ CSSValue(*x) for x in values if x[0] == vals ]
            return val_list[0] if for_list else val_list
        elif type(vals) is tuple:
            val_list = []
            for val in vals:
                for x in values:
                    if x[0] == val[0]:
                        value = CSSValue(*x)
                        if len(val) is 2:
                            value.defaults = get_tuple(val[1])
                        val_list.append(value)
                        break
                else:
                    raise ValueError('Value ' + val[0] + ' not found!')
            return val_list
        else:
            raise TypeError('Expected None, str or tuple, got ' +
                            type(vals).__name__)

    @property
    def default_op(self):
        if len(self.defaults) < 1:
            raise ValueError('Property has empty defaults!')
        return self.defaults[0]

    def default_value(self, index):
        # First default of property is the opcode
        if len(self.defaults) < index + 2:
            return self.values[index].defaults
        else:
            return self.defaults[index + 1]

    @property
    def bits_size(self):
        return self.type_size + sum([ v.bits['size'] for v in self.values
            if v.bits is not None ])

    @property
    def bytes_size(self):
        return sum([ v.size for v in self.values if v.size is not None ])

    @property
    def ptr_size(self):
        return sum([ 1 for v in self.values if v.size is None ])

    @property
    def size_line(self):
        name = '{:{width}}'.format(self.name, width=Text.name_width)
        type_size = '{:>3}'.format(str(self.type_size))
        extra_size = sum([ v.bits['size'] for v in self.values
                if v.bits is not None ])
        bits_size = '{:{width}}'.format(type_size +
                (' + ' + str(extra_size) if extra_size else ''),
                width=Text.bits_width)
        vars_size = '{:>3}'.format(
                str(self.bytes_size)) if self.bytes_size else ''
        ptr = ''
        for v in self.values:
            if v.size is None:
                ptr = 'sizeof(ptr)'
                break

        return (name + bits_size + vars_size +
                (' + ' if vars_size and ptr else '') + ptr)

    @property
    def index(self):
        if self.__index is None:
            raise NameError('Attribute `index` not set yet!')
        return self.__index

    @index.setter
    def index(self, val):
        if type(val) is not int:
            raise TypeError('Value of `index` must be an integer!')
        if val < 0:
            raise ValueError('Value of `index` must be zero or positive!')
        self.__index = val

    @property
    def shift(self):
        if self.__shift is None:
            raise NameError('Attribute `shift` not set yet!')
        return self.__shift

    @shift.setter
    def shift(self, val):
        if type(val) is not int:
            raise TypeError('Value of `shift` must be an integer!')
        if val < 0:
            raise ValueError('Value of `shift` must be zero or positive!')
        self.__shift = val

    @property
    def mask(self):
        if self.__mask is None:
            raise NameError('Attribute `mask` not set yet!')
        return '0x{:x}'.format(self.__mask).lower()

    @mask.setter
    def mask(self, val):
        if type(val) is not int:
            raise TypeError('Value of `mask` must be an integer!')
        if val < 0:
            raise ValueError('Value of `mask` must be zero or positive!')
        self.__mask = val


class Bin:
    def __init__(self, first_object):
        self.contents = [ first_object ]

    @property
    def size(self):
        return sum([ x.bits_size for x in self.contents ])

    def push(self, obj):
        self.contents.append(obj)

class CSSGroup:
    def __init__(self, config):
        self.name = config['name']
        self.props = [ CSSProperty(*x) for x in config['props'] ]
        self.__bits_array = None

    @property
    def bits_size(self):
        return sum([ p.bits_size for p in self.props ])

    @property
    def bytes_size(self):
        return sum([ p.bytes_size for p in self.props ])

    @property
    def ptr_size(self):
        return sum([ p.ptr_size for p in self.props ])

    @property
    def bits_array(self):
        '''Implements a `best fit first` heuristics for the bin packing of
        property bits in the bits array'''

        if self.__bits_array is not None:
            return self.__bits_array

        bin_size = 32
        self.__bits_array = []
        props = sorted(self.props, key=(lambda x: x.bits_size), reverse=True)

        for p in props:
            for b in self.__bits_array:
                if b.size + p.bits_size <= bin_size:
                    b.push(p)
                    p.shift = 32 - sum([ x.bits_size for x in b.contents ])
                    break
            else:
                p.shift = 32 - p.bits_size
                self.__bits_array.append(Bin(p))

            p.mask = (sum([ 2 ** x for x in range(p.bits_size) ]) *
                      2 ** p.shift)
            self.__bits_array.sort(key=(lambda x: x.size), reverse=True)

        for i, b in enumerate(self.__bits_array):
            for p in b.contents:
                p.index = i

        return self.__bits_array

    def make_computed_h(self):
        t = Text()
        t.append()

        typedef = 'typedef ' if self.name is 'page' else ''
        t.append('{}struct css_computed_{}{} {{'.format(
            typedef, self.name, '' if self.name is 'page' else '_i'))

        t.comment()
        commented = []
        t.table_header()
        for prop in sorted(self.props, key=(lambda x: x.name)):
            if prop.comments is None:
                t.append(prop.size_line)
            else:
                commented.extend(( '', prop.comments, '', prop.size_line ))
        t.append(commented)
        t.append()
        t.table_line()
        t.append('{:{len_1}}{:>3}{:{len_2}}{:>3}{}{}'.format('',
            str(self.bits_size), ' bits', str(self.bytes_size),
            ' + ' + str(self.ptr_size) + 'sizeof(ptr)'
                    if self.ptr_size else '',
            ' bytes',
            len_1=Text.name_width, len_2=(Text.bits_width - 3)))
        t.result_line()
        t.append('{:{len_1}}{:>3}{}{}'.format('',
            math.ceil(self.bits_size / 8) + self.bytes_size,
            ' + ' + str(self.ptr_size) + 'sizeof(ptr)'
                    if self.ptr_size else '',
            ' bytes', len_1=Text.name_width))
        t.append()

        t.append('Bit allocations:')
        for i, b in enumerate(self.bits_array):
            bits = []
            for prop in b.contents:
                for char in prop.name + prop.name.upper():
                    if char not in bits and char in string.ascii_letters:
                        bits.extend(char * prop.bits_size)
                        break
            t.append()
            t.append('{:<2} {:.<32}'.format(str(i), ''.join(bits)))
            t.append('; '.join([ p.name for p in b.contents ]))
        t.comment()

        t.indent(1)
        t.append('uint32_t bits[' + str(len(self.bits_array)) + '];')
        t.append()
        t.append(self.make_value_declaration(for_commented=False))
        if self.name is 'style':
            t.append()
            t.append('css_computed_uncommon *uncommon;')
            t.append('void *aural;')
        t.indent(-1)
        t.append('}}{};'.format(
            ' css_computed_' + self.name if typedef else ''))

        if self.name is not 'page':
            typedef = 'typedef ' if self.name is not 'style' else ''
            t.append()
            t.append('{}struct css_computed_{} {{'.format(
                     typedef, self.name))
            t.indent(1)
            t.append('struct css_computed_' + self.name + '_i i;')
            t.append()
            t.append(self.make_value_declaration(for_commented=True))
            t.append()
            if self.name is 'style':
                t.append('css_computed_page *page;')
            t.append('struct css_computed_' + self.name + ' *next;')
            t.append('uint32_t count;')
            t.append('uint32_t bin;')
            t.indent(-1)
            t.append('}}{};'.format(
                ' css_computed_' + self.name if typedef else ''))

        return t.to_string()

    def make_propset_h(self):
        t = Text()

        if self.name is not 'style':
            t.append('static const css_computed_{0} default_{0} = {{'.format(
                self.name))
            t.indent(1)
            if self.name is not 'page':
                t.append('.i = {')
                t.indent(1)
            t.append('.bits = {') 
            t.indent(1)
            bits_ops = []
            for b in self.bits_array:
                or_ops = []
                for p in b.contents:
                    or_ops.append('({} << {})'.format(p.default_op,
                                                      str(p.shift))
                                  if p.shift else p.default_op)
                bits_ops.append(' | '.join(or_ops))
            t.append(',\n'.join(bits_ops).split('\n'))
            t.indent(-1)
            t.append('},')
            t.append(',\n'.join(
                self.make_value_declaration(False, True)).split('\n'))

            if self.name is not 'page':
                t.indent(-1)
                t.append('},')
                t.append(',\n'.join(
                    self.make_value_declaration(True, True) +
                    [ '.next = NULL', '.count = 0', '.bin = UINT32_MAX' ]
                    ).split('\n'))

            t.indent(-1)
            t.append('};')
            t.append()

            t.escape_newline()
            i_dot = '' if self.name is 'page' else 'i.'
            t.append('#define ENSURE_{} do {{'.format(self.name.upper()))
            t.indent(1)
            t.append('if (style->{}{} == NULL) {{'.format(i_dot, self.name))
            t.indent(1)
            t.append('style->{}{n} = malloc(sizeof(css_computed_{n}));'.format(
                i_dot, n=self.name))
            t.append('if (style->{}{} == NULL)'.format(i_dot, self.name))
            t.indent(1)
            t.append('return CSS_NOMEM;')
            t.indent(-1)
            t.append()
            t.append('memcpy(style->{}{n}, &default_{n}, '
                     'sizeof(css_computed_{n}));'.format(i_dot, n=self.name))
            t.indent(-1)
            t.append('}')
            t.indent(-1)
            t.append('} while(0)')
            t.escape_newline()
            t.append()

        for p in sorted(self.props, key=(lambda x: x.name)):
            t.append('#define {}_INDEX {}'.format(p.name.upper(), p.index))
            t.append('#define {}_SHIFT {}'.format(p.name.upper(), p.shift))
            t.append('#define {}_MASK {}'.format(p.name.upper(), p.mask))
            t.append('#undef {}_INDEX'.format(p.name.upper()))
            t.append('#undef {}_SHIFT'.format(p.name.upper()))
            t.append('#undef {}_MASK'.format(p.name.upper()))



        return t.to_string()

    def make_value_declaration(self, for_commented, defaults=False):
        r = []
        for p in sorted(self.props, key=(lambda x: x.name)):
            if bool(p.comments) == for_commented:
                for i, v in enumerate(p.values):
                    v_suffix = ('' if len(p.values) is 1 else
                                '_' + string.ascii_lowercase[i])
                    if defaults:
                        r.append('.{}{} = {}'.format(p.name, v_suffix,
                                                    p.default_value(i)[0]))
                    else:
                        v_type, v_name = shift_star(v.type, p.name)
                        r.append('{} {}{};'.format(v_type, v_name, v_suffix))
        return r

    def make_text(self, filename):
        if filename == 'computed.h':
            return self.make_computed_h()
        if filename == 'propset.h':
            return self.make_propset_h()
        else:
            raise ValueError()

css_groups = [ CSSGroup(g) for g in groups ]

for k, v in assets.items():
    # Key is filename string (e.g. "computed.h") without autogenerated_ prefix
    body = '\n'.join([ g.make_text(k) for g in css_groups ])
    text = '\n'.join([ v['header'], body, v['footer'] ])
    with open('autogenerated_' + k, 'w') as file_k:
        file_k.write(text)