| #!/usr/bin/python |
| # Copyright 2018 The ANGLE Project Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| # |
| # gen_builtin_symbols.py: |
| # Code generation for the built-in symbol tables. |
| |
| from collections import OrderedDict |
| from datetime import date |
| import argparse |
| import hashlib |
| import json |
| import re |
| import os |
| import sys |
| |
| template_immutablestringtest_cpp = """// GENERATED FILE - DO NOT EDIT. |
| // Generated by {script_name} using data from {function_data_source_name}. |
| // |
| // Copyright {copyright_year} The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // ImmutableString_test_autogen.cpp: |
| // Tests for matching script-generated hashes with runtime computed hashes. |
| |
| #include "compiler/translator/ImmutableString.h" |
| #include "gtest/gtest.h" |
| |
| namespace sh |
| {{ |
| |
| TEST(ImmutableStringTest, ScriptGeneratedHashesMatch) |
| {{ |
| {script_generated_hash_tests} |
| }} |
| |
| }} // namespace sh |
| """ |
| |
| # The header file has a "get" function for each variable. They are used in traversers. |
| # It also declares id values of built-ins with human readable names, so they can be used to identify built-ins. |
| template_builtin_header = """// GENERATED FILE - DO NOT EDIT. |
| // Generated by {script_name} using data from {variable_data_source_name} and |
| // {function_data_source_name}. |
| // |
| // Copyright {copyright_year} The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // BuiltIn_autogen.h: |
| // Compile-time initialized built-ins. |
| |
| #ifndef COMPILER_TRANSLATOR_TREEUTIL_BUILTIN_AUTOGEN_H_ |
| #define COMPILER_TRANSLATOR_TREEUTIL_BUILTIN_AUTOGEN_H_ |
| |
| #include "compiler/translator/SymbolUniqueId.h" |
| |
| namespace sh |
| {{ |
| |
| class TVariable; |
| |
| class BuiltInId |
| {{ |
| public: |
| |
| {builtin_id_declarations} |
| |
| }}; // class BuiltInId |
| |
| namespace BuiltInVariable |
| {{ |
| |
| {get_variable_declarations} |
| |
| }} // namespace BuiltInVariable |
| |
| }} // namespace sh |
| |
| #endif // COMPILER_TRANSLATOR_TREEUTIL_BUILTIN_AUTOGEN_H_ |
| """ |
| |
| template_symboltable_h = """// GENERATED FILE - DO NOT EDIT. |
| // Generated by {script_name} using data from {variable_data_source_name} and |
| // {function_data_source_name}. |
| // |
| // Copyright {copyright_year} The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // SymbolTable_autogen.h: |
| // Autogenerated member variables of TSymbolTable. |
| |
| #ifndef COMPILER_TRANSLATOR_SYMBOLTABLE_AUTOGEN_H_ |
| #define COMPILER_TRANSLATOR_SYMBOLTABLE_AUTOGEN_H_ |
| |
| namespace sh |
| {{ |
| |
| class TSymbolTableBase |
| {{ |
| protected: |
| TSymbolTableBase() = default; |
| {declare_member_variables} |
| }}; |
| |
| }} // namespace sh |
| |
| #endif // COMPILER_TRANSLATOR_SYMBOLTABLE_AUTOGEN_H_ |
| """ |
| |
| # By having the variables defined in a cpp file we ensure that there's just one instance of each of the declared variables. |
| template_symboltable_cpp = """// GENERATED FILE - DO NOT EDIT. |
| // Generated by {script_name} using data from {variable_data_source_name} and |
| // {function_data_source_name}. |
| // |
| // Copyright {copyright_year} The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // SymbolTable_autogen.cpp: |
| // Compile-time initialized built-ins. |
| |
| #include "compiler/translator/SymbolTable.h" |
| |
| #include "angle_gl.h" |
| #include "compiler/translator/tree_util/BuiltIn_autogen.h" |
| #include "compiler/translator/ImmutableString.h" |
| #include "compiler/translator/StaticType.h" |
| #include "compiler/translator/Symbol.h" |
| #include "compiler/translator/SymbolTable.h" |
| |
| namespace sh |
| {{ |
| |
| // Since some of the BuiltInId declarations are used outside of constexpr expressions, we need to |
| // have these definitions without an initializer. C++17 should eventually remove the need for this. |
| {builtin_id_definitions} |
| |
| const int TSymbolTable::kLastBuiltInId = {last_builtin_id}; |
| |
| namespace BuiltInName |
| {{ |
| |
| constexpr const ImmutableString _empty(""); |
| {name_declarations} |
| |
| }} // namespace BuiltInName |
| |
| // TODO(oetuaho): Would be nice to make this a class instead of a namespace so that we could friend |
| // this from TVariable. Now symbol constructors taking an id have to be public even though they're |
| // not supposed to be accessible from outside of here. http://anglebug.com/2390 |
| namespace BuiltInVariable |
| {{ |
| |
| {variable_declarations} |
| |
| {get_variable_definitions} |
| |
| }} // namespace BuiltInVariable |
| |
| namespace BuiltInParameters |
| {{ |
| |
| {parameter_declarations} |
| |
| }} // namespace BuiltInParameters |
| |
| namespace UnmangledBuiltIns |
| {{ |
| |
| {unmangled_builtin_declarations} |
| |
| }} // namespace UnmangledBuiltIns |
| |
| // TODO(oetuaho): Would be nice to make this a class instead of a namespace so that we could friend |
| // this from TFunction. Now symbol constructors taking an id have to be public even though they're |
| // not supposed to be accessible from outside of here. http://anglebug.com/2390 |
| namespace BuiltInFunction |
| {{ |
| |
| {function_declarations} |
| |
| }} // namespace BuiltInFunction |
| |
| void TSymbolTable::initializeBuiltInVariables(sh::GLenum shaderType, |
| ShShaderSpec spec, |
| const ShBuiltInResources &resources) |
| {{ |
| const TSourceLoc zeroSourceLoc = {{0, 0, 0, 0}}; |
| {init_member_variables} |
| }} |
| |
| const TSymbol *TSymbolTable::findBuiltIn(const ImmutableString &name, |
| int shaderVersion) const |
| {{ |
| if (name.length() > {max_mangled_name_length}) |
| {{ |
| return nullptr; |
| }} |
| uint32_t nameHash = name.mangledNameHash(); |
| if ((nameHash >> 31) != 0) |
| {{ |
| // The name contains [ or {{. |
| return nullptr; |
| }} |
| {get_builtin} |
| }} |
| |
| const UnmangledBuiltIn *TSymbolTable::getUnmangledBuiltInForShaderVersion(const ImmutableString &name, int shaderVersion) |
| {{ |
| if (name.length() > {max_unmangled_name_length}) |
| {{ |
| return nullptr; |
| }} |
| uint32_t nameHash = name.mangledNameHash(); |
| {get_unmangled_builtin} |
| }} |
| |
| }} // namespace sh |
| """ |
| |
| template_parsecontext_header = """// GENERATED FILE - DO NOT EDIT. |
| // Generated by {script_name} using data from {variable_data_source_name} and |
| // {function_data_source_name}. |
| // |
| // Copyright {copyright_year} The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // ParseContext_autogen.h: |
| // Helpers for built-in related checks. |
| |
| #ifndef COMPILER_TRANSLATOR_PARSECONTEXT_AUTOGEN_H_ |
| #define COMPILER_TRANSLATOR_PARSECONTEXT_AUTOGEN_H_ |
| |
| namespace sh |
| {{ |
| |
| namespace BuiltInGroup |
| {{ |
| |
| {is_in_group_definitions} |
| |
| }} // namespace BuiltInGroup |
| |
| }} // namespace sh |
| |
| #endif // COMPILER_TRANSLATOR_PARSECONTEXT_AUTOGEN_H_ |
| |
| """ |
| |
| parsed_variables = None |
| |
| basic_types_enumeration = [ |
| 'Void', |
| 'Float', |
| 'Int', |
| 'UInt', |
| 'Bool', |
| 'AtomicCounter', |
| 'YuvCscStandardEXT', |
| 'Sampler2D', |
| 'Sampler3D', |
| 'SamplerCube', |
| 'Sampler2DArray', |
| 'SamplerExternalOES', |
| 'SamplerExternal2DY2YEXT', |
| 'Sampler2DRect', |
| 'Sampler2DMS', |
| 'Sampler2DMSArray', |
| 'ISampler2D', |
| 'ISampler3D', |
| 'ISamplerCube', |
| 'ISampler2DArray', |
| 'ISampler2DMS', |
| 'ISampler2DMSArray', |
| 'USampler2D', |
| 'USampler3D', |
| 'USamplerCube', |
| 'USampler2DArray', |
| 'USampler2DMS', |
| 'USampler2DMSArray', |
| 'Sampler2DShadow', |
| 'SamplerCubeShadow', |
| 'Sampler2DArrayShadow', |
| 'Image2D', |
| 'IImage2D', |
| 'UImage2D', |
| 'Image3D', |
| 'IImage3D', |
| 'UImage3D', |
| 'Image2DArray', |
| 'IImage2DArray', |
| 'UImage2DArray', |
| 'ImageCube', |
| 'IImageCube', |
| 'UImageCube' |
| ] |
| |
| id_counter = 0 |
| |
| def set_working_dir(): |
| script_dir = os.path.dirname(os.path.abspath(__file__)) |
| os.chdir(script_dir) |
| |
| def get_basic_mangled_name(basic): |
| index = basic_types_enumeration.index(basic) |
| if index < 26: |
| return chr(ord('A') + index) |
| return chr(ord('a') + index - 26) |
| |
| levels = ['ESSL3_1_BUILTINS', 'ESSL3_BUILTINS', 'ESSL1_BUILTINS', 'COMMON_BUILTINS'] |
| |
| def get_shader_version_condition_for_level(level): |
| if level == 'ESSL3_1_BUILTINS': |
| return 'shaderVersion >= 310' |
| elif level == 'ESSL3_BUILTINS': |
| return 'shaderVersion >= 300' |
| elif level == 'ESSL1_BUILTINS': |
| return 'shaderVersion == 100' |
| elif level == 'COMMON_BUILTINS': |
| return '' |
| else: |
| raise Exception('Unsupported symbol table level') |
| |
| class GroupedList: |
| """"Class for storing a list of objects grouped by symbol table level and condition.""" |
| def __init__(self): |
| self.objs = OrderedDict() |
| self.max_name_length = 0 |
| # We need to add all the levels here instead of lazily since they must be in a specific order. |
| for l in levels: |
| self.objs[l] = OrderedDict() |
| |
| def add_obj(self, level, condition, name, obj): |
| if (level not in levels): |
| raise Exception('Unexpected level: ' + str(level)) |
| if condition not in self.objs[level]: |
| self.objs[level][condition] = OrderedDict() |
| self.objs[level][condition][name] = obj |
| if len(name) > self.max_name_length: |
| self.max_name_length = len(name) |
| |
| def has_key(self, level, condition, name): |
| if (level not in levels): |
| raise Exception('Unexpected level: ' + str(level)) |
| if condition not in self.objs[level]: |
| return False |
| return (name in self.objs[level][condition]) |
| |
| def get(self, level, condition, name): |
| if self.has_key(level, condition, name): |
| return self.objs[level][condition][name] |
| return None |
| |
| def get_max_name_length(self): |
| return self.max_name_length |
| |
| def get_switch_code(self, script_generated_hash_tests): |
| code = [] |
| for level in levels: |
| if len(self.objs[level]) == 0: |
| continue |
| level_condition = get_shader_version_condition_for_level(level) |
| if level_condition != '': |
| code.append('if ({condition})\n {{'.format(condition = level_condition)) |
| |
| for condition, objs in self.objs[level].iteritems(): |
| if len(objs) > 0: |
| if condition != 'NO_CONDITION': |
| condition_header = ' if ({condition})\n {{'.format(condition = condition) |
| code.append(condition_header.replace('shaderType', 'mShaderType')) |
| |
| switch = {} |
| for name, obj in objs.iteritems(): |
| name_hash = mangledNameHash(name, script_generated_hash_tests) |
| if name_hash not in switch: |
| switch[name_hash] = [] |
| switch[name_hash].append(obj['hash_matched_code']) |
| |
| code.append('switch(nameHash) {') |
| for name_hash, obj in sorted(switch.iteritems()): |
| code.append('case 0x' + ('%08x' % name_hash) + 'u:\n{') |
| code += obj |
| code.append('break;\n}') |
| code.append('}') |
| |
| if condition != 'NO_CONDITION': |
| code.append('}') |
| |
| if level_condition != '': |
| code.append('}') |
| code.append('return nullptr;') |
| return '\n'.join(code) |
| |
| class TType: |
| def __init__(self, glsl_header_type): |
| if isinstance(glsl_header_type, basestring): |
| self.data = self.parse_type(glsl_header_type) |
| else: |
| self.data = glsl_header_type |
| self.normalize() |
| |
| def normalize(self): |
| # Note that this will set primarySize and secondarySize also on genTypes. In that case they |
| # are overridden when the specific types are generated. |
| if 'primarySize' not in self.data: |
| if ('secondarySize' in self.data): |
| raise Exception('Unexpected secondarySize on type that does not have primarySize set') |
| self.data['primarySize'] = 1 |
| if 'secondarySize' not in self.data: |
| self.data['secondarySize'] = 1 |
| if 'precision' not in self.data: |
| self.data['precision'] = 'Undefined' |
| if 'qualifier' not in self.data: |
| self.data['qualifier'] = 'Global' |
| |
| def get_statictype_string(self): |
| template_type = 'StaticType::Get<Ebt{basic}, Ebp{precision}, Evq{qualifier}, {primarySize}, {secondarySize}>()' |
| return template_type.format(**self.data) |
| |
| def get_dynamic_type_string(self): |
| template_type = 'new TType(Ebt{basic}, Ebp{precision}, Evq{qualifier}, {primarySize}, {secondarySize})' |
| return template_type.format(**self.data) |
| |
| def get_mangled_name(self): |
| mangled_name = '' |
| |
| size_key = (self.data['secondarySize'] - 1) * 4 + self.data['primarySize'] - 1 |
| if size_key < 10: |
| mangled_name += chr(ord('0') + size_key) |
| else: |
| mangled_name += chr(ord('A') + size_key - 10) |
| |
| mangled_name += get_basic_mangled_name(self.data['basic']) |
| return mangled_name |
| |
| def get_human_readable_name(self): |
| name = self.data['basic'] |
| name += str(self.data['primarySize']) |
| if self.data['secondarySize'] > 1: |
| name += 'x' + str(self.data['secondarySize']) |
| return name |
| |
| def is_vector(self): |
| return self.data['primarySize'] > 1 and self.data['secondarySize'] == 1 |
| |
| def is_matrix(self): |
| return self.data['secondarySize'] > 1 |
| |
| def get_object_size(self): |
| return self.data['primarySize'] * self.data['secondarySize'] |
| |
| def specific_sampler_or_image_type(self, basic_type_prefix): |
| if 'genType' in self.data: |
| type = {} |
| if 'basic' not in self.data: |
| type['basic'] = {'': 'Float', 'I': 'Int', 'U': 'UInt'}[basic_type_prefix] |
| type['primarySize'] = self.data['primarySize'] |
| else: |
| type['basic'] = basic_type_prefix + self.data['basic'] |
| type['primarySize'] = 1 |
| type['precision'] = 'Undefined' |
| return TType(type) |
| return self |
| |
| def specific_type(self, vec_size): |
| type = {} |
| if 'genType' in self.data: |
| type['basic'] = self.data['basic'] |
| type['precision'] = self.data['precision'] |
| type['qualifier'] = self.data['qualifier'] |
| type['primarySize'] = vec_size |
| type['secondarySize'] = 1 |
| return TType(type) |
| return self |
| |
| def parse_type(self, glsl_header_type): |
| if glsl_header_type.startswith('out '): |
| type_obj = self.parse_type(glsl_header_type[4:]) |
| type_obj['qualifier'] = 'Out' |
| return type_obj |
| if glsl_header_type.startswith('inout '): |
| type_obj = self.parse_type(glsl_header_type[6:]) |
| type_obj['qualifier'] = 'InOut' |
| return type_obj |
| |
| basic_type_map = { |
| 'float': 'Float', |
| 'int': 'Int', |
| 'uint': 'UInt', |
| 'bool': 'Bool', |
| 'void': 'Void', |
| 'atomic_uint': 'AtomicCounter', |
| 'yuvCscStandardEXT': 'YuvCscStandardEXT' |
| } |
| |
| if glsl_header_type in basic_type_map: |
| return {'basic': basic_type_map[glsl_header_type]} |
| |
| type_obj = {} |
| |
| basic_type_prefix_map = {'': 'Float', 'i': 'Int', 'u': 'UInt', 'b': 'Bool', 'v': 'Void'} |
| |
| vec_re = re.compile(r'^([iub]?)vec([234]?)$') |
| vec_match = vec_re.match(glsl_header_type) |
| if vec_match: |
| type_obj['basic'] = basic_type_prefix_map[vec_match.group(1)] |
| if vec_match.group(2) == '': |
| # Type like "ivec" that represents either ivec2, ivec3 or ivec4 |
| type_obj['genType'] = 'vec' |
| else: |
| # vec with specific size |
| type_obj['primarySize'] = int(vec_match.group(2)) |
| return type_obj |
| |
| mat_re = re.compile(r'^mat([234])(x([234]))?$') |
| mat_match = mat_re.match(glsl_header_type) |
| if mat_match: |
| type_obj['basic'] = 'Float' |
| if len(glsl_header_type) == 4: |
| mat_size = int(mat_match.group(1)) |
| type_obj['primarySize'] = mat_size |
| type_obj['secondarySize'] = mat_size |
| else: |
| type_obj['primarySize'] = int(mat_match.group(1)) |
| type_obj['secondarySize'] = int(mat_match.group(3)) |
| return type_obj |
| |
| gen_re = re.compile(r'^gen([IUB]?)Type$') |
| gen_match = gen_re.match(glsl_header_type) |
| if gen_match: |
| type_obj['basic'] = basic_type_prefix_map[gen_match.group(1).lower()] |
| type_obj['genType'] = 'yes' |
| return type_obj |
| |
| if glsl_header_type.startswith('sampler'): |
| type_obj['basic'] = glsl_header_type[0].upper() + glsl_header_type[1:] |
| return type_obj |
| |
| if glsl_header_type.startswith('gsampler') or glsl_header_type.startswith('gimage'): |
| type_obj['basic'] = glsl_header_type[1].upper() + glsl_header_type[2:] |
| type_obj['genType'] = 'sampler_or_image' |
| return type_obj |
| |
| if glsl_header_type == 'gvec4': |
| return {'primarySize': 4, 'genType': 'sampler_or_image'} |
| if glsl_header_type == 'gvec3': |
| return {'primarySize': 3, 'genType': 'sampler_or_image'} |
| |
| raise Exception('Unrecognized type: ' + str(glsl_header_type)) |
| |
| def get_parsed_functions(functions_txt_filename): |
| |
| def parse_function_parameters(parameters): |
| if parameters == '': |
| return [] |
| parametersOut = [] |
| parameters = parameters.split(', ') |
| for parameter in parameters: |
| parametersOut.append(TType(parameter.strip())) |
| return parametersOut |
| |
| lines = [] |
| with open(functions_txt_filename) as f: |
| lines = f.readlines() |
| lines = [line.strip() for line in lines if line.strip() != '' and not line.strip().startswith('//')] |
| |
| fun_re = re.compile(r'^(\w+) (\w+)\((.*)\);$') |
| |
| parsed_functions = OrderedDict() |
| group_stack = [] |
| default_metadata = {} |
| |
| for line in lines: |
| fun_match = fun_re.match(line) |
| if line.startswith('GROUP BEGIN '): |
| group_rest = line[12:].strip() |
| group_parts = group_rest.split(' ', 1) |
| current_group = { |
| 'functions': [], |
| 'name': group_parts[0], |
| 'subgroups': {} |
| } |
| if len(group_parts) > 1: |
| group_metadata = json.loads(group_parts[1]) |
| current_group.update(group_metadata) |
| group_stack.append(current_group) |
| elif line.startswith('GROUP END '): |
| group_end_name = line[10:].strip() |
| current_group = group_stack[-1] |
| if current_group['name'] != group_end_name: |
| raise Exception('GROUP END: Unexpected function group name "' + group_end_name + '" was expecting "' + current_group['name'] + '"') |
| group_stack.pop() |
| is_top_level_group = (len(group_stack) == 0) |
| if is_top_level_group: |
| parsed_functions[current_group['name']] = current_group |
| default_metadata = {} |
| else: |
| super_group = group_stack[-1] |
| super_group['subgroups'][current_group['name']] = current_group |
| elif line.startswith('DEFAULT METADATA'): |
| line_rest = line[16:].strip() |
| default_metadata = json.loads(line_rest) |
| elif fun_match: |
| return_type = fun_match.group(1) |
| name = fun_match.group(2) |
| parameters = fun_match.group(3) |
| function_props = { |
| 'name': name, |
| 'returnType': TType(return_type), |
| 'parameters': parse_function_parameters(parameters) |
| } |
| function_props.update(default_metadata) |
| group_stack[-1]['functions'].append(function_props) |
| else: |
| raise Exception('Unexpected function input line: ' + line) |
| |
| return parsed_functions |
| |
| fnvPrime = 16777619 |
| def hash32(str): |
| fnvOffsetBasis = 0x811c9dc5 |
| hash = fnvOffsetBasis |
| for c in str: |
| hash = hash ^ ord(c) |
| hash = (hash * fnvPrime) & 0xffffffff |
| return hash |
| |
| def mangledNameHash(str, script_generated_hash_tests, save_test = True): |
| hash = hash32(str) |
| index = 0 |
| max_six_bit_value = (1 << 6) - 1 |
| paren_location = max_six_bit_value |
| has_array_or_block_param_bit = 0 |
| for c in str: |
| if c == '(': |
| paren_location = index |
| elif c == '{' or c == '[': |
| has_array_or_block_param_bit = 1 |
| index += 1 |
| hash = ((hash >> 13) ^ (hash & 0x1fff)) | (index << 19) | (paren_location << 25) | (has_array_or_block_param_bit << 31) |
| if save_test: |
| sanity_check = ' ASSERT_EQ(0x{hash}u, ImmutableString("{str}").mangledNameHash());'.format(hash = ('%08x' % hash), str = str) |
| script_generated_hash_tests.update({sanity_check: None}) |
| return hash |
| |
| def get_suffix(props): |
| if 'suffix' in props: |
| return props['suffix'] |
| return '' |
| |
| def get_extension(props): |
| if 'extension' in props: |
| return props['extension'] |
| return 'UNDEFINED' |
| |
| def get_op(name, function_props): |
| if 'op' not in function_props: |
| raise Exception('function op not defined') |
| if function_props['op'] == 'auto': |
| return name[0].upper() + name[1:] |
| return function_props['op'] |
| |
| def get_known_to_not_have_side_effects(function_props): |
| if 'op' in function_props and function_props['op'] != 'CallBuiltInFunction': |
| if 'hasSideEffects' in function_props: |
| return 'false' |
| else: |
| for param in get_parameters(function_props): |
| if 'qualifier' in param.data and (param.data['qualifier'] == 'Out' or param.data['qualifier'] == 'InOut'): |
| return 'false' |
| return 'true' |
| return 'false' |
| |
| def get_parameters(function_props): |
| if 'parameters' in function_props: |
| return function_props['parameters'] |
| return [] |
| |
| def get_function_mangled_name(function_name, parameters): |
| mangled_name = function_name + '(' |
| for param in parameters: |
| mangled_name += param.get_mangled_name() |
| return mangled_name |
| |
| def get_function_human_readable_name(function_name, parameters): |
| name = function_name |
| for param in parameters: |
| name += '_' + param.get_human_readable_name() |
| return name |
| |
| def gen_parameters_variant_ids(str_len, ttype_mangled_name_variants): |
| # Note that this doesn't generate variants with array parameters or struct / interface block parameters. They are assumed to have been filtered out separately. |
| if str_len % 2 != 0: |
| raise Exception('Expecting parameters mangled name length to be divisible by two') |
| num_variants = pow(len(ttype_mangled_name_variants), str_len / 2) |
| return xrange(num_variants) |
| |
| def get_parameters_mangled_name_variant(variant_id, paren_location, total_length, ttype_mangled_name_variants): |
| str_len = total_length - paren_location - 1 |
| if str_len % 2 != 0: |
| raise Exception('Expecting parameters mangled name length to be divisible by two') |
| variant = '' |
| while (len(variant)) < str_len: |
| parameter_index = len(variant) / 2 |
| parameter_variant_index = variant_id |
| for i in xrange(parameter_index): |
| parameter_variant_index = parameter_variant_index / len(ttype_mangled_name_variants) |
| parameter_variant_index = parameter_variant_index % len(ttype_mangled_name_variants) |
| variant += ttype_mangled_name_variants[parameter_variant_index] |
| return variant |
| |
| # Calculate the mangled name hash of a common prefix string that's been pre-hashed with hash32() |
| # plus a variant of the parameters. This is faster than constructing the whole string and then |
| # calculating the hash for that. |
| def get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, total_length, |
| num_type_variants, ttype_mangled_name_variants): |
| hash = prefix_hash32 |
| parameter_count = (total_length - paren_location) >> 1 |
| parameter_variant_id_base = variant_id |
| for parameter_index in xrange(parameter_count): |
| parameter_variant_index = parameter_variant_id_base % num_type_variants |
| param_str = ttype_mangled_name_variants[parameter_variant_index] |
| hash = hash ^ ord(param_str[0]) |
| hash = (hash * fnvPrime) & 0xffffffff |
| hash = hash ^ ord(param_str[1]) |
| hash = (hash * fnvPrime) & 0xffffffff |
| parameter_variant_id_base = parameter_variant_id_base / num_type_variants |
| return ((hash >> 13) ^ (hash & 0x1fff)) | (total_length << 19) | (paren_location << 25) |
| |
| def mangled_name_hash_can_collide_with_different_parameters(function_variant_props, num_type_variants, |
| ttype_mangled_name_variants, script_generated_hash_tests): |
| # We exhaustively search through all possible lists of parameters and see if any other mangled |
| # name has the same hash. |
| mangled_name = function_variant_props['mangled_name'] |
| mangled_name_len = len(mangled_name) |
| hash = mangledNameHash(mangled_name, script_generated_hash_tests) |
| mangled_name_prefix = function_variant_props['name'] + '(' |
| paren_location = len(mangled_name_prefix) - 1 |
| prefix_hash32 = hash32(mangled_name_prefix) |
| parameters_mangled_name_len = len(mangled_name) - len(mangled_name_prefix) |
| parameters_mangled_name = mangled_name[len(mangled_name_prefix):] |
| if (parameters_mangled_name_len > 6): |
| # This increases the complexity of searching for hash collisions considerably, so rather than doing it we just conservatively assume that a hash collision may be possible. |
| return True |
| for variant_id in gen_parameters_variant_ids(parameters_mangled_name_len, ttype_mangled_name_variants): |
| variant_hash = get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, mangled_name_len, |
| num_type_variants, ttype_mangled_name_variants) |
| manged_name_variant = get_parameters_mangled_name_variant(variant_id, paren_location, mangled_name_len, |
| ttype_mangled_name_variants) |
| if variant_hash == hash and manged_name_variant != parameters_mangled_name: |
| return True |
| return False |
| |
| def get_unique_identifier_name(function_name, parameters): |
| unique_name = function_name + '_' |
| for param in parameters: |
| unique_name += param.get_mangled_name() |
| return unique_name |
| |
| def get_variable_name_to_store_parameter(param): |
| unique_name = 'pt' |
| if 'qualifier' in param.data: |
| if param.data['qualifier'] == 'Out': |
| unique_name += '_o_' |
| if param.data['qualifier'] == 'InOut': |
| unique_name += '_io_' |
| unique_name += param.get_mangled_name() |
| return unique_name |
| |
| def get_variable_name_to_store_parameters(parameters): |
| if len(parameters) == 0: |
| return 'empty' |
| unique_name = 'p' |
| for param in parameters: |
| if 'qualifier' in param.data: |
| if param.data['qualifier'] == 'Out': |
| unique_name += '_o_' |
| if param.data['qualifier'] == 'InOut': |
| unique_name += '_io_' |
| unique_name += param.get_mangled_name() |
| return unique_name |
| |
| def define_constexpr_variable(template_args, variable_declarations): |
| template_variable_declaration = 'constexpr const TVariable kVar_{name_with_suffix}(BuiltInId::{name_with_suffix}, BuiltInName::{name}, SymbolType::BuiltIn, TExtension::{extension}, {type});' |
| variable_declarations.append(template_variable_declaration.format(**template_args)) |
| |
| def gen_function_variants(function_name, function_props): |
| function_variants = [] |
| parameters = get_parameters(function_props) |
| function_is_gen_type = False |
| gen_type = set() |
| for param in parameters: |
| if 'genType' in param.data: |
| if param.data['genType'] not in ['sampler_or_image', 'vec', 'yes']: |
| raise Exception('Unexpected value of genType "' + str(param.data['genType']) + '" should be "sampler_or_image", "vec", or "yes"') |
| gen_type.add(param.data['genType']) |
| if len(gen_type) > 1: |
| raise Exception('Unexpected multiple values of genType set on the same function: ' + str(list(gen_type))) |
| if len(gen_type) == 0: |
| function_variants.append(function_props) |
| return function_variants |
| |
| # If we have a gsampler_or_image then we're generating variants for float, int and uint |
| # samplers. |
| if 'sampler_or_image' in gen_type: |
| types = ['', 'I', 'U'] |
| for type in types: |
| variant_props = function_props.copy() |
| variant_parameters = [] |
| for param in parameters: |
| variant_parameters.append(param.specific_sampler_or_image_type(type)) |
| variant_props['parameters'] = variant_parameters |
| variant_props['returnType'] = function_props['returnType'].specific_sampler_or_image_type(type) |
| function_variants.append(variant_props) |
| return function_variants |
| |
| # If we have a normal gentype then we're generating variants for different sizes of vectors. |
| sizes = range(1, 5) |
| if 'vec' in gen_type: |
| sizes = range(2, 5) |
| for size in sizes: |
| variant_props = function_props.copy() |
| variant_parameters = [] |
| for param in parameters: |
| variant_parameters.append(param.specific_type(size)) |
| variant_props['parameters'] = variant_parameters |
| variant_props['returnType'] = function_props['returnType'].specific_type(size) |
| function_variants.append(variant_props) |
| return function_variants |
| |
| def process_single_function_group(condition, group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants, |
| name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations, defined_function_variants, |
| builtin_id_declarations, builtin_id_definitions, defined_parameter_names, variable_declarations, function_declarations, |
| script_generated_hash_tests, get_builtin_if_statements): |
| global id_counter |
| |
| if 'functions' not in group: |
| return |
| |
| for function_props in group['functions']: |
| function_name = function_props['name'] |
| level = function_props['level'] |
| extension = get_extension(function_props) |
| template_args = { |
| 'name': function_name, |
| 'name_with_suffix': function_name + get_suffix(function_props), |
| 'level': level, |
| 'extension': extension, |
| 'op': get_op(function_name, function_props), |
| 'known_to_not_have_side_effects': get_known_to_not_have_side_effects(function_props) |
| } |
| |
| function_variants = gen_function_variants(function_name, function_props) |
| |
| template_name_declaration = 'constexpr const ImmutableString {name_with_suffix}("{name}");' |
| name_declaration = template_name_declaration.format(**template_args) |
| if not name_declaration in name_declarations: |
| name_declarations.add(name_declaration) |
| |
| template_unmangled_if = """if (name == BuiltInName::{name_with_suffix}) |
| {{ |
| return &UnmangledBuiltIns::{extension}; |
| }}""" |
| unmangled_if = template_unmangled_if.format(**template_args) |
| unmangled_builtin_no_condition = unmangled_function_if_statements.get(level, 'NO_CONDITION', function_name) |
| if unmangled_builtin_no_condition != None and unmangled_builtin_no_condition['extension'] == 'UNDEFINED': |
| # We already have this unmangled name without a condition nor extension on the same level. No need to add a duplicate with a condition. |
| pass |
| elif (not unmangled_function_if_statements.has_key(level, condition, function_name)) or extension == 'UNDEFINED': |
| # We don't have this unmangled builtin recorded yet or we might replace an unmangled builtin from an extension with one from core. |
| unmangled_function_if_statements.add_obj(level, condition, function_name, {'hash_matched_code': unmangled_if, 'extension': extension}) |
| unmangled_builtin_declarations.add('constexpr const UnmangledBuiltIn {extension}(TExtension::{extension});'.format(**template_args)) |
| |
| for function_props in function_variants: |
| template_args['id'] = id_counter |
| |
| parameters = get_parameters(function_props) |
| |
| template_args['unique_name'] = get_unique_identifier_name(template_args['name_with_suffix'], parameters) |
| |
| if template_args['unique_name'] in defined_function_variants: |
| continue |
| defined_function_variants.add(template_args['unique_name']) |
| |
| template_args['param_count'] = len(parameters) |
| template_args['return_type'] = function_props['returnType'].get_statictype_string() |
| template_args['mangled_name'] = get_function_mangled_name(function_name, parameters) |
| template_args['human_readable_name'] = get_function_human_readable_name(template_args['name_with_suffix'], parameters) |
| template_args['mangled_name_length'] = len(template_args['mangled_name']) |
| |
| template_builtin_id_declaration = ' static constexpr const TSymbolUniqueId {human_readable_name} = TSymbolUniqueId({id});' |
| builtin_id_declarations.append(template_builtin_id_declaration.format(**template_args)) |
| template_builtin_id_definition = 'constexpr const TSymbolUniqueId BuiltInId::{human_readable_name};' |
| builtin_id_definitions.append(template_builtin_id_definition.format(**template_args)) |
| |
| parameters_list = [] |
| for param in parameters: |
| unique_param_name = get_variable_name_to_store_parameter(param) |
| param_template_args = { |
| 'name': '_empty', |
| 'name_with_suffix': unique_param_name, |
| 'type': param.get_statictype_string(), |
| 'extension': 'UNDEFINED' |
| } |
| if unique_param_name not in defined_parameter_names: |
| id_counter += 1 |
| param_template_args['id'] = id_counter |
| template_builtin_id_declaration = ' static constexpr const TSymbolUniqueId {name_with_suffix} = TSymbolUniqueId({id});' |
| builtin_id_declarations.append(template_builtin_id_declaration.format(**param_template_args)) |
| define_constexpr_variable(param_template_args, variable_declarations) |
| defined_parameter_names.add(unique_param_name) |
| parameters_list.append('&BuiltInVariable::kVar_{name_with_suffix}'.format(**param_template_args)); |
| |
| template_args['parameters_var_name'] = get_variable_name_to_store_parameters(parameters) |
| if len(parameters) > 0: |
| template_args['parameters_list'] = ', '.join(parameters_list) |
| template_parameter_list_declaration = 'constexpr const TVariable *{parameters_var_name}[{param_count}] = {{ {parameters_list} }};' |
| parameter_declarations[template_args['parameters_var_name']] = template_parameter_list_declaration.format(**template_args) |
| else: |
| template_parameter_list_declaration = 'constexpr const TVariable **{parameters_var_name} = nullptr;' |
| parameter_declarations[template_args['parameters_var_name']] = template_parameter_list_declaration.format(**template_args) |
| |
| template_function_declaration = 'constexpr const TFunction kFunction_{unique_name}(BuiltInId::{human_readable_name}, BuiltInName::{name_with_suffix}, TExtension::{extension}, BuiltInParameters::{parameters_var_name}, {param_count}, {return_type}, EOp{op}, {known_to_not_have_side_effects});' |
| function_declarations.append(template_function_declaration.format(**template_args)) |
| |
| # If we can make sure that there's no other mangled name with the same length, function |
| # name and hash, then we can only check the mangled name length and the function name |
| # instead of checking the whole mangled name. |
| template_mangled_if = '' |
| if mangled_name_hash_can_collide_with_different_parameters(template_args, num_type_variants, |
| ttype_mangled_name_variants, script_generated_hash_tests): |
| template_mangled_name_declaration = 'constexpr const ImmutableString {unique_name}("{mangled_name}");' |
| name_declarations.add(template_mangled_name_declaration.format(**template_args)) |
| template_mangled_if = """if (name == BuiltInName::{unique_name}) |
| {{ |
| return &BuiltInFunction::kFunction_{unique_name}; |
| }}""" |
| else: |
| template_mangled_if = """if (name.beginsWith(BuiltInName::{name_with_suffix})) |
| {{ |
| ASSERT(name.length() == {mangled_name_length}); |
| return &BuiltInFunction::kFunction_{unique_name}; |
| }}""" |
| mangled_if = template_mangled_if.format(**template_args) |
| get_builtin_if_statements.add_obj(level, condition, template_args['mangled_name'], {'hash_matched_code': mangled_if}) |
| |
| id_counter += 1 |
| |
| def process_function_group(group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants, |
| name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations, |
| defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names, |
| variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements, |
| is_in_group_definitions): |
| global id_counter |
| first_id = id_counter |
| |
| condition = 'NO_CONDITION' |
| if 'condition' in group: |
| condition = group['condition'] |
| |
| process_single_function_group(condition, group_name, group, num_type_variants, parameter_declarations, |
| ttype_mangled_name_variants, name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations, |
| defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names, |
| variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements) |
| |
| if 'subgroups' in group: |
| for subgroup_name, subgroup in group['subgroups'].iteritems(): |
| process_function_group(group_name + subgroup_name, subgroup, num_type_variants, parameter_declarations, |
| ttype_mangled_name_variants, name_declarations, unmangled_function_if_statements, |
| unmangled_builtin_declarations, defined_function_variants, builtin_id_declarations, |
| builtin_id_definitions, defined_parameter_names, variable_declarations, function_declarations, |
| script_generated_hash_tests, get_builtin_if_statements, is_in_group_definitions) |
| |
| if 'queryFunction' in group: |
| template_args = { |
| 'first_id': first_id, |
| 'last_id': id_counter - 1, |
| 'group_name': group_name |
| } |
| template_is_in_group_definition = """bool is{group_name}(const TFunction *func) |
| {{ |
| int id = func->uniqueId().get(); |
| return id >= {first_id} && id <= {last_id}; |
| }}""" |
| is_in_group_definitions.append(template_is_in_group_definition.format(**template_args)) |
| |
| def prune_parameters_arrays(parameter_declarations, function_declarations): |
| # We can share parameters arrays between functions in case one array is a subarray of another. |
| parameter_variable_name_replacements = {} |
| used_param_variable_names = set() |
| for param_variable_name, param_declaration in sorted(parameter_declarations.iteritems(), key=lambda item: -len(item[0])): |
| replaced = False |
| for used in used_param_variable_names: |
| if used.startswith(param_variable_name): |
| parameter_variable_name_replacements[param_variable_name] = used |
| replaced = True |
| break |
| if not replaced: |
| used_param_variable_names.add(param_variable_name) |
| |
| for i in xrange(len(function_declarations)): |
| for replaced, replacement in parameter_variable_name_replacements.iteritems(): |
| function_declarations[i] = function_declarations[i].replace('BuiltInParameters::' + replaced + ',', 'BuiltInParameters::' + replacement + ',') |
| |
| return [value for key, value in parameter_declarations.iteritems() if key in used_param_variable_names] |
| |
| def process_single_variable_group(condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations, |
| init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations, |
| get_variable_definitions, variable_name_count): |
| global id_counter |
| if 'variables' not in group: |
| return |
| for variable_name, props in group['variables'].iteritems(): |
| level = props['level'] |
| template_args = { |
| 'id': id_counter, |
| 'name': variable_name, |
| 'name_with_suffix': variable_name + get_suffix(props), |
| 'level': props['level'], |
| 'extension': get_extension(props), |
| 'class': 'TVariable' |
| } |
| |
| template_builtin_id_declaration = ' static constexpr const TSymbolUniqueId {name_with_suffix} = TSymbolUniqueId({id});' |
| builtin_id_declarations.append(template_builtin_id_declaration.format(**template_args)) |
| template_builtin_id_definition = 'constexpr const TSymbolUniqueId BuiltInId::{name_with_suffix};' |
| builtin_id_definitions.append(template_builtin_id_definition.format(**template_args)) |
| |
| template_name_declaration = 'constexpr const ImmutableString {name}("{name}");' |
| name_declarations.add(template_name_declaration.format(**template_args)) |
| |
| is_member = True |
| template_init_variable = '' |
| |
| if 'type' in props: |
| if props['type']['basic'] != 'Bool' and 'precision' not in props['type']: |
| raise Exception('Missing precision for variable ' + variable_name) |
| template_args['type'] = TType(props['type']).get_statictype_string() |
| |
| if 'fields' in props: |
| # Handle struct and interface block definitions. |
| template_args['class'] = props['class'] |
| template_args['fields'] = 'fields_{name_with_suffix}'.format(**template_args) |
| init_member_variables.append(' TFieldList *{fields} = new TFieldList();'.format(**template_args)) |
| for field_name, field_type in props['fields'].iteritems(): |
| template_args['field_name'] = field_name |
| template_args['field_type'] = TType(field_type).get_dynamic_type_string() |
| template_name_declaration = 'constexpr const ImmutableString {field_name}("{field_name}");' |
| name_declarations.add(template_name_declaration.format(**template_args)) |
| template_add_field = ' {fields}->push_back(new TField({field_type}, BuiltInName::{field_name}, zeroSourceLoc, SymbolType::BuiltIn));' |
| init_member_variables.append(template_add_field.format(**template_args)) |
| template_init_temp_variable = ' {class} *{name_with_suffix} = new {class}(BuiltInId::{name_with_suffix}, BuiltInName::{name}, TExtension::{extension}, {fields});' |
| init_member_variables.append(template_init_temp_variable.format(**template_args)) |
| if 'private' in props and props['private']: |
| is_member = False |
| else: |
| template_init_variable = ' mVar_{name_with_suffix} = {name_with_suffix};' |
| |
| elif 'initDynamicType' in props: |
| # Handle variables whose type can't be expressed as TStaticType |
| # (type is a struct or has variable array size for example). |
| template_args['type_name'] = 'type_{name_with_suffix}'.format(**template_args) |
| template_args['type'] = template_args['type_name'] |
| template_args['initDynamicType'] = props['initDynamicType'].format(**template_args) |
| template_init_variable = """ {initDynamicType} |
| {type_name}->realize(); |
| mVar_{name_with_suffix} = new TVariable(BuiltInId::{name_with_suffix}, BuiltInName::{name}, SymbolType::BuiltIn, TExtension::{extension}, {type});""" |
| |
| elif 'value' in props: |
| # Handle variables with constant value, such as gl_MaxDrawBuffers. |
| if props['value'] != 'resources': |
| raise Exception('Unrecognized value source in variable properties: ' + str(props['value'])) |
| resources_key = variable_name[3:] |
| if 'valueKey' in props: |
| resources_key = props['valueKey'] |
| template_args['value'] = 'resources.' + resources_key |
| template_args['object_size'] = TType(props['type']).get_object_size() |
| template_init_variable = """ mVar_{name_with_suffix} = new TVariable(BuiltInId::{name_with_suffix}, BuiltInName::{name}, SymbolType::BuiltIn, TExtension::{extension}, {type}); |
| {{ |
| TConstantUnion *unionArray = new TConstantUnion[{object_size}]; |
| unionArray[0].setIConst({value}); |
| mVar_{name_with_suffix}->shareConstPointer(unionArray); |
| }}""" |
| if template_args['object_size'] > 1: |
| template_init_variable = """ mVar_{name_with_suffix} = new TVariable(BuiltInId::{name_with_suffix}, BuiltInName::{name}, SymbolType::BuiltIn, TExtension::{extension}, {type}); |
| {{ |
| TConstantUnion *unionArray = new TConstantUnion[{object_size}]; |
| for (size_t index = 0u; index < {object_size}; ++index) |
| {{ |
| unionArray[index].setIConst({value}[index]); |
| }} |
| mVar_{name_with_suffix}->shareConstPointer(unionArray); |
| }}""" |
| |
| else: |
| # Handle variables that can be stored as constexpr TVariable like |
| # gl_Position, gl_FragColor etc. |
| define_constexpr_variable(template_args, variable_declarations) |
| is_member = False |
| |
| template_get_variable_declaration = 'const TVariable *{name_with_suffix}();' |
| get_variable_declarations.append(template_get_variable_declaration.format(**template_args)) |
| |
| template_get_variable_definition = """const TVariable *{name_with_suffix}() |
| {{ |
| return &kVar_{name_with_suffix}; |
| }} |
| """ |
| get_variable_definitions.append(template_get_variable_definition.format(**template_args)) |
| |
| if level != 'GLSL_BUILTINS': |
| template_name_if = """if (name == BuiltInName::{name}) |
| {{ |
| return &BuiltInVariable::kVar_{name_with_suffix}; |
| }}""" |
| name_if = template_name_if.format(**template_args) |
| get_builtin_if_statements.add_obj(level, condition, template_args['name'], {'hash_matched_code': name_if}) |
| |
| if is_member: |
| get_condition = condition |
| init_conditionally = (condition != 'NO_CONDITION' and variable_name_count[variable_name] == 1) |
| if init_conditionally: |
| # Instead of having the condition if statement at lookup, it's cheaper to have it at initialization time. |
| init_member_variables.append(' if ({condition})\n {{'.format(condition = condition)) |
| template_args['condition_comment'] = '\n // Only initialized if {condition}'.format(condition = condition) |
| get_condition = 'NO_CONDITION' |
| else: |
| template_args['condition_comment'] = '' |
| init_member_variables.append(template_init_variable.format(**template_args)) |
| if init_conditionally: |
| init_member_variables.append(' }') |
| |
| template_declare_member_variable = '{class} *mVar_{name_with_suffix} = nullptr;' |
| declare_member_variables.append(template_declare_member_variable.format(**template_args)) |
| |
| if level != 'GLSL_BUILTINS': |
| template_name_if = """if (name == BuiltInName::{name}) |
| {{{condition_comment} |
| return mVar_{name_with_suffix}; |
| }}""" |
| name_if = template_name_if.format(**template_args) |
| get_builtin_if_statements.add_obj(level, get_condition, variable_name, {'hash_matched_code': name_if}) |
| |
| id_counter += 1 |
| |
| def count_variable_names(group, variable_name_count): |
| if 'variables' in group: |
| for name in group['variables'].iterkeys(): |
| if name not in variable_name_count: |
| variable_name_count[name] = 1 |
| else: |
| variable_name_count[name] += 1 |
| if 'subgroups' in group: |
| for subgroup_name, subgroup in group['subgroups'].iteritems(): |
| count_variable_names(subgroup, variable_name_count) |
| |
| def process_variable_group(parent_condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations, |
| init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations, |
| get_variable_definitions, variable_name_count): |
| global id_counter |
| condition = 'NO_CONDITION' |
| if 'condition' in group: |
| condition = group['condition'] |
| |
| if parent_condition != 'NO_CONDITION': |
| if condition == 'NO_CONDITION': |
| condition = parent_condition |
| else: |
| condition = '({cond1}) && ({cond2})'.format(cond1 = parent_condition, cond2 = condition) |
| |
| process_single_variable_group(condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations, |
| init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations, |
| get_variable_definitions, variable_name_count) |
| |
| if 'subgroups' in group: |
| for subgroup_name, subgroup in group['subgroups'].iteritems(): |
| process_variable_group(condition, subgroup_name, subgroup, builtin_id_declarations, builtin_id_definitions, name_declarations, |
| init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations, |
| get_variable_definitions, variable_name_count) |
| |
| |
| def main(): |
| |
| set_working_dir() |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--dump-intermediate-json', help='Dump parsed function data as a JSON file builtin_functions.json', action="store_true") |
| parser.add_argument('auto_script_command', nargs='?', default='') |
| args = parser.parse_args() |
| |
| test_filename = '../../tests/compiler_tests/ImmutableString_test_autogen.cpp' |
| variables_json_filename = 'builtin_variables.json' |
| functions_txt_filename = 'builtin_function_declarations.txt' |
| hash_filename = 'builtin_symbols_hash_autogen.txt' |
| |
| # auto_script parameters. |
| if args.auto_script_command != '': |
| inputs = [ |
| functions_txt_filename, |
| variables_json_filename, |
| ] |
| outputs = [ |
| 'ParseContext_autogen.h', |
| 'SymbolTable_autogen.cpp', |
| 'SymbolTable_autogen.h', |
| 'tree_util/BuiltIn_autogen.h', |
| test_filename, |
| hash_filename, |
| ] |
| |
| if args.auto_script_command == 'inputs': |
| print ','.join(inputs) |
| elif args.auto_script_command == 'outputs': |
| print ','.join(outputs) |
| else: |
| print('Invalid script parameters') |
| return 1 |
| return 0 |
| |
| |
| all_inputs = [os.path.abspath(__file__), variables_json_filename, functions_txt_filename] |
| # This script takes a while to run since it searches for hash collisions of mangled names. To avoid |
| # running it unnecessarily, we first check if we've already ran it with the same inputs. |
| m = hashlib.md5() |
| for input_path in all_inputs: |
| with open(input_path, 'rU') as input_file: |
| m.update(input_file.read()) |
| input_hash = m.hexdigest() |
| if os.path.exists(hash_filename): |
| with open(hash_filename) as hash_file: |
| if input_hash == hash_file.read(): |
| print "Canceling ESSL static builtins code generator - generated hash matches inputs." |
| sys.exit(0) |
| |
| # Declarations of symbol unique ids |
| builtin_id_declarations = [] |
| |
| # Definitions of symbol unique ids needed for those ids used outside of constexpr expressions. |
| builtin_id_definitions = [] |
| |
| # Declarations of name string variables |
| name_declarations = set() |
| |
| # Declarations of builtin TVariables |
| variable_declarations = [] |
| |
| # Declarations of builtin TFunctions |
| function_declarations = [] |
| |
| # Functions for querying the pointer to a specific TVariable. |
| get_variable_declarations = [] |
| get_variable_definitions = [] |
| |
| # Code for defining TVariables stored as members of TSymbolTable. |
| declare_member_variables = [] |
| init_member_variables = [] |
| |
| # Code for querying builtins. |
| get_builtin_if_statements = GroupedList() |
| |
| # Declarations of UnmangledBuiltIn objects |
| unmangled_builtin_declarations = set() |
| |
| # Code for querying builtin function unmangled names. |
| unmangled_function_if_statements = GroupedList() |
| |
| # Code for testing that script-generated hashes match with runtime computed hashes. |
| script_generated_hash_tests = OrderedDict() |
| |
| # Functions for testing whether a builtin belongs in group. |
| is_in_group_definitions = [] |
| |
| # Counts of variables with a certain name string: |
| variable_name_count = {} |
| |
| # Declarations of parameter arrays for builtin TFunctions. Map from C++ variable name to the full |
| # declaration. |
| parameter_declarations = {} |
| |
| ttype_mangled_name_variants = [] |
| |
| defined_function_variants = set() |
| defined_parameter_names = set() |
| |
| |
| parsed_functions = get_parsed_functions(functions_txt_filename) |
| |
| if args.dump_intermediate_json: |
| with open('builtin_functions.json', 'w') as outfile: |
| def serialize_obj(obj): |
| if isinstance(obj, TType): |
| return obj.data |
| else: |
| raise "Cannot serialize to JSON: " + str(obj) |
| json.dump(parsed_functions, outfile, indent=4, separators=(',', ': '), default=serialize_obj) |
| |
| with open(variables_json_filename) as f: |
| parsed_variables = json.load(f, object_pairs_hook=OrderedDict) |
| |
| for basic_type in basic_types_enumeration: |
| primary_sizes = [1] |
| secondary_sizes = [1] |
| if basic_type in ['Float', 'Int', 'UInt', 'Bool']: |
| primary_sizes = [1, 2, 3, 4] |
| if basic_type == 'Float': |
| secondary_sizes = [1, 2, 3, 4] |
| for primary_size in primary_sizes: |
| for secondary_size in secondary_sizes: |
| type = TType({'basic': basic_type, 'primarySize': primary_size, 'secondarySize': secondary_size}) |
| ttype_mangled_name_variants.append(type.get_mangled_name()) |
| |
| num_type_variants = len(ttype_mangled_name_variants) |
| |
| # Sanity check for get_mangled_name_variant_hash: |
| variant_hash = get_mangled_name_variant_hash(hash32("atan("), 3, 4, len("atan(0123"), num_type_variants, |
| ttype_mangled_name_variants) |
| mangled_name_hash = mangledNameHash("atan(" + get_parameters_mangled_name_variant(3, 4, len("atan(0123"), |
| ttype_mangled_name_variants), script_generated_hash_tests) |
| if variant_hash != mangled_name_hash: |
| raise Exception("get_mangled_name_variant_hash sanity check failed") |
| |
| for group_name, group in parsed_functions.iteritems(): |
| process_function_group(group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants, |
| name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations, |
| defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names, |
| variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements, |
| is_in_group_definitions) |
| |
| parameter_declarations = prune_parameters_arrays(parameter_declarations, function_declarations) |
| |
| for group_name, group in parsed_variables.iteritems(): |
| count_variable_names(group, variable_name_count) |
| |
| for group_name, group in parsed_variables.iteritems(): |
| process_variable_group('NO_CONDITION', group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations, |
| init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations, |
| get_variable_definitions, variable_name_count) |
| |
| output_strings = { |
| 'script_name': os.path.basename(__file__), |
| 'copyright_year': date.today().year, |
| |
| 'builtin_id_declarations': '\n'.join(builtin_id_declarations), |
| 'builtin_id_definitions': '\n'.join(builtin_id_definitions), |
| 'last_builtin_id': id_counter - 1, |
| 'name_declarations': '\n'.join(sorted(list(name_declarations))), |
| |
| 'function_data_source_name': functions_txt_filename, |
| 'function_declarations': '\n'.join(function_declarations), |
| 'parameter_declarations': '\n'.join(sorted(parameter_declarations)), |
| |
| 'is_in_group_definitions': '\n'.join(is_in_group_definitions), |
| |
| 'variable_data_source_name': variables_json_filename, |
| 'variable_declarations': '\n'.join(sorted(variable_declarations)), |
| 'get_variable_declarations': '\n'.join(sorted(get_variable_declarations)), |
| 'get_variable_definitions': '\n'.join(sorted(get_variable_definitions)), |
| 'unmangled_builtin_declarations': '\n'.join(sorted(unmangled_builtin_declarations)), |
| |
| 'declare_member_variables': '\n'.join(declare_member_variables), |
| 'init_member_variables': '\n'.join(init_member_variables), |
| |
| 'get_unmangled_builtin': unmangled_function_if_statements.get_switch_code(script_generated_hash_tests), |
| 'get_builtin': get_builtin_if_statements.get_switch_code(script_generated_hash_tests), |
| 'max_unmangled_name_length': unmangled_function_if_statements.get_max_name_length(), |
| 'max_mangled_name_length': get_builtin_if_statements.get_max_name_length(), |
| |
| 'script_generated_hash_tests': '\n'.join(script_generated_hash_tests.iterkeys()) |
| } |
| |
| with open(test_filename, 'wt') as outfile_cpp: |
| output_cpp = template_immutablestringtest_cpp.format(**output_strings) |
| outfile_cpp.write(output_cpp) |
| |
| with open('tree_util/BuiltIn_autogen.h', 'wt') as outfile_header: |
| output_header = template_builtin_header.format(**output_strings) |
| outfile_header.write(output_header) |
| |
| with open('SymbolTable_autogen.cpp', 'wt') as outfile_cpp: |
| output_cpp = template_symboltable_cpp.format(**output_strings) |
| outfile_cpp.write(output_cpp) |
| |
| with open('ParseContext_autogen.h', 'wt') as outfile_header: |
| output_header = template_parsecontext_header.format(**output_strings) |
| outfile_header.write(output_header) |
| |
| with open('SymbolTable_autogen.h', 'wt') as outfile_h: |
| output_h = template_symboltable_h.format(**output_strings) |
| outfile_h.write(output_h) |
| |
| with open(hash_filename, 'wt') as hash_file: |
| hash_file.write(input_hash) |
| |
| return 0 |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |
