#!/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()