1#!/usr/bin/env python
2
3from pprint import pprint
4import random, atexit, time
5from random import randrange
6import re
7
8from Enumeration import *
9from TypeGen import *
10
11####
12
13class TypePrinter:
14    def __init__(self, output, outputHeader=None,
15                 outputTests=None, outputDriver=None,
16                 headerName=None, info=None):
17        self.output = output
18        self.outputHeader = outputHeader
19        self.outputTests = outputTests
20        self.outputDriver = outputDriver
21        self.writeBody = outputHeader or outputTests or outputDriver
22        self.types = {}
23        self.testValues = {}
24        self.testReturnValues = {}
25        self.layoutTests = []
26        self.declarations = set()
27
28        if info:
29            for f in (self.output,self.outputHeader,self.outputTests,self.outputDriver):
30                if f:
31                    print >>f,info
32
33        if self.writeBody:
34            print >>self.output, '#include <stdio.h>\n'
35            if self.outputTests:
36                print >>self.outputTests, '#include <stdio.h>'
37                print >>self.outputTests, '#include <string.h>'
38                print >>self.outputTests, '#include <assert.h>\n'
39
40        if headerName:
41            for f in (self.output,self.outputTests,self.outputDriver):
42                if f is not None:
43                    print >>f, '#include "%s"\n'%(headerName,)
44
45        if self.outputDriver:
46            print >>self.outputDriver, '#include <stdio.h>'
47            print >>self.outputDriver, '#include <stdlib.h>\n'
48            print >>self.outputDriver, 'int main(int argc, char **argv) {'
49            print >>self.outputDriver, '  int index = -1;'
50            print >>self.outputDriver, '  if (argc > 1) index = atoi(argv[1]);'
51
52    def finish(self):
53        if self.layoutTests:
54            print >>self.output, 'int main(int argc, char **argv) {'
55            print >>self.output, '  int index = -1;'
56            print >>self.output, '  if (argc > 1) index = atoi(argv[1]);'
57            for i,f in self.layoutTests:
58                print >>self.output, '  if (index == -1 || index == %d)' % i
59                print >>self.output, '    %s();' % f
60            print >>self.output, '  return 0;'
61            print >>self.output, '}'
62
63        if self.outputDriver:
64            print >>self.outputDriver, '  printf("DONE\\n");'
65            print >>self.outputDriver, '  return 0;'
66            print >>self.outputDriver, '}'
67
68    def addDeclaration(self, decl):
69        if decl in self.declarations:
70            return False
71
72        self.declarations.add(decl)
73        if self.outputHeader:
74            print >>self.outputHeader, decl
75        else:
76            print >>self.output, decl
77            if self.outputTests:
78                print >>self.outputTests, decl
79        return True
80
81    def getTypeName(self, T):
82        name = self.types.get(T)
83        if name is None:
84            # Reserve slot
85            self.types[T] = None
86            self.types[T] = name = T.getTypeName(self)
87        return name
88
89    def writeLayoutTest(self, i, ty):
90        tyName = self.getTypeName(ty)
91        tyNameClean = tyName.replace(' ','_').replace('*','star')
92        fnName = 'test_%s' % tyNameClean
93
94        print >>self.output,'void %s(void) {' % fnName
95        self.printSizeOfType('    %s'%fnName, tyName, ty, self.output)
96        self.printAlignOfType('    %s'%fnName, tyName, ty, self.output)
97        self.printOffsetsOfType('    %s'%fnName, tyName, ty, self.output)
98        print >>self.output,'}'
99        print >>self.output
100
101        self.layoutTests.append((i,fnName))
102
103    def writeFunction(self, i, FT):
104        args = ', '.join(['%s arg%d'%(self.getTypeName(t),i) for i,t in enumerate(FT.argTypes)])
105        if not args:
106            args = 'void'
107
108        if FT.returnType is None:
109            retvalName = None
110            retvalTypeName = 'void'
111        else:
112            retvalTypeName = self.getTypeName(FT.returnType)
113            if self.writeBody or self.outputTests:
114                retvalName = self.getTestReturnValue(FT.returnType)
115
116        fnName = 'fn%d'%(FT.index,)
117        if self.outputHeader:
118            print >>self.outputHeader,'%s %s(%s);'%(retvalTypeName, fnName, args)
119        elif self.outputTests:
120            print >>self.outputTests,'%s %s(%s);'%(retvalTypeName, fnName, args)
121
122        print >>self.output,'%s %s(%s)'%(retvalTypeName, fnName, args),
123        if self.writeBody:
124            print >>self.output, '{'
125
126            for i,t in enumerate(FT.argTypes):
127                self.printValueOfType('    %s'%fnName, 'arg%d'%i, t)
128
129            if retvalName is not None:
130                print >>self.output, '  return %s;'%(retvalName,)
131            print >>self.output, '}'
132        else:
133            print >>self.output, '{}'
134        print >>self.output
135
136        if self.outputDriver:
137            print >>self.outputDriver, '  if (index == -1 || index == %d) {' % i
138            print >>self.outputDriver, '    extern void test_%s(void);' % fnName
139            print >>self.outputDriver, '    test_%s();' % fnName
140            print >>self.outputDriver, '   }'
141
142        if self.outputTests:
143            if self.outputHeader:
144                print >>self.outputHeader, 'void test_%s(void);'%(fnName,)
145
146            if retvalName is None:
147                retvalTests = None
148            else:
149                retvalTests = self.getTestValuesArray(FT.returnType)
150            tests = map(self.getTestValuesArray, FT.argTypes)
151            print >>self.outputTests, 'void test_%s(void) {'%(fnName,)
152
153            if retvalTests is not None:
154                print >>self.outputTests, '  printf("%s: testing return.\\n");'%(fnName,)
155                print >>self.outputTests, '  for (int i=0; i<%d; ++i) {'%(retvalTests[1],)
156                args = ', '.join(['%s[%d]'%(t,randrange(l)) for t,l in tests])
157                print >>self.outputTests, '    %s RV;'%(retvalTypeName,)
158                print >>self.outputTests, '    %s = %s[i];'%(retvalName, retvalTests[0])
159                print >>self.outputTests, '    RV = %s(%s);'%(fnName, args)
160                self.printValueOfType('  %s_RV'%fnName, 'RV', FT.returnType, output=self.outputTests, indent=4)
161                self.checkTypeValues('RV', '%s[i]' % retvalTests[0], FT.returnType, output=self.outputTests, indent=4)
162                print >>self.outputTests, '  }'
163
164            if tests:
165                print >>self.outputTests, '  printf("%s: testing arguments.\\n");'%(fnName,)
166            for i,(array,length) in enumerate(tests):
167                for j in range(length):
168                    args = ['%s[%d]'%(t,randrange(l)) for t,l in tests]
169                    args[i] = '%s[%d]'%(array,j)
170                    print >>self.outputTests, '  %s(%s);'%(fnName, ', '.join(args),)
171            print >>self.outputTests, '}'
172
173    def getTestReturnValue(self, type):
174        typeName = self.getTypeName(type)
175        info = self.testReturnValues.get(typeName)
176        if info is None:
177            name = '%s_retval'%(typeName.replace(' ','_').replace('*','star'),)
178            print >>self.output, '%s %s;'%(typeName,name)
179            if self.outputHeader:
180                print >>self.outputHeader, 'extern %s %s;'%(typeName,name)
181            elif self.outputTests:
182                print >>self.outputTests, 'extern %s %s;'%(typeName,name)
183            info = self.testReturnValues[typeName] = name
184        return info
185
186    def getTestValuesArray(self, type):
187        typeName = self.getTypeName(type)
188        info = self.testValues.get(typeName)
189        if info is None:
190            name = '%s_values'%(typeName.replace(' ','_').replace('*','star'),)
191            print >>self.outputTests, 'static %s %s[] = {'%(typeName,name)
192            length = 0
193            for item in self.getTestValues(type):
194                print >>self.outputTests, '\t%s,'%(item,)
195                length += 1
196            print >>self.outputTests,'};'
197            info = self.testValues[typeName] = (name,length)
198        return info
199
200    def getTestValues(self, t):
201        if isinstance(t, BuiltinType):
202            if t.name=='float':
203                for i in ['0.0','-1.0','1.0']:
204                    yield i+'f'
205            elif t.name=='double':
206                for i in ['0.0','-1.0','1.0']:
207                    yield i
208            elif t.name in ('void *'):
209                yield '(void*) 0'
210                yield '(void*) -1'
211            else:
212                yield '(%s) 0'%(t.name,)
213                yield '(%s) -1'%(t.name,)
214                yield '(%s) 1'%(t.name,)
215        elif isinstance(t, EnumType):
216            for i in range(0, len(t.enumerators)):
217                yield 'enum%dval%d_%d' % (t.index, i, t.unique_id)
218        elif isinstance(t, RecordType):
219            nonPadding = [f for f in t.fields
220                          if not f.isPaddingBitField()]
221
222            if not nonPadding:
223                yield '{ }'
224                return
225
226            # FIXME: Use designated initializers to access non-first
227            # fields of unions.
228            if t.isUnion:
229                for v in self.getTestValues(nonPadding[0]):
230                    yield '{ %s }' % v
231                return
232
233            fieldValues = map(list, map(self.getTestValues, nonPadding))
234            for i,values in enumerate(fieldValues):
235                for v in values:
236                    elements = map(random.choice,fieldValues)
237                    elements[i] = v
238                    yield '{ %s }'%(', '.join(elements))
239
240        elif isinstance(t, ComplexType):
241            for t in self.getTestValues(t.elementType):
242                yield '%s + %s * 1i'%(t,t)
243        elif isinstance(t, ArrayType):
244            values = list(self.getTestValues(t.elementType))
245            if not values:
246                yield '{ }'
247            for i in range(t.numElements):
248                for v in values:
249                    elements = [random.choice(values) for i in range(t.numElements)]
250                    elements[i] = v
251                    yield '{ %s }'%(', '.join(elements))
252        else:
253            raise NotImplementedError,'Cannot make tests values of type: "%s"'%(t,)
254
255    def printSizeOfType(self, prefix, name, t, output=None, indent=2):
256        print >>output, '%*sprintf("%s: sizeof(%s) = %%ld\\n", (long)sizeof(%s));'%(indent, '', prefix, name, name)
257    def printAlignOfType(self, prefix, name, t, output=None, indent=2):
258        print >>output, '%*sprintf("%s: __alignof__(%s) = %%ld\\n", (long)__alignof__(%s));'%(indent, '', prefix, name, name)
259    def printOffsetsOfType(self, prefix, name, t, output=None, indent=2):
260        if isinstance(t, RecordType):
261            for i,f in enumerate(t.fields):
262                if f.isBitField():
263                    continue
264                fname = 'field%d' % i
265                print >>output, '%*sprintf("%s: __builtin_offsetof(%s, %s) = %%ld\\n", (long)__builtin_offsetof(%s, %s));'%(indent, '', prefix, name, fname, name, fname)
266
267    def printValueOfType(self, prefix, name, t, output=None, indent=2):
268        if output is None:
269            output = self.output
270        if isinstance(t, BuiltinType):
271            value_expr = name
272            if t.name.split(' ')[-1] == '_Bool':
273                # Hack to work around PR5579.
274                value_expr = "%s ? 2 : 0" % name
275
276            if t.name.endswith('long long'):
277                code = 'lld'
278            elif t.name.endswith('long'):
279                code = 'ld'
280            elif t.name.split(' ')[-1] in ('_Bool','char','short',
281                                           'int','unsigned'):
282                code = 'd'
283            elif t.name in ('float','double'):
284                code = 'f'
285            elif t.name == 'long double':
286                code = 'Lf'
287            else:
288                code = 'p'
289            print >>output, '%*sprintf("%s: %s = %%%s\\n", %s);'%(
290                indent, '', prefix, name, code, value_expr)
291        elif isinstance(t, EnumType):
292            print >>output, '%*sprintf("%s: %s = %%d\\n", %s);'%(indent, '', prefix, name, name)
293        elif isinstance(t, RecordType):
294            if not t.fields:
295                print >>output, '%*sprintf("%s: %s (empty)\\n");'%(indent, '', prefix, name)
296            for i,f in enumerate(t.fields):
297                if f.isPaddingBitField():
298                    continue
299                fname = '%s.field%d'%(name,i)
300                self.printValueOfType(prefix, fname, f, output=output, indent=indent)
301        elif isinstance(t, ComplexType):
302            self.printValueOfType(prefix, '(__real %s)'%name, t.elementType, output=output,indent=indent)
303            self.printValueOfType(prefix, '(__imag %s)'%name, t.elementType, output=output,indent=indent)
304        elif isinstance(t, ArrayType):
305            for i in range(t.numElements):
306                # Access in this fashion as a hackish way to portably
307                # access vectors.
308                if t.isVector:
309                    self.printValueOfType(prefix, '((%s*) &%s)[%d]'%(t.elementType,name,i), t.elementType, output=output,indent=indent)
310                else:
311                    self.printValueOfType(prefix, '%s[%d]'%(name,i), t.elementType, output=output,indent=indent)
312        else:
313            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
314
315    def checkTypeValues(self, nameLHS, nameRHS, t, output=None, indent=2):
316        prefix = 'foo'
317        if output is None:
318            output = self.output
319        if isinstance(t, BuiltinType):
320            print >>output, '%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS)
321        elif isinstance(t, EnumType):
322            print >>output, '%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS)
323        elif isinstance(t, RecordType):
324            for i,f in enumerate(t.fields):
325                if f.isPaddingBitField():
326                    continue
327                self.checkTypeValues('%s.field%d'%(nameLHS,i), '%s.field%d'%(nameRHS,i),
328                                     f, output=output, indent=indent)
329                if t.isUnion:
330                    break
331        elif isinstance(t, ComplexType):
332            self.checkTypeValues('(__real %s)'%nameLHS, '(__real %s)'%nameRHS, t.elementType, output=output,indent=indent)
333            self.checkTypeValues('(__imag %s)'%nameLHS, '(__imag %s)'%nameRHS, t.elementType, output=output,indent=indent)
334        elif isinstance(t, ArrayType):
335            for i in range(t.numElements):
336                # Access in this fashion as a hackish way to portably
337                # access vectors.
338                if t.isVector:
339                    self.checkTypeValues('((%s*) &%s)[%d]'%(t.elementType,nameLHS,i),
340                                         '((%s*) &%s)[%d]'%(t.elementType,nameRHS,i),
341                                         t.elementType, output=output,indent=indent)
342                else:
343                    self.checkTypeValues('%s[%d]'%(nameLHS,i), '%s[%d]'%(nameRHS,i),
344                                         t.elementType, output=output,indent=indent)
345        else:
346            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
347
348import sys
349
350def main():
351    from optparse import OptionParser, OptionGroup
352    parser = OptionParser("%prog [options] {indices}")
353    parser.add_option("", "--mode", dest="mode",
354                      help="autogeneration mode (random or linear) [default %default]",
355                      type='choice', choices=('random','linear'), default='linear')
356    parser.add_option("", "--count", dest="count",
357                      help="autogenerate COUNT functions according to MODE",
358                      type=int, default=0)
359    parser.add_option("", "--min", dest="minIndex", metavar="N",
360                      help="start autogeneration with the Nth function type  [default %default]",
361                      type=int, default=0)
362    parser.add_option("", "--max", dest="maxIndex", metavar="N",
363                      help="maximum index for random autogeneration  [default %default]",
364                      type=int, default=10000000)
365    parser.add_option("", "--seed", dest="seed",
366                      help="random number generator seed [default %default]",
367                      type=int, default=1)
368    parser.add_option("", "--use-random-seed", dest="useRandomSeed",
369                      help="use random value for initial random number generator seed",
370                      action='store_true', default=False)
371    parser.add_option("", "--skip", dest="skipTests",
372                      help="add a test index to skip",
373                      type=int, action='append', default=[])
374    parser.add_option("-o", "--output", dest="output", metavar="FILE",
375                      help="write output to FILE  [default %default]",
376                      type=str, default='-')
377    parser.add_option("-O", "--output-header", dest="outputHeader", metavar="FILE",
378                      help="write header file for output to FILE  [default %default]",
379                      type=str, default=None)
380    parser.add_option("-T", "--output-tests", dest="outputTests", metavar="FILE",
381                      help="write function tests to FILE  [default %default]",
382                      type=str, default=None)
383    parser.add_option("-D", "--output-driver", dest="outputDriver", metavar="FILE",
384                      help="write test driver to FILE  [default %default]",
385                      type=str, default=None)
386    parser.add_option("", "--test-layout", dest="testLayout", metavar="FILE",
387                      help="test structure layout",
388                      action='store_true', default=False)
389
390    group = OptionGroup(parser, "Type Enumeration Options")
391    # Builtins - Ints
392    group.add_option("", "--no-char", dest="useChar",
393                     help="do not generate char types",
394                     action="store_false", default=True)
395    group.add_option("", "--no-short", dest="useShort",
396                     help="do not generate short types",
397                     action="store_false", default=True)
398    group.add_option("", "--no-int", dest="useInt",
399                     help="do not generate int types",
400                     action="store_false", default=True)
401    group.add_option("", "--no-long", dest="useLong",
402                     help="do not generate long types",
403                     action="store_false", default=True)
404    group.add_option("", "--no-long-long", dest="useLongLong",
405                     help="do not generate long long types",
406                     action="store_false", default=True)
407    group.add_option("", "--no-unsigned", dest="useUnsigned",
408                     help="do not generate unsigned integer types",
409                     action="store_false", default=True)
410
411    # Other builtins
412    group.add_option("", "--no-bool", dest="useBool",
413                     help="do not generate bool types",
414                     action="store_false", default=True)
415    group.add_option("", "--no-float", dest="useFloat",
416                     help="do not generate float types",
417                     action="store_false", default=True)
418    group.add_option("", "--no-double", dest="useDouble",
419                     help="do not generate double types",
420                     action="store_false", default=True)
421    group.add_option("", "--no-long-double", dest="useLongDouble",
422                     help="do not generate long double types",
423                     action="store_false", default=True)
424    group.add_option("", "--no-void-pointer", dest="useVoidPointer",
425                     help="do not generate void* types",
426                     action="store_false", default=True)
427
428    # Enumerations
429    group.add_option("", "--no-enums", dest="useEnum",
430                     help="do not generate enum types",
431                     action="store_false", default=True)
432
433    # Derived types
434    group.add_option("", "--no-array", dest="useArray",
435                     help="do not generate record types",
436                     action="store_false", default=True)
437    group.add_option("", "--no-complex", dest="useComplex",
438                     help="do not generate complex types",
439                     action="store_false", default=True)
440    group.add_option("", "--no-record", dest="useRecord",
441                     help="do not generate record types",
442                     action="store_false", default=True)
443    group.add_option("", "--no-union", dest="recordUseUnion",
444                     help="do not generate union types",
445                     action="store_false", default=True)
446    group.add_option("", "--no-vector", dest="useVector",
447                     help="do not generate vector types",
448                     action="store_false", default=True)
449    group.add_option("", "--no-bit-field", dest="useBitField",
450                     help="do not generate bit-field record members",
451                     action="store_false", default=True)
452    group.add_option("", "--no-builtins", dest="useBuiltins",
453                     help="do not use any types",
454                     action="store_false", default=True)
455
456    # Tuning
457    group.add_option("", "--no-function-return", dest="functionUseReturn",
458                     help="do not generate return types for functions",
459                     action="store_false", default=True)
460    group.add_option("", "--vector-types", dest="vectorTypes",
461                     help="comma separated list of vector types (e.g., v2i32) [default %default]",
462                     action="store", type=str, default='v2i16, v1i64, v2i32, v4i16, v8i8, v2f32, v2i64, v4i32, v8i16, v16i8, v2f64, v4f32, v16f32', metavar="N")
463    group.add_option("", "--bit-fields", dest="bitFields",
464                     help="comma separated list 'type:width' bit-field specifiers [default %default]",
465                     action="store", type=str, default=(
466            "char:0,char:4,int:0,unsigned:1,int:1,int:4,int:13,int:24"))
467    group.add_option("", "--max-args", dest="functionMaxArgs",
468                     help="maximum number of arguments per function [default %default]",
469                     action="store", type=int, default=4, metavar="N")
470    group.add_option("", "--max-array", dest="arrayMaxSize",
471                     help="maximum array size [default %default]",
472                     action="store", type=int, default=4, metavar="N")
473    group.add_option("", "--max-record", dest="recordMaxSize",
474                     help="maximum number of fields per record [default %default]",
475                     action="store", type=int, default=4, metavar="N")
476    group.add_option("", "--max-record-depth", dest="recordMaxDepth",
477                     help="maximum nested structure depth [default %default]",
478                     action="store", type=int, default=None, metavar="N")
479    parser.add_option_group(group)
480    (opts, args) = parser.parse_args()
481
482    if not opts.useRandomSeed:
483        random.seed(opts.seed)
484
485    # Construct type generator
486    builtins = []
487    if opts.useBuiltins:
488        ints = []
489        if opts.useChar: ints.append(('char',1))
490        if opts.useShort: ints.append(('short',2))
491        if opts.useInt: ints.append(('int',4))
492        # FIXME: Wrong size.
493        if opts.useLong: ints.append(('long',4))
494        if opts.useLongLong: ints.append(('long long',8))
495        if opts.useUnsigned:
496            ints = ([('unsigned %s'%i,s) for i,s in ints] +
497                    [('signed %s'%i,s) for i,s in ints])
498        builtins.extend(ints)
499
500        if opts.useBool: builtins.append(('_Bool',1))
501        if opts.useFloat: builtins.append(('float',4))
502        if opts.useDouble: builtins.append(('double',8))
503        if opts.useLongDouble: builtins.append(('long double',16))
504        # FIXME: Wrong size.
505        if opts.useVoidPointer:  builtins.append(('void*',4))
506
507    btg = FixedTypeGenerator([BuiltinType(n,s) for n,s in builtins])
508
509    bitfields = []
510    for specifier in opts.bitFields.split(','):
511        if not specifier.strip():
512            continue
513        name,width = specifier.strip().split(':', 1)
514        bitfields.append(BuiltinType(name,None,int(width)))
515    bftg = FixedTypeGenerator(bitfields)
516
517    charType = BuiltinType('char',1)
518    shortType = BuiltinType('short',2)
519    intType = BuiltinType('int',4)
520    longlongType = BuiltinType('long long',8)
521    floatType = BuiltinType('float',4)
522    doubleType = BuiltinType('double',8)
523    sbtg = FixedTypeGenerator([charType, intType, floatType, doubleType])
524
525    atg = AnyTypeGenerator()
526    artg = AnyTypeGenerator()
527    def makeGenerator(atg, subgen, subfieldgen, useRecord, useArray, useBitField):
528        atg.addGenerator(btg)
529        if useBitField and opts.useBitField:
530            atg.addGenerator(bftg)
531        if useRecord and opts.useRecord:
532            assert subgen
533            atg.addGenerator(RecordTypeGenerator(subfieldgen, opts.recordUseUnion,
534                                                 opts.recordMaxSize))
535        if opts.useComplex:
536            # FIXME: Allow overriding builtins here
537            atg.addGenerator(ComplexTypeGenerator(sbtg))
538        if useArray and opts.useArray:
539            assert subgen
540            atg.addGenerator(ArrayTypeGenerator(subgen, opts.arrayMaxSize))
541        if opts.useVector:
542            vTypes = []
543            for i,t in enumerate(opts.vectorTypes.split(',')):
544                m = re.match('v([1-9][0-9]*)([if][1-9][0-9]*)', t.strip())
545                if not m:
546                    parser.error('Invalid vector type: %r' % t)
547                count,kind = m.groups()
548                count = int(count)
549                type = { 'i8'  : charType,
550                         'i16' : shortType,
551                         'i32' : intType,
552                         'i64' : longlongType,
553                         'f32' : floatType,
554                         'f64' : doubleType,
555                         }.get(kind)
556                if not type:
557                    parser.error('Invalid vector type: %r' % t)
558                vTypes.append(ArrayType(i, True, type, count * type.size))
559
560            atg.addGenerator(FixedTypeGenerator(vTypes))
561        if opts.useEnum:
562            atg.addGenerator(EnumTypeGenerator([None, '-1', '1', '1u'], 1, 4))
563
564    if opts.recordMaxDepth is None:
565        # Fully recursive, just avoid top-level arrays.
566        subFTG = AnyTypeGenerator()
567        subTG = AnyTypeGenerator()
568        atg = AnyTypeGenerator()
569        makeGenerator(subFTG, atg, atg, True, True, True)
570        makeGenerator(subTG, atg, subFTG, True, True, False)
571        makeGenerator(atg, subTG, subFTG, True, False, False)
572    else:
573        # Make a chain of type generators, each builds smaller
574        # structures.
575        base = AnyTypeGenerator()
576        fbase = AnyTypeGenerator()
577        makeGenerator(base, None, None, False, False, False)
578        makeGenerator(fbase, None, None, False, False, True)
579        for i in range(opts.recordMaxDepth):
580            n = AnyTypeGenerator()
581            fn = AnyTypeGenerator()
582            makeGenerator(n, base, fbase, True, True, False)
583            makeGenerator(fn, base, fbase, True, True, True)
584            base = n
585            fbase = fn
586        atg = AnyTypeGenerator()
587        makeGenerator(atg, base, fbase, True, False, False)
588
589    if opts.testLayout:
590        ftg = atg
591    else:
592        ftg = FunctionTypeGenerator(atg, opts.functionUseReturn, opts.functionMaxArgs)
593
594    # Override max,min,count if finite
595    if opts.maxIndex is None:
596        if ftg.cardinality is aleph0:
597            opts.maxIndex = 10000000
598        else:
599            opts.maxIndex = ftg.cardinality
600    opts.maxIndex = min(opts.maxIndex, ftg.cardinality)
601    opts.minIndex = max(0,min(opts.maxIndex-1, opts.minIndex))
602    if not opts.mode=='random':
603        opts.count = min(opts.count, opts.maxIndex-opts.minIndex)
604
605    if opts.output=='-':
606        output = sys.stdout
607    else:
608        output = open(opts.output,'w')
609        atexit.register(lambda: output.close())
610
611    outputHeader = None
612    if opts.outputHeader:
613        outputHeader = open(opts.outputHeader,'w')
614        atexit.register(lambda: outputHeader.close())
615
616    outputTests = None
617    if opts.outputTests:
618        outputTests = open(opts.outputTests,'w')
619        atexit.register(lambda: outputTests.close())
620
621    outputDriver = None
622    if opts.outputDriver:
623        outputDriver = open(opts.outputDriver,'w')
624        atexit.register(lambda: outputDriver.close())
625
626    info = ''
627    info += '// %s\n'%(' '.join(sys.argv),)
628    info += '// Generated: %s\n'%(time.strftime('%Y-%m-%d %H:%M'),)
629    info += '// Cardinality of function generator: %s\n'%(ftg.cardinality,)
630    info += '// Cardinality of type generator: %s\n'%(atg.cardinality,)
631
632    if opts.testLayout:
633        info += '\n#include <stdio.h>'
634
635    P = TypePrinter(output,
636                    outputHeader=outputHeader,
637                    outputTests=outputTests,
638                    outputDriver=outputDriver,
639                    headerName=opts.outputHeader,
640                    info=info)
641
642    def write(N):
643        try:
644            FT = ftg.get(N)
645        except RuntimeError,e:
646            if e.args[0]=='maximum recursion depth exceeded':
647                print >>sys.stderr,'WARNING: Skipped %d, recursion limit exceeded (bad arguments?)'%(N,)
648                return
649            raise
650        if opts.testLayout:
651            P.writeLayoutTest(N, FT)
652        else:
653            P.writeFunction(N, FT)
654
655    if args:
656        [write(int(a)) for a in args]
657
658    skipTests = set(opts.skipTests)
659    for i in range(opts.count):
660        if opts.mode=='linear':
661            index = opts.minIndex + i
662        else:
663            index = opts.minIndex + int((opts.maxIndex-opts.minIndex) * random.random())
664        if index in skipTests:
665            continue
666        write(index)
667
668    P.finish()
669
670if __name__=='__main__':
671    main()
672
673