therubyracer 0.9.0beta4 → 0.9.0beta5

data/ext/v8/upstream/v8/tools/freebsd-tick-processor

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-# A wrapper script to call 'linux-tick-processor'.
-
-# Known issues on FreeBSD:
-#  No ticks from C++ code.
-#  You must have d8 built and in your path before calling this.
-
-tools_path=`cd $(dirname "$0");pwd`
-$tools_path/linux-tick-processor "$@"

data/ext/v8/upstream/v8/tools/gc-nvp-trace-processor.py

@@ -1,328 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2010 the V8 project authors. All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-#       copyright notice, this list of conditions and the following
-#       disclaimer in the documentation and/or other materials provided
-#       with the distribution.
-#     * Neither the name of Google Inc. nor the names of its
-#       contributors may be used to endorse or promote products derived
-#       from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-
-#
-# This is an utility for plotting charts based on GC traces produced by V8 when
-# run with flags --trace-gc --trace-gc-nvp. Relies on gnuplot for actual
-# plotting.
-#
-# Usage: gc-nvp-trace-processor.py <GC-trace-filename>
-#
-
-
-from __future__ import with_statement
-import sys, types, re, subprocess, math
-
-def flatten(l):
-  flat = []
-  for i in l: flat.extend(i)
-  return flat
-
-def split_nvp(s):
-  t = {}
-  for (name, value) in re.findall(r"(\w+)=([-\w]+)", s):
-    try:
-      t[name] = int(value)
-    except ValueError:
-      t[name] = value
-
-  return t
-
-def parse_gc_trace(input):
-  trace = []
-  with open(input) as f:
-    for line in f:
-      info = split_nvp(line)
-      if info and 'pause' in info and info['pause'] > 0:
-        info['i'] = len(trace)
-        trace.append(info)
-  return trace
-
-def extract_field_names(script):
-  fields = { 'data': true, 'in': true }
-
-  for m in re.finditer(r"$(\w+)", script):
-    field_name = m.group(1)
-    if field_name not in fields:
-      fields[field] = field_count
-      field_count = field_count + 1
-
-  return fields
-
-def gnuplot(script):
-  gnuplot = subprocess.Popen(["gnuplot"], stdin=subprocess.PIPE)
-  gnuplot.stdin.write(script)
-  gnuplot.stdin.close()
-  gnuplot.wait()
-
-x1y1 = 'x1y1'
-x1y2 = 'x1y2'
-x2y1 = 'x2y1'
-x2y2 = 'x2y2'
-
-class Item(object):
-  def __init__(self, title, field, axis = x1y1, **keywords):
-    self.title = title
-    self.axis = axis
-    self.props = keywords
-    if type(field) is types.ListType:
-      self.field = field
-    else:
-      self.field = [field]
-
-  def fieldrefs(self):
-    return self.field
-
-  def to_gnuplot(self, context):
-    args = ['"%s"' % context.datafile,
-            'using %s' % context.format_fieldref(self.field),
-            'title "%s"' % self.title,
-            'axis %s' % self.axis]
-    if 'style' in self.props:
-      args.append('with %s' % self.props['style'])
-    if 'lc' in self.props:
-      args.append('lc rgb "%s"' % self.props['lc'])
-    if 'fs' in self.props:
-      args.append('fs %s' % self.props['fs'])
-    return ' '.join(args)
-
-class Plot(object):
-  def __init__(self, *items):
-    self.items = items
-
-  def fieldrefs(self):
-    return flatten([item.fieldrefs() for item in self.items])
-
-  def to_gnuplot(self, ctx):
-    return 'plot ' + ', '.join([item.to_gnuplot(ctx) for item in self.items])
-
-class Set(object):
-  def __init__(self, value):
-    self.value = value
-
-  def to_gnuplot(self, ctx):
-    return 'set ' + self.value
-
-  def fieldrefs(self):
-    return []
-
-class Context(object):
-  def __init__(self, datafile, field_to_index):
-    self.datafile = datafile
-    self.field_to_index = field_to_index
-
-  def format_fieldref(self, fieldref):
-    return ':'.join([str(self.field_to_index[field]) for field in fieldref])
-
-def collect_fields(plot):
-  field_to_index = {}
-  fields = []
-
-  def add_field(field):
-    if field not in field_to_index:
-      fields.append(field)
-      field_to_index[field] = len(fields)
-
-  for field in flatten([item.fieldrefs() for item in plot]):
-    add_field(field)
-
-  return (fields, field_to_index)
-
-def is_y2_used(plot):
-  for subplot in plot:
-    if isinstance(subplot, Plot):
-      for item in subplot.items:
-        if item.axis == x1y2 or item.axis == x2y2:
-          return True
-  return False
-
-def get_field(trace_line, field):
-  t = type(field)
-  if t is types.StringType:
-    return trace_line[field]
-  elif t is types.FunctionType:
-    return field(trace_line)
-
-def generate_datafile(datafile_name, trace, fields):
-  with open(datafile_name, 'w') as datafile:
-    for line in trace:
-      data_line = [str(get_field(line, field)) for field in fields]
-      datafile.write('\t'.join(data_line))
-      datafile.write('\n')
-
-def generate_script_and_datafile(plot, trace, datafile, output):
-  (fields, field_to_index) = collect_fields(plot)
-  generate_datafile(datafile, trace, fields)
-  script = [
-      'set terminal png',
-      'set output "%s"' % output,
-      'set autoscale',
-      'set ytics nomirror',
-      'set xtics nomirror',
-      'set key below'
-  ]
-
-  if is_y2_used(plot):
-    script.append('set autoscale y2')
-    script.append('set y2tics')
-
-  context = Context(datafile, field_to_index)
-
-  for item in plot:
-    script.append(item.to_gnuplot(context))
-
-  return '\n'.join(script)
-
-def plot_all(plots, trace, prefix):
-  charts = []
-
-  for plot in plots:
-    outfilename = "%s_%d.png" % (prefix, len(charts))
-    charts.append(outfilename)
-    script = generate_script_and_datafile(plot, trace, '~datafile', outfilename)
-    print 'Plotting %s...' % outfilename
-    gnuplot(script)
-
-  return charts
-
-def reclaimed_bytes(row):
-  return row['total_size_before'] - row['total_size_after']
-
-def other_scope(r):
-  return r['pause'] - r['mark'] - r['sweep'] - r['compact']
-
-plots = [
-  [
-    Set('style fill solid 0.5 noborder'),
-    Set('style histogram rowstacked'),
-    Set('style data histograms'),
-    Plot(Item('Marking', 'mark', lc = 'purple'),
-         Item('Sweep', 'sweep', lc = 'blue'),
-         Item('Compaction', 'compact', lc = 'red'),
-         Item('Other', other_scope, lc = 'grey'))
-  ],
-  [
-    Set('style histogram rowstacked'),
-    Set('style data histograms'),
-    Plot(Item('Heap Size (before GC)', 'total_size_before', x1y2,
-              fs = 'solid 0.4 noborder',
-              lc = 'green'),
-         Item('Total holes (after GC)', 'holes_size_before', x1y2,
-              fs = 'solid 0.4 noborder',
-              lc = 'red'),
-         Item('GC Time', ['i', 'pause'], style = 'lines', lc = 'red'))
-  ],
-  [
-    Set('style histogram rowstacked'),
-    Set('style data histograms'),
-    Plot(Item('Heap Size (after GC)', 'total_size_after', x1y2,
-              fs = 'solid 0.4 noborder',
-              lc = 'green'),
-         Item('Total holes (after GC)', 'holes_size_after', x1y2,
-              fs = 'solid 0.4 noborder',
-              lc = 'red'),
-         Item('GC Time', ['i', 'pause'],
-              style = 'lines',
-              lc = 'red'))
-  ],
-  [
-    Set('style fill solid 0.5 noborder'),
-    Set('style data histograms'),
-    Plot(Item('Allocated', 'allocated'),
-         Item('Reclaimed', reclaimed_bytes),
-         Item('Promoted', 'promoted', style = 'lines', lc = 'black'))
-  ],
-]
-
-def freduce(f, field, trace, init):
-  return reduce(lambda t,r: f(t, r[field]), trace, init)
-
-def calc_total(trace, field):
-  return freduce(lambda t,v: t + v, field, trace, 0)
-
-def calc_max(trace, field):
-  return freduce(lambda t,r: max(t, r), field, trace, 0)
-
-def count_nonzero(trace, field):
-  return freduce(lambda t,r: t if r == 0 else t + 1, field, trace, 0)
-
-
-def process_trace(filename):
-  trace = parse_gc_trace(filename)
-
-  marksweeps = filter(lambda r: r['gc'] == 'ms', trace)
-  markcompacts = filter(lambda r: r['gc'] == 'mc', trace)
-  scavenges = filter(lambda r: r['gc'] == 's', trace)
-
-  charts = plot_all(plots, trace, filename)
-
-  def stats(out, prefix, trace, field):
-    n = len(trace)
-    total = calc_total(trace, field)
-    max = calc_max(trace, field)
-    if n > 0:
-      avg = total / n
-    else:
-      avg = 0
-    if n > 1:
-      dev = math.sqrt(freduce(lambda t,r: (r - avg) ** 2, field, trace, 0) /
-                      (n - 1))
-    else:
-      dev = 0
-
-    out.write('<tr><td>%s</td><td>%d</td><td>%d</td>'
-              '<td>%d</td><td>%d [dev %f]</td></tr>' %
-              (prefix, n, total, max, avg, dev))
-
-
-  with open(filename + '.html', 'w') as out:
-    out.write('<html><body>')
-    out.write('<table>')
-    out.write('<tr><td>Phase</td><td>Count</td><td>Time (ms)</td>')
-    out.write('<td>Max</td><td>Avg</td></tr>')
-    stats(out, 'Total in GC', trace, 'pause')
-    stats(out, 'Scavenge', scavenges, 'pause')
-    stats(out, 'MarkSweep', marksweeps, 'pause')
-    stats(out, 'MarkCompact', markcompacts, 'pause')
-    stats(out, 'Mark', filter(lambda r: r['mark'] != 0, trace), 'mark')
-    stats(out, 'Sweep', filter(lambda r: r['sweep'] != 0, trace), 'sweep')
-    stats(out, 'Compact', filter(lambda r: r['compact'] != 0, trace), 'compact')
-    out.write('</table>')
-    for chart in charts:
-      out.write('<img src="%s">' % chart)
-      out.write('</body></html>')
-
-  print "%s generated." % (filename + '.html')
-
-if len(sys.argv) != 2:
-  print "Usage: %s <GC-trace-filename>" % sys.argv[0]
-  sys.exit(1)
-
-process_trace(sys.argv[1])

data/ext/v8/upstream/v8/tools/generate-ten-powers.scm

@@ -1,286 +0,0 @@
-;; Copyright 2010 the V8 project authors. All rights reserved.
-;; Redistribution and use in source and binary forms, with or without
-;; modification, are permitted provided that the following conditions are
-;; met:
-;;
-;;     * Redistributions of source code must retain the above copyright
-;;       notice, this list of conditions and the following disclaimer.
-;;     * Redistributions in binary form must reproduce the above
-;;       copyright notice, this list of conditions and the following
-;;       disclaimer in the documentation and/or other materials provided
-;;       with the distribution.
-;;     * Neither the name of Google Inc. nor the names of its
-;;       contributors may be used to endorse or promote products derived
-;;       from this software without specific prior written permission.
-;;
-;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-;; This is a Scheme script for the Bigloo compiler. Bigloo must be compiled with
-;; support for bignums. The compilation of the script can be done as follows:
-;;   bigloo -static-bigloo -o generate-ten-powers generate-ten-powers.scm
-;;  
-;; Generate approximations of 10^k.
-
-(module gen-ten-powers
-   (static (class Cached-Fast
-	      v::bignum
-	      e::bint
-	      exact?::bool))
-   (main my-main))
-
-
-;;----------------bignum shifts -----------------------------------------------
-(define (bit-lshbx::bignum x::bignum by::bint)
-   (if (<fx by 0)
-       #z0
-       (*bx x (exptbx #z2 (fixnum->bignum by)))))
-
-(define (bit-rshbx::bignum x::bignum by::bint)
-   (if (<fx by 0)
-       #z0
-       (/bx x (exptbx #z2 (fixnum->bignum by)))))
-
-;;----------------the actual power generation -------------------------------
-
-;; e should be an indication. it might be too small.
-(define (round-n-cut n e nb-bits)
-   (define max-container (- (bit-lshbx #z1 nb-bits) 1))
-   (define (round n)
-      (case *round*
-	 ((down) n)
-	 ((up)
-	  (+bx n
-	       ;; with the -1 it will only round up if the cut off part is
-	       ;; non-zero
-	       (-bx (bit-lshbx #z1
-			       (-fx (+fx e nb-bits) 1))
-		    #z1)))
-	 ((round)
-	  (+bx n
-	       (bit-lshbx #z1
-			  (-fx (+fx e nb-bits) 2))))))
-   (let* ((shift (-fx (+fx e nb-bits) 1))
-	  (cut (bit-rshbx (round n) shift))
-	  (exact? (=bx n (bit-lshbx cut shift))))
-      (if (<=bx cut max-container)
-	  (values cut e exact?)
-	  (round-n-cut n (+fx e 1) nb-bits))))
-
-(define (rounded-/bx x y)
-   (case *round*
-      ((down)  (/bx x y))
-      ((up)    (+bx (/bx x y) #z1))
-      ((round) (let ((tmp (/bx (*bx #z2 x) y)))
-		  (if (zerobx? (remainderbx tmp #z2))
-		      (/bx tmp #z2)
-		      (+bx (/bx tmp #z2) #z1))))))
-
-(define (generate-powers from to mantissa-size)
-   (let* ((nb-bits mantissa-size)
-	  (offset (- from))
-	  (nb-elements (+ (- from) to 1))
-	  (vec (make-vector nb-elements))
-	  (max-container (- (bit-lshbx #z1 nb-bits) 1)))
-      ;; the negative ones. 10^-1, 10^-2, etc.
-      ;; We already know, that we can't be exact, so exact? will always be #f.
-      ;; Basically we will have a ten^i that we will *10 at each iteration. We
-      ;; want to create the matissa of 1/ten^i. However the mantissa must be
-      ;; normalized (start with a 1). -> we have to shift the number.
-      ;; We shift by multiplying with two^e. -> We encode two^e*(1/ten^i) ==
-      ;;  two^e/ten^i.
-      (let loop ((i 1)
-		 (ten^i #z10)
-		 (two^e #z1)
-		 (e 0))
-	 (unless (< (- i) from)
-	    (if (>bx (/bx (*bx #z2 two^e) ten^i) max-container)
-		;; another shift would make the number too big. We are
-		;; hence normalized now.
-		(begin
-		   (vector-set! vec (-fx offset i)
-				(instantiate::Cached-Fast
-				   (v (rounded-/bx two^e ten^i))
-				   (e (negfx e))
-				   (exact? #f)))
-		   (loop (+fx i 1) (*bx ten^i #z10) two^e e))
-		(loop i ten^i (bit-lshbx two^e 1) (+fx e 1)))))
-      ;; the positive ones 10^0, 10^1, etc.
-      ;; start with 1.0. mantissa: 10...0 (1 followed by nb-bits-1 bits)
-      ;;      -> e = -(nb-bits-1)
-      ;; exact? is true when the container can still hold the complete 10^i
-      (let loop ((i 0)
-		 (n (bit-lshbx #z1 (-fx nb-bits 1)))
-		 (e (-fx 1 nb-bits)))
-	 (when (<= i to)
-	    (receive (cut e exact?)
-	       (round-n-cut n e nb-bits)
-	       (vector-set! vec (+fx i offset)
-			    (instantiate::Cached-Fast
-			       (v cut)
-			       (e e)
-			       (exact? exact?)))
-	       (loop (+fx i 1) (*bx n #z10) e))))
-      vec))
-
-(define (print-c powers from to struct-type
-		 cache-name max-distance-name offset-name macro64)
-   (define (display-power power k)
-      (with-access::Cached-Fast power (v e exact?)
-	 (let ((tmp-p (open-output-string)))
-	    ;; really hackish way of getting the digits
-	    (display (format "~x" v) tmp-p)
-	    (let ((str (close-output-port tmp-p)))
-	       (printf "  {~a(0x~a, ~a), ~a, ~a},\n"
-		       macro64
-		       (substring str 0 8)
-		       (substring str 8 16)
-		       e
-		       k)))))
-   (define (print-powers-reduced n)
-      (print "static const " struct-type " " cache-name
-	     "(" n ")"
-	     "[] = {")
-      (let loop ((i 0)
-		 (nb-elements 0)
-		 (last-e 0)
-		 (max-distance 0))
-	 (cond
-	    ((>= i (vector-length powers))
-	     (print "  };")
-	     (print "static const int " max-distance-name "(" n ") = "
-		 max-distance ";")
-	     (print "// nb elements (" n "): " nb-elements))
-	    (else
-	     (let* ((power (vector-ref powers i))
-		    (e (Cached-Fast-e power)))
-	     (display-power power (+ i from))
-	     (loop (+ i n)
-		   (+ nb-elements 1)
-		   e
-		   (cond
-		      ((=fx i 0) max-distance)
-		      ((> (- e last-e) max-distance) (- e last-e))
-		      (else max-distance))))))))
-   (print "// Copyright 2010 the V8 project authors. All rights reserved.")
-   (print "// ------------ GENERATED FILE ----------------")
-   (print "// command used:")
-   (print "// "
-	  (apply string-append (map (lambda (str)
-				       (string-append " " str))
-				    *main-args*))
-	  "  // NOLINT")
-   (print)
-   (print
-    "// This file is intended to be included inside another .h or .cc files\n"
-    "// with the following defines set:\n"
-    "//  GRISU_CACHE_STRUCT: should expand to the name of a struct that will\n"
-    "//   hold the cached powers of ten. Each entry will hold a 64-bit\n"
-    "//   significand, a 16-bit signed binary exponent, and a 16-bit\n"
-    "//   signed decimal exponent. Each entry will be constructed as follows:\n"
-    "//      { significand, binary_exponent, decimal_exponent }.\n"
-    "//  GRISU_CACHE_NAME(i): generates the name for the different caches.\n"
-    "//   The parameter i will be a number in the range 1-20. A cache will\n"
-    "//   hold every i'th element of a full cache. GRISU_CACHE_NAME(1) will\n"
-    "//   thus hold all elements. The higher i the fewer elements it has.\n"
-    "//   Ideally the user should only reference one cache and let the\n"
-    "//   compiler remove the unused ones.\n"
-    "//  GRISU_CACHE_MAX_DISTANCE(i): generates the name for the maximum\n"
-    "//   binary exponent distance between all elements of a given cache.\n"
-    "//  GRISU_CACHE_OFFSET: is used as variable name for the decimal\n"
-    "//   exponent offset. It is equal to -cache[0].decimal_exponent.\n"
-    "//  GRISU_UINT64_C: used to construct 64-bit values in a platform\n"
-    "//   independent way. In order to encode 0x123456789ABCDEF0 the macro\n"
-    "//   will be invoked as follows: GRISU_UINT64_C(0x12345678,9ABCDEF0).\n")
-   (print)
-   (print-powers-reduced 1)
-   (print-powers-reduced 2)
-   (print-powers-reduced 3)
-   (print-powers-reduced 4)
-   (print-powers-reduced 5)
-   (print-powers-reduced 6)
-   (print-powers-reduced 7)
-   (print-powers-reduced 8)
-   (print-powers-reduced 9)
-   (print-powers-reduced 10)
-   (print-powers-reduced 11)
-   (print-powers-reduced 12)
-   (print-powers-reduced 13)
-   (print-powers-reduced 14)
-   (print-powers-reduced 15)
-   (print-powers-reduced 16)
-   (print-powers-reduced 17)
-   (print-powers-reduced 18)
-   (print-powers-reduced 19)
-   (print-powers-reduced 20)
-   (print "static const int GRISU_CACHE_OFFSET = " (- from) ";"))
-
-;;----------------main --------------------------------------------------------
-(define *main-args* #f)
-(define *mantissa-size* #f)
-(define *dest* #f)
-(define *round* #f)
-(define *from* #f)
-(define *to* #f)
-
-(define (my-main args)
-   (set! *main-args* args)
-   (args-parse (cdr args)
-      (section "Help")
-      (("?") (args-parse-usage #f))
-      ((("-h" "--help") (help "?, -h, --help" "This help message"))
-       (args-parse-usage #f))
-      (section "Misc")
-      (("-o" ?file (help "The output file"))
-       (set! *dest* file))
-      (("--mantissa-size" ?size (help "Container-size in bits"))
-       (set! *mantissa-size* (string->number size)))
-      (("--round" ?direction (help "Round bignums (down, round or up)"))
-       (set! *round* (string->symbol direction)))
-      (("--from" ?from (help "start at 10^from"))
-       (set! *from* (string->number from)))
-      (("--to" ?to (help "go up to 10^to"))
-       (set! *to* (string->number to)))
-      (else
-       (print "Illegal argument `" else "'. Usage:")
-       (args-parse-usage #f)))
-   (when (not *from*)
-      (error "generate-ten-powers"
-	     "Missing from"
-	     #f))
-   (when (not *to*)
-      (error "generate-ten-powers"
-	     "Missing to"
-	     #f))
-   (when (not *mantissa-size*)
-      (error "generate-ten-powers"
-	     "Missing mantissa size"
-	     #f))
-   (when (not (memv *round* '(up down round)))
-      (error "generate-ten-powers"
-	     "Missing round-method"
-	     *round*))
-
-   (let ((dividers (generate-powers *from* *to* *mantissa-size*))
-	 (p (if (not *dest*)
-		(current-output-port)
-		(open-output-file *dest*))))
-      (unwind-protect
-	 (with-output-to-port p
-	    (lambda ()
-	       (print-c dividers *from* *to*
-			"GRISU_CACHE_STRUCT" "GRISU_CACHE_NAME"
-			"GRISU_CACHE_MAX_DISTANCE" "GRISU_CACHE_OFFSET"
-			"GRISU_UINT64_C"
-			)))
-	 (if *dest*
-	     (close-output-port p)))))