| #!/usr/bin/env python |
| |
| from __future__ import absolute_import, division, print_function |
| from pprint import pprint |
| import random, atexit, time |
| from random import randrange |
| import re |
| |
| from Enumeration import * |
| from TypeGen import * |
| |
| #### |
| |
| |
| class TypePrinter(object): |
| def __init__( |
| self, |
| output, |
| outputHeader=None, |
| outputTests=None, |
| outputDriver=None, |
| headerName=None, |
| info=None, |
| ): |
| self.output = output |
| self.outputHeader = outputHeader |
| self.outputTests = outputTests |
| self.outputDriver = outputDriver |
| self.writeBody = outputHeader or outputTests or outputDriver |
| self.types = {} |
| self.testValues = {} |
| self.testReturnValues = {} |
| self.layoutTests = [] |
| self.declarations = set() |
| |
| if info: |
| for f in ( |
| self.output, |
| self.outputHeader, |
| self.outputTests, |
| self.outputDriver, |
| ): |
| if f: |
| print(info, file=f) |
| |
| if self.writeBody: |
| print("#include <stdio.h>\n", file=self.output) |
| if self.outputTests: |
| print("#include <stdio.h>", file=self.outputTests) |
| print("#include <string.h>", file=self.outputTests) |
| print("#include <assert.h>\n", file=self.outputTests) |
| |
| if headerName: |
| for f in (self.output, self.outputTests, self.outputDriver): |
| if f is not None: |
| print('#include "%s"\n' % (headerName,), file=f) |
| |
| if self.outputDriver: |
| print("#include <stdio.h>", file=self.outputDriver) |
| print("#include <stdlib.h>\n", file=self.outputDriver) |
| print("int main(int argc, char **argv) {", file=self.outputDriver) |
| print(" int index = -1;", file=self.outputDriver) |
| print(" if (argc > 1) index = atoi(argv[1]);", file=self.outputDriver) |
| |
| def finish(self): |
| if self.layoutTests: |
| print("int main(int argc, char **argv) {", file=self.output) |
| print(" int index = -1;", file=self.output) |
| print(" if (argc > 1) index = atoi(argv[1]);", file=self.output) |
| for i, f in self.layoutTests: |
| print(" if (index == -1 || index == %d)" % i, file=self.output) |
| print(" %s();" % f, file=self.output) |
| print(" return 0;", file=self.output) |
| print("}", file=self.output) |
| |
| if self.outputDriver: |
| print(' printf("DONE\\n");', file=self.outputDriver) |
| print(" return 0;", file=self.outputDriver) |
| print("}", file=self.outputDriver) |
| |
| def addDeclaration(self, decl): |
| if decl in self.declarations: |
| return False |
| |
| self.declarations.add(decl) |
| if self.outputHeader: |
| print(decl, file=self.outputHeader) |
| else: |
| print(decl, file=self.output) |
| if self.outputTests: |
| print(decl, file=self.outputTests) |
| return True |
| |
| def getTypeName(self, T): |
| name = self.types.get(T) |
| if name is None: |
| # Reserve slot |
| self.types[T] = None |
| self.types[T] = name = T.getTypeName(self) |
| return name |
| |
| def writeLayoutTest(self, i, ty): |
| tyName = self.getTypeName(ty) |
| tyNameClean = tyName.replace(" ", "_").replace("*", "star") |
| fnName = "test_%s" % tyNameClean |
| |
| print("void %s(void) {" % fnName, file=self.output) |
| self.printSizeOfType(" %s" % fnName, tyName, ty, self.output) |
| self.printAlignOfType(" %s" % fnName, tyName, ty, self.output) |
| self.printOffsetsOfType(" %s" % fnName, tyName, ty, self.output) |
| print("}", file=self.output) |
| print(file=self.output) |
| |
| self.layoutTests.append((i, fnName)) |
| |
| def writeFunction(self, i, FT): |
| args = ", ".join( |
| ["%s arg%d" % (self.getTypeName(t), i) for i, t in enumerate(FT.argTypes)] |
| ) |
| if not args: |
| args = "void" |
| |
| if FT.returnType is None: |
| retvalName = None |
| retvalTypeName = "void" |
| else: |
| retvalTypeName = self.getTypeName(FT.returnType) |
| if self.writeBody or self.outputTests: |
| retvalName = self.getTestReturnValue(FT.returnType) |
| |
| fnName = "fn%d" % (FT.index,) |
| if self.outputHeader: |
| print("%s %s(%s);" % (retvalTypeName, fnName, args), file=self.outputHeader) |
| elif self.outputTests: |
| print("%s %s(%s);" % (retvalTypeName, fnName, args), file=self.outputTests) |
| |
| print("%s %s(%s)" % (retvalTypeName, fnName, args), end=" ", file=self.output) |
| if self.writeBody: |
| print("{", file=self.output) |
| |
| for i, t in enumerate(FT.argTypes): |
| self.printValueOfType(" %s" % fnName, "arg%d" % i, t) |
| |
| if retvalName is not None: |
| print(" return %s;" % (retvalName,), file=self.output) |
| print("}", file=self.output) |
| else: |
| print("{}", file=self.output) |
| print(file=self.output) |
| |
| if self.outputDriver: |
| print(" if (index == -1 || index == %d) {" % i, file=self.outputDriver) |
| print(" extern void test_%s(void);" % fnName, file=self.outputDriver) |
| print(" test_%s();" % fnName, file=self.outputDriver) |
| print(" }", file=self.outputDriver) |
| |
| if self.outputTests: |
| if self.outputHeader: |
| print("void test_%s(void);" % (fnName,), file=self.outputHeader) |
| |
| if retvalName is None: |
| retvalTests = None |
| else: |
| retvalTests = self.getTestValuesArray(FT.returnType) |
| tests = [self.getTestValuesArray(ty) for ty in FT.argTypes] |
| print("void test_%s(void) {" % (fnName,), file=self.outputTests) |
| |
| if retvalTests is not None: |
| print( |
| ' printf("%s: testing return.\\n");' % (fnName,), |
| file=self.outputTests, |
| ) |
| print( |
| " for (int i=0; i<%d; ++i) {" % (retvalTests[1],), |
| file=self.outputTests, |
| ) |
| args = ", ".join(["%s[%d]" % (t, randrange(l)) for t, l in tests]) |
| print(" %s RV;" % (retvalTypeName,), file=self.outputTests) |
| print( |
| " %s = %s[i];" % (retvalName, retvalTests[0]), |
| file=self.outputTests, |
| ) |
| print(" RV = %s(%s);" % (fnName, args), file=self.outputTests) |
| self.printValueOfType( |
| " %s_RV" % fnName, |
| "RV", |
| FT.returnType, |
| output=self.outputTests, |
| indent=4, |
| ) |
| self.checkTypeValues( |
| "RV", |
| "%s[i]" % retvalTests[0], |
| FT.returnType, |
| output=self.outputTests, |
| indent=4, |
| ) |
| print(" }", file=self.outputTests) |
| |
| if tests: |
| print( |
| ' printf("%s: testing arguments.\\n");' % (fnName,), |
| file=self.outputTests, |
| ) |
| for i, (array, length) in enumerate(tests): |
| for j in range(length): |
| args = ["%s[%d]" % (t, randrange(l)) for t, l in tests] |
| args[i] = "%s[%d]" % (array, j) |
| print( |
| " %s(%s);" |
| % ( |
| fnName, |
| ", ".join(args), |
| ), |
| file=self.outputTests, |
| ) |
| print("}", file=self.outputTests) |
| |
| def getTestReturnValue(self, type): |
| typeName = self.getTypeName(type) |
| info = self.testReturnValues.get(typeName) |
| if info is None: |
| name = "%s_retval" % (typeName.replace(" ", "_").replace("*", "star"),) |
| print("%s %s;" % (typeName, name), file=self.output) |
| if self.outputHeader: |
| print("extern %s %s;" % (typeName, name), file=self.outputHeader) |
| elif self.outputTests: |
| print("extern %s %s;" % (typeName, name), file=self.outputTests) |
| info = self.testReturnValues[typeName] = name |
| return info |
| |
| def getTestValuesArray(self, type): |
| typeName = self.getTypeName(type) |
| info = self.testValues.get(typeName) |
| if info is None: |
| name = "%s_values" % (typeName.replace(" ", "_").replace("*", "star"),) |
| print("static %s %s[] = {" % (typeName, name), file=self.outputTests) |
| length = 0 |
| for item in self.getTestValues(type): |
| print("\t%s," % (item,), file=self.outputTests) |
| length += 1 |
| print("};", file=self.outputTests) |
| info = self.testValues[typeName] = (name, length) |
| return info |
| |
| def getTestValues(self, t): |
| if isinstance(t, BuiltinType): |
| if t.name == "float": |
| for i in ["0.0", "-1.0", "1.0"]: |
| yield i + "f" |
| elif t.name == "double": |
| for i in ["0.0", "-1.0", "1.0"]: |
| yield i |
| elif t.name in ("void *"): |
| yield "(void*) 0" |
| yield "(void*) -1" |
| else: |
| yield "(%s) 0" % (t.name,) |
| yield "(%s) -1" % (t.name,) |
| yield "(%s) 1" % (t.name,) |
| elif isinstance(t, EnumType): |
| for i in range(0, len(t.enumerators)): |
| yield "enum%dval%d_%d" % (t.index, i, t.unique_id) |
| elif isinstance(t, RecordType): |
| nonPadding = [f for f in t.fields if not f.isPaddingBitField()] |
| |
| if not nonPadding: |
| yield "{ }" |
| return |
| |
| # FIXME: Use designated initializers to access non-first |
| # fields of unions. |
| if t.isUnion: |
| for v in self.getTestValues(nonPadding[0]): |
| yield "{ %s }" % v |
| return |
| |
| fieldValues = [list(v) for v in map(self.getTestValues, nonPadding)] |
| for i, values in enumerate(fieldValues): |
| for v in values: |
| elements = [random.choice(fv) for fv in fieldValues] |
| elements[i] = v |
| yield "{ %s }" % (", ".join(elements)) |
| |
| elif isinstance(t, ComplexType): |
| for t in self.getTestValues(t.elementType): |
| yield "%s + %s * 1i" % (t, t) |
| elif isinstance(t, ArrayType): |
| values = list(self.getTestValues(t.elementType)) |
| if not values: |
| yield "{ }" |
| for i in range(t.numElements): |
| for v in values: |
| elements = [random.choice(values) for i in range(t.numElements)] |
| elements[i] = v |
| yield "{ %s }" % (", ".join(elements)) |
| else: |
| raise NotImplementedError('Cannot make tests values of type: "%s"' % (t,)) |
| |
| def printSizeOfType(self, prefix, name, t, output=None, indent=2): |
| print( |
| '%*sprintf("%s: sizeof(%s) = %%ld\\n", (long)sizeof(%s));' |
| % (indent, "", prefix, name, name), |
| file=output, |
| ) |
| |
| def printAlignOfType(self, prefix, name, t, output=None, indent=2): |
| print( |
| '%*sprintf("%s: __alignof__(%s) = %%ld\\n", (long)__alignof__(%s));' |
| % (indent, "", prefix, name, name), |
| file=output, |
| ) |
| |
| def printOffsetsOfType(self, prefix, name, t, output=None, indent=2): |
| if isinstance(t, RecordType): |
| for i, f in enumerate(t.fields): |
| if f.isBitField(): |
| continue |
| fname = "field%d" % i |
| print( |
| '%*sprintf("%s: __builtin_offsetof(%s, %s) = %%ld\\n", (long)__builtin_offsetof(%s, %s));' |
| % (indent, "", prefix, name, fname, name, fname), |
| file=output, |
| ) |
| |
| def printValueOfType(self, prefix, name, t, output=None, indent=2): |
| if output is None: |
| output = self.output |
| if isinstance(t, BuiltinType): |
| value_expr = name |
| if t.name.split(" ")[-1] == "_Bool": |
| # Hack to work around PR5579. |
| value_expr = "%s ? 2 : 0" % name |
| |
| if t.name.endswith("long long"): |
| code = "lld" |
| elif t.name.endswith("long"): |
| code = "ld" |
| elif t.name.split(" ")[-1] in ("_Bool", "char", "short", "int", "unsigned"): |
| code = "d" |
| elif t.name in ("float", "double"): |
| code = "f" |
| elif t.name == "long double": |
| code = "Lf" |
| else: |
| code = "p" |
| print( |
| '%*sprintf("%s: %s = %%%s\\n", %s);' |
| % (indent, "", prefix, name, code, value_expr), |
| file=output, |
| ) |
| elif isinstance(t, EnumType): |
| print( |
| '%*sprintf("%s: %s = %%d\\n", %s);' % (indent, "", prefix, name, name), |
| file=output, |
| ) |
| elif isinstance(t, RecordType): |
| if not t.fields: |
| print( |
| '%*sprintf("%s: %s (empty)\\n");' % (indent, "", prefix, name), |
| file=output, |
| ) |
| for i, f in enumerate(t.fields): |
| if f.isPaddingBitField(): |
| continue |
| fname = "%s.field%d" % (name, i) |
| self.printValueOfType(prefix, fname, f, output=output, indent=indent) |
| elif isinstance(t, ComplexType): |
| self.printValueOfType( |
| prefix, |
| "(__real %s)" % name, |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| self.printValueOfType( |
| prefix, |
| "(__imag %s)" % name, |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| elif isinstance(t, ArrayType): |
| for i in range(t.numElements): |
| # Access in this fashion as a hackish way to portably |
| # access vectors. |
| if t.isVector: |
| self.printValueOfType( |
| prefix, |
| "((%s*) &%s)[%d]" % (t.elementType, name, i), |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| else: |
| self.printValueOfType( |
| prefix, |
| "%s[%d]" % (name, i), |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| else: |
| raise NotImplementedError('Cannot print value of type: "%s"' % (t,)) |
| |
| def checkTypeValues(self, nameLHS, nameRHS, t, output=None, indent=2): |
| prefix = "foo" |
| if output is None: |
| output = self.output |
| if isinstance(t, BuiltinType): |
| print("%*sassert(%s == %s);" % (indent, "", nameLHS, nameRHS), file=output) |
| elif isinstance(t, EnumType): |
| print("%*sassert(%s == %s);" % (indent, "", nameLHS, nameRHS), file=output) |
| elif isinstance(t, RecordType): |
| for i, f in enumerate(t.fields): |
| if f.isPaddingBitField(): |
| continue |
| self.checkTypeValues( |
| "%s.field%d" % (nameLHS, i), |
| "%s.field%d" % (nameRHS, i), |
| f, |
| output=output, |
| indent=indent, |
| ) |
| if t.isUnion: |
| break |
| elif isinstance(t, ComplexType): |
| self.checkTypeValues( |
| "(__real %s)" % nameLHS, |
| "(__real %s)" % nameRHS, |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| self.checkTypeValues( |
| "(__imag %s)" % nameLHS, |
| "(__imag %s)" % nameRHS, |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| elif isinstance(t, ArrayType): |
| for i in range(t.numElements): |
| # Access in this fashion as a hackish way to portably |
| # access vectors. |
| if t.isVector: |
| self.checkTypeValues( |
| "((%s*) &%s)[%d]" % (t.elementType, nameLHS, i), |
| "((%s*) &%s)[%d]" % (t.elementType, nameRHS, i), |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| else: |
| self.checkTypeValues( |
| "%s[%d]" % (nameLHS, i), |
| "%s[%d]" % (nameRHS, i), |
| t.elementType, |
| output=output, |
| indent=indent, |
| ) |
| else: |
| raise NotImplementedError('Cannot print value of type: "%s"' % (t,)) |
| |
| |
| import sys |
| |
| |
| def main(): |
| from optparse import OptionParser, OptionGroup |
| |
| parser = OptionParser("%prog [options] {indices}") |
| parser.add_option( |
| "", |
| "--mode", |
| dest="mode", |
| help="autogeneration mode (random or linear) [default %default]", |
| type="choice", |
| choices=("random", "linear"), |
| default="linear", |
| ) |
| parser.add_option( |
| "", |
| "--count", |
| dest="count", |
| help="autogenerate COUNT functions according to MODE", |
| type=int, |
| default=0, |
| ) |
| parser.add_option( |
| "", |
| "--min", |
| dest="minIndex", |
| metavar="N", |
| help="start autogeneration with the Nth function type [default %default]", |
| type=int, |
| default=0, |
| ) |
| parser.add_option( |
| "", |
| "--max", |
| dest="maxIndex", |
| metavar="N", |
| help="maximum index for random autogeneration [default %default]", |
| type=int, |
| default=10000000, |
| ) |
| parser.add_option( |
| "", |
| "--seed", |
| dest="seed", |
| help="random number generator seed [default %default]", |
| type=int, |
| default=1, |
| ) |
| parser.add_option( |
| "", |
| "--use-random-seed", |
| dest="useRandomSeed", |
| help="use random value for initial random number generator seed", |
| action="store_true", |
| default=False, |
| ) |
| parser.add_option( |
| "", |
| "--skip", |
| dest="skipTests", |
| help="add a test index to skip", |
| type=int, |
| action="append", |
| default=[], |
| ) |
| parser.add_option( |
| "-o", |
| "--output", |
| dest="output", |
| metavar="FILE", |
| help="write output to FILE [default %default]", |
| type=str, |
| default="-", |
| ) |
| parser.add_option( |
| "-O", |
| "--output-header", |
| dest="outputHeader", |
| metavar="FILE", |
| help="write header file for output to FILE [default %default]", |
| type=str, |
| default=None, |
| ) |
| parser.add_option( |
| "-T", |
| "--output-tests", |
| dest="outputTests", |
| metavar="FILE", |
| help="write function tests to FILE [default %default]", |
| type=str, |
| default=None, |
| ) |
| parser.add_option( |
| "-D", |
| "--output-driver", |
| dest="outputDriver", |
| metavar="FILE", |
| help="write test driver to FILE [default %default]", |
| type=str, |
| default=None, |
| ) |
| parser.add_option( |
| "", |
| "--test-layout", |
| dest="testLayout", |
| metavar="FILE", |
| help="test structure layout", |
| action="store_true", |
| default=False, |
| ) |
| |
| group = OptionGroup(parser, "Type Enumeration Options") |
| # Builtins - Ints |
| group.add_option( |
| "", |
| "--no-char", |
| dest="useChar", |
| help="do not generate char types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-short", |
| dest="useShort", |
| help="do not generate short types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-int", |
| dest="useInt", |
| help="do not generate int types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-long", |
| dest="useLong", |
| help="do not generate long types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-long-long", |
| dest="useLongLong", |
| help="do not generate long long types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-unsigned", |
| dest="useUnsigned", |
| help="do not generate unsigned integer types", |
| action="store_false", |
| default=True, |
| ) |
| |
| # Other builtins |
| group.add_option( |
| "", |
| "--no-bool", |
| dest="useBool", |
| help="do not generate bool types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-float", |
| dest="useFloat", |
| help="do not generate float types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-double", |
| dest="useDouble", |
| help="do not generate double types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-long-double", |
| dest="useLongDouble", |
| help="do not generate long double types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-void-pointer", |
| dest="useVoidPointer", |
| help="do not generate void* types", |
| action="store_false", |
| default=True, |
| ) |
| |
| # Enumerations |
| group.add_option( |
| "", |
| "--no-enums", |
| dest="useEnum", |
| help="do not generate enum types", |
| action="store_false", |
| default=True, |
| ) |
| |
| # Derived types |
| group.add_option( |
| "", |
| "--no-array", |
| dest="useArray", |
| help="do not generate record types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-complex", |
| dest="useComplex", |
| help="do not generate complex types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-record", |
| dest="useRecord", |
| help="do not generate record types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-union", |
| dest="recordUseUnion", |
| help="do not generate union types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-vector", |
| dest="useVector", |
| help="do not generate vector types", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-bit-field", |
| dest="useBitField", |
| help="do not generate bit-field record members", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--no-builtins", |
| dest="useBuiltins", |
| help="do not use any types", |
| action="store_false", |
| default=True, |
| ) |
| |
| # Tuning |
| group.add_option( |
| "", |
| "--no-function-return", |
| dest="functionUseReturn", |
| help="do not generate return types for functions", |
| action="store_false", |
| default=True, |
| ) |
| group.add_option( |
| "", |
| "--vector-types", |
| dest="vectorTypes", |
| help="comma separated list of vector types (e.g., v2i32) [default %default]", |
| action="store", |
| type=str, |
| default="v2i16, v1i64, v2i32, v4i16, v8i8, v2f32, v2i64, v4i32, v8i16, v16i8, v2f64, v4f32, v16f32", |
| metavar="N", |
| ) |
| group.add_option( |
| "", |
| "--bit-fields", |
| dest="bitFields", |
| help="comma separated list 'type:width' bit-field specifiers [default %default]", |
| action="store", |
| type=str, |
| default=("char:0,char:4,int:0,unsigned:1,int:1,int:4,int:13,int:24"), |
| ) |
| group.add_option( |
| "", |
| "--max-args", |
| dest="functionMaxArgs", |
| help="maximum number of arguments per function [default %default]", |
| action="store", |
| type=int, |
| default=4, |
| metavar="N", |
| ) |
| group.add_option( |
| "", |
| "--max-array", |
| dest="arrayMaxSize", |
| help="maximum array size [default %default]", |
| action="store", |
| type=int, |
| default=4, |
| metavar="N", |
| ) |
| group.add_option( |
| "", |
| "--max-record", |
| dest="recordMaxSize", |
| help="maximum number of fields per record [default %default]", |
| action="store", |
| type=int, |
| default=4, |
| metavar="N", |
| ) |
| group.add_option( |
| "", |
| "--max-record-depth", |
| dest="recordMaxDepth", |
| help="maximum nested structure depth [default %default]", |
| action="store", |
| type=int, |
| default=None, |
| metavar="N", |
| ) |
| parser.add_option_group(group) |
| (opts, args) = parser.parse_args() |
| |
| if not opts.useRandomSeed: |
| random.seed(opts.seed) |
| |
| # Construct type generator |
| builtins = [] |
| if opts.useBuiltins: |
| ints = [] |
| if opts.useChar: |
| ints.append(("char", 1)) |
| if opts.useShort: |
| ints.append(("short", 2)) |
| if opts.useInt: |
| ints.append(("int", 4)) |
| # FIXME: Wrong size. |
| if opts.useLong: |
| ints.append(("long", 4)) |
| if opts.useLongLong: |
| ints.append(("long long", 8)) |
| if opts.useUnsigned: |
| ints = [("unsigned %s" % i, s) for i, s in ints] + [ |
| ("signed %s" % i, s) for i, s in ints |
| ] |
| builtins.extend(ints) |
| |
| if opts.useBool: |
| builtins.append(("_Bool", 1)) |
| if opts.useFloat: |
| builtins.append(("float", 4)) |
| if opts.useDouble: |
| builtins.append(("double", 8)) |
| if opts.useLongDouble: |
| builtins.append(("long double", 16)) |
| # FIXME: Wrong size. |
| if opts.useVoidPointer: |
| builtins.append(("void*", 4)) |
| |
| btg = FixedTypeGenerator([BuiltinType(n, s) for n, s in builtins]) |
| |
| bitfields = [] |
| for specifier in opts.bitFields.split(","): |
| if not specifier.strip(): |
| continue |
| name, width = specifier.strip().split(":", 1) |
| bitfields.append(BuiltinType(name, None, int(width))) |
| bftg = FixedTypeGenerator(bitfields) |
| |
| charType = BuiltinType("char", 1) |
| shortType = BuiltinType("short", 2) |
| intType = BuiltinType("int", 4) |
| longlongType = BuiltinType("long long", 8) |
| floatType = BuiltinType("float", 4) |
| doubleType = BuiltinType("double", 8) |
| sbtg = FixedTypeGenerator([charType, intType, floatType, doubleType]) |
| |
| atg = AnyTypeGenerator() |
| artg = AnyTypeGenerator() |
| |
| def makeGenerator(atg, subgen, subfieldgen, useRecord, useArray, useBitField): |
| atg.addGenerator(btg) |
| if useBitField and opts.useBitField: |
| atg.addGenerator(bftg) |
| if useRecord and opts.useRecord: |
| assert subgen |
| atg.addGenerator( |
| RecordTypeGenerator( |
| subfieldgen, opts.recordUseUnion, opts.recordMaxSize |
| ) |
| ) |
| if opts.useComplex: |
| # FIXME: Allow overriding builtins here |
| atg.addGenerator(ComplexTypeGenerator(sbtg)) |
| if useArray and opts.useArray: |
| assert subgen |
| atg.addGenerator(ArrayTypeGenerator(subgen, opts.arrayMaxSize)) |
| if opts.useVector: |
| vTypes = [] |
| for i, t in enumerate(opts.vectorTypes.split(",")): |
| m = re.match("v([1-9][0-9]*)([if][1-9][0-9]*)", t.strip()) |
| if not m: |
| parser.error("Invalid vector type: %r" % t) |
| count, kind = m.groups() |
| count = int(count) |
| type = { |
| "i8": charType, |
| "i16": shortType, |
| "i32": intType, |
| "i64": longlongType, |
| "f32": floatType, |
| "f64": doubleType, |
| }.get(kind) |
| if not type: |
| parser.error("Invalid vector type: %r" % t) |
| vTypes.append(ArrayType(i, True, type, count * type.size)) |
| |
| atg.addGenerator(FixedTypeGenerator(vTypes)) |
| if opts.useEnum: |
| atg.addGenerator(EnumTypeGenerator([None, "-1", "1", "1u"], 1, 4)) |
| |
| if opts.recordMaxDepth is None: |
| # Fully recursive, just avoid top-level arrays. |
| subFTG = AnyTypeGenerator() |
| subTG = AnyTypeGenerator() |
| atg = AnyTypeGenerator() |
| makeGenerator(subFTG, atg, atg, True, True, True) |
| makeGenerator(subTG, atg, subFTG, True, True, False) |
| makeGenerator(atg, subTG, subFTG, True, False, False) |
| else: |
| # Make a chain of type generators, each builds smaller |
| # structures. |
| base = AnyTypeGenerator() |
| fbase = AnyTypeGenerator() |
| makeGenerator(base, None, None, False, False, False) |
| makeGenerator(fbase, None, None, False, False, True) |
| for i in range(opts.recordMaxDepth): |
| n = AnyTypeGenerator() |
| fn = AnyTypeGenerator() |
| makeGenerator(n, base, fbase, True, True, False) |
| makeGenerator(fn, base, fbase, True, True, True) |
| base = n |
| fbase = fn |
| atg = AnyTypeGenerator() |
| makeGenerator(atg, base, fbase, True, False, False) |
| |
| if opts.testLayout: |
| ftg = atg |
| else: |
| ftg = FunctionTypeGenerator(atg, opts.functionUseReturn, opts.functionMaxArgs) |
| |
| # Override max,min,count if finite |
| if opts.maxIndex is None: |
| if ftg.cardinality is aleph0: |
| opts.maxIndex = 10000000 |
| else: |
| opts.maxIndex = ftg.cardinality |
| opts.maxIndex = min(opts.maxIndex, ftg.cardinality) |
| opts.minIndex = max(0, min(opts.maxIndex - 1, opts.minIndex)) |
| if not opts.mode == "random": |
| opts.count = min(opts.count, opts.maxIndex - opts.minIndex) |
| |
| if opts.output == "-": |
| output = sys.stdout |
| else: |
| output = open(opts.output, "w") |
| atexit.register(lambda: output.close()) |
| |
| outputHeader = None |
| if opts.outputHeader: |
| outputHeader = open(opts.outputHeader, "w") |
| atexit.register(lambda: outputHeader.close()) |
| |
| outputTests = None |
| if opts.outputTests: |
| outputTests = open(opts.outputTests, "w") |
| atexit.register(lambda: outputTests.close()) |
| |
| outputDriver = None |
| if opts.outputDriver: |
| outputDriver = open(opts.outputDriver, "w") |
| atexit.register(lambda: outputDriver.close()) |
| |
| info = "" |
| info += "// %s\n" % (" ".join(sys.argv),) |
| info += "// Generated: %s\n" % (time.strftime("%Y-%m-%d %H:%M"),) |
| info += "// Cardinality of function generator: %s\n" % (ftg.cardinality,) |
| info += "// Cardinality of type generator: %s\n" % (atg.cardinality,) |
| |
| if opts.testLayout: |
| info += "\n#include <stdio.h>" |
| |
| P = TypePrinter( |
| output, |
| outputHeader=outputHeader, |
| outputTests=outputTests, |
| outputDriver=outputDriver, |
| headerName=opts.outputHeader, |
| info=info, |
| ) |
| |
| def write(N): |
| try: |
| FT = ftg.get(N) |
| except RuntimeError as e: |
| if e.args[0] == "maximum recursion depth exceeded": |
| print( |
| "WARNING: Skipped %d, recursion limit exceeded (bad arguments?)" |
| % (N,), |
| file=sys.stderr, |
| ) |
| return |
| raise |
| if opts.testLayout: |
| P.writeLayoutTest(N, FT) |
| else: |
| P.writeFunction(N, FT) |
| |
| if args: |
| [write(int(a)) for a in args] |
| |
| skipTests = set(opts.skipTests) |
| for i in range(opts.count): |
| if opts.mode == "linear": |
| index = opts.minIndex + i |
| else: |
| index = opts.minIndex + int( |
| (opts.maxIndex - opts.minIndex) * random.random() |
| ) |
| if index in skipTests: |
| continue |
| write(index) |
| |
| P.finish() |
| |
| |
| if __name__ == "__main__": |
| main() |
