OSDN Git Service

* boehm.c (set_bit): Improve type safety wrt unsignedness.
[pf3gnuchains/gcc-fork.git] / gcc / java / jcf-io.c
1 /* Utility routines for finding and reading Java(TM) .class files.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  
21
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
25
26 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
27
28 #include "config.h"
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
32
33 #include "jcf.h"
34 #include "tree.h"
35 #include "toplev.h"
36 #include "java-tree.h"
37 #include "hashtab.h"
38 #if JCF_USE_SCANDIR
39 #include <dirent.h>
40 #include <fnmatch.h>
41 #endif
42
43 #include "zlib.h"
44
45 /* DOS brain-damage */
46 #ifndef O_BINARY
47 #define O_BINARY 0 /* MS-DOS brain-damage */
48 #endif
49
50 int
51 jcf_unexpected_eof (JCF *jcf, int count ATTRIBUTE_UNUSED)
52 {
53   if (jcf->filename)
54     fprintf (stderr, "Premature end of .class file %s.\n", jcf->filename);
55   else
56     fprintf (stderr, "Premature end of .class file <stdin>.\n");
57   exit (-1);
58 }
59
60 void
61 jcf_trim_old_input (JCF *jcf)
62 {
63   int count = jcf->read_ptr - jcf->buffer;
64   if (count > 0)
65     {
66       memmove (jcf->buffer, jcf->read_ptr, jcf->read_end - jcf->read_ptr);
67       jcf->read_ptr -= count;
68       jcf->read_end -= count;
69     }
70 }
71
72 int
73 jcf_filbuf_from_stdio (JCF *jcf, int count)
74 {
75   FILE *file = (FILE*) (jcf->read_state);
76   if (count > jcf->buffer_end - jcf->read_ptr)
77     {
78       JCF_u4 old_read_ptr = jcf->read_ptr - jcf->buffer;
79       JCF_u4 old_read_end = jcf->read_end - jcf->buffer;
80       JCF_u4 old_size = jcf->buffer_end - jcf->buffer;
81       JCF_u4 new_size = (old_size == 0 ? 2000 : 2 * old_size) + count;
82       unsigned char *new_buffer = jcf->buffer == NULL ? ALLOC (new_size)
83         : REALLOC (jcf->buffer, new_size);
84       jcf->buffer = new_buffer;
85       jcf->buffer_end = new_buffer + new_size;
86       jcf->read_ptr = new_buffer + old_read_ptr;
87       jcf->read_end = new_buffer + old_read_end;
88     }
89   count -= jcf->read_end - jcf->read_ptr;
90   if (count <= 0)
91     return 0;
92   if ((int) fread (jcf->read_end, 1, count, file) != count)
93     jcf_unexpected_eof (jcf, count);
94   jcf->read_end += count;
95   return 0;
96 }
97
98 #include "zipfile.h"
99
100 struct ZipFile *SeenZipFiles = NULL;
101
102 /* Open a zip file with the given name, and cache directory and file
103    descriptor.  If the file is missing, treat it as an empty archive.
104    Return NULL if the .zip file is malformed.
105 */
106
107 ZipFile *
108 opendir_in_zip (const char *zipfile, int is_system)
109 {
110   struct ZipFile* zipf;
111   char magic [4];
112   int fd;
113   for (zipf = SeenZipFiles;  zipf != NULL;  zipf = zipf->next)
114     {
115       if (strcmp (zipf->name, zipfile) == 0)
116         return zipf;
117     }
118
119   zipf = ALLOC (sizeof (struct ZipFile) + strlen (zipfile) + 1);
120   zipf->next = SeenZipFiles;
121   zipf->name = (char*)(zipf+1);
122   strcpy (zipf->name, zipfile);
123   fd = open (zipfile, O_RDONLY | O_BINARY);
124   zipf->fd = fd;
125   if (fd < 0)
126     {
127       /* A missing zip file is not considered an error.
128        We may want to re-consider that.  FIXME. */
129       zipf->count = 0;
130       zipf->dir_size = 0;
131       zipf->central_directory = NULL;
132     }
133   else
134     {
135       jcf_dependency_add_file (zipfile, is_system);
136       if (read (fd, magic, 4) != 4 || GET_u4 (magic) != (JCF_u4)ZIPMAGIC)
137         return NULL;
138       lseek (fd, 0L, SEEK_SET);
139       if (read_zip_archive (zipf) != 0)
140         return NULL;
141     }
142
143   SeenZipFiles = zipf;  
144   return zipf;
145 }
146
147 /* Returns:
148    0:  OK - zipmember found.
149    -1: Not found.
150    -2: Malformed archive.
151 */
152
153 int
154 open_in_zip (JCF *jcf, const char *zipfile, const char *zipmember,
155              int is_system)
156 {
157   ZipDirectory *zipd;
158   int i, len;
159   ZipFile *zipf = opendir_in_zip (zipfile, is_system);
160
161   if (zipf == NULL)
162     return -2;
163
164   if (!zipmember)
165     return 0;
166
167   len = strlen (zipmember);
168   
169   zipd = (struct ZipDirectory*) zipf->central_directory;
170   for (i = 0; i < zipf->count; i++, zipd = ZIPDIR_NEXT (zipd))
171     {
172       if (len == zipd->filename_length &&
173           strncmp (ZIPDIR_FILENAME (zipd), zipmember, len) == 0)
174         {
175           JCF_ZERO (jcf);
176
177           jcf->filename = xstrdup (zipfile);
178           jcf->classname = xstrdup (zipmember);
179           return read_zip_member(jcf, zipd, zipf);
180         }
181     }
182   return -1;
183 }
184
185 /* Read data from zip archive member. */
186
187 int
188 read_zip_member (JCF *jcf,  ZipDirectory *zipd, ZipFile *zipf)
189 {
190   jcf->filbuf = jcf_unexpected_eof;
191   jcf->zipd = (void *)zipd;
192
193   if (zipd->compression_method == Z_NO_COMPRESSION)
194     {
195       jcf->buffer = ALLOC (zipd->size);
196       jcf->buffer_end = jcf->buffer + zipd->size;
197       jcf->read_ptr = jcf->buffer;
198       jcf->read_end = jcf->buffer_end;
199       if (lseek (zipf->fd, zipd->filestart, 0) < 0
200           || read (zipf->fd, jcf->buffer, zipd->size) != (long) zipd->size)
201         return -2;
202     }
203   else
204     {
205       char *buffer;
206       z_stream d_stream; /* decompression stream */
207       d_stream.zalloc = (alloc_func) 0;
208       d_stream.zfree = (free_func) 0;
209       d_stream.opaque = (voidpf) 0;
210
211       jcf->buffer = ALLOC (zipd->uncompressed_size);
212       d_stream.next_out = jcf->buffer;
213       d_stream.avail_out = zipd->uncompressed_size;
214       jcf->buffer_end = jcf->buffer + zipd->uncompressed_size;
215       jcf->read_ptr = jcf->buffer;
216       jcf->read_end = jcf->buffer_end;
217       buffer = ALLOC (zipd->size);
218       d_stream.next_in = (unsigned char *) buffer;
219       d_stream.avail_in = zipd->size;
220       if (lseek (zipf->fd, zipd->filestart, 0) < 0
221           || read (zipf->fd, buffer, zipd->size) != (long) zipd->size)
222         return -2;
223       /* Handle NO_HEADER using undocumented zlib feature.
224          This is a very common hack.  */
225       inflateInit2 (&d_stream, -MAX_WBITS);
226       inflate (&d_stream, Z_NO_FLUSH);
227       inflateEnd (&d_stream);
228       FREE (buffer);
229     }
230
231   return 0;
232 }
233
234 const char *
235 open_class (const char *filename, JCF *jcf, int fd, const char *dep_name)
236 {
237   if (jcf)
238     {
239       struct stat stat_buf;
240       if (fstat (fd, &stat_buf) != 0
241           || ! S_ISREG (stat_buf.st_mode))
242         {
243           perror ("Could not figure length of .class file");
244           return NULL;
245         }
246       if (dep_name != NULL)
247         jcf_dependency_add_file (dep_name, 0);
248       JCF_ZERO (jcf);
249       jcf->buffer = ALLOC (stat_buf.st_size);
250       jcf->buffer_end = jcf->buffer + stat_buf.st_size;
251       jcf->read_ptr = jcf->buffer;
252       jcf->read_end = jcf->buffer_end;
253       jcf->read_state = NULL;
254       jcf->filename = filename;
255       if (read (fd, jcf->buffer, stat_buf.st_size) != stat_buf.st_size)
256         {
257           perror ("Failed to read .class file");
258           return NULL;
259         }
260       close (fd);
261       jcf->filbuf = jcf_unexpected_eof;
262     }
263   else
264     close (fd);
265   return filename;
266 }
267
268
269 const char *
270 find_classfile (char *filename, JCF *jcf, const char *dep_name)
271 {
272   int fd = open (filename, O_RDONLY | O_BINARY);
273   if (fd < 0)
274     return NULL;
275   return open_class (filename, jcf, fd, dep_name);
276 }
277
278 #if JCF_USE_SCANDIR
279
280 /* A comparison function (as for qsort) that compares KEY (a char *
281    giving the basename of a file) with the name stored in ENTRY (a
282    dirent **).  */
283
284 static int
285 compare_path (const void *key, const void *entry)
286 {
287   return strcmp ((const char *) key, 
288                  (*((const struct dirent **) entry))->d_name);
289 }
290
291 /* Returns nonzero if ENTRY names a .java or .class file.  */
292
293 static int
294 java_or_class_file (const struct dirent *entry)
295 {
296   const char *base = lbasename (entry->d_name);
297   return (fnmatch ("*.java", base, 0) == 0 || 
298           fnmatch ("*.class", base, 0) == 0);
299 }
300
301 /* Information about the files present in a particular directory.  */
302 typedef struct memoized_dirlist_entry 
303 {
304   /* The name of the directory.  */
305   const char *dir;
306   /* The number of .java and .class files present, or -1 if we could
307      not, for some reason, obtain the list.  */
308   int num_files;
309   /* The .java and .class files in the directory, in alphabetical
310      order.  */
311   struct dirent **files;
312 } memoized_dirlist_entry;
313
314 /* Returns true if ENTRY (a memoized_dirlist_entry *) corresponds to
315    the directory given by KEY (a char *) giving the directory 
316    name.  */
317
318 static int
319 memoized_dirlist_lookup_eq (const void *entry, const void *key)
320 {
321   return strcmp ((const char *) key,
322                  ((const memoized_dirlist_entry *) entry)->dir) == 0;
323 }
324
325 /* A hash table mapping directory names to the lists of .java and
326    .class files in that directory.  */
327
328 static htab_t memoized_dirlists;
329
330 #endif
331
332 /* Like stat, but avoids actually making the stat system call if we
333    know that it cannot succeed.  FILENAME and BUF are as for stat.  */
334
335 static int
336 caching_stat (char *filename, struct stat *buf)
337 {
338 #if JCF_USE_SCANDIR
339   char *sep;
340   char origsep = 0;
341   char *base;
342   memoized_dirlist_entry *dent;
343   void **slot;
344   
345   /* If the hashtable has not already been created, create it now.  */
346   if (!memoized_dirlists)
347     memoized_dirlists = htab_create (37,
348                                      htab_hash_string,
349                                      memoized_dirlist_lookup_eq,
350                                      NULL);
351
352   /* Get the name of the directory.  */
353   sep = strrchr (filename, DIR_SEPARATOR);
354 #ifdef DIR_SEPARATOR_2
355   if (! sep)
356     sep = strrchr (filename, DIR_SEPARATOR_2);
357 #endif
358   if (sep)
359     {
360       origsep = *sep;
361       *sep = '\0';
362       base = sep + 1;
363     }
364   else
365     base = filename;
366
367   /* Obtain the entry for this directory from the hash table.  */
368   slot = htab_find_slot (memoized_dirlists, filename, INSERT);
369   if (!*slot)
370     {
371       /* We have not already scanned this directory; scan it now.  */
372       dent = ((memoized_dirlist_entry *) 
373               ALLOC (sizeof (memoized_dirlist_entry)));
374       dent->dir = xstrdup (filename);
375       /* Unfortunately, scandir is not fully standardized.  In
376          particular, the type of the function pointer passed as the
377          third argument sometimes takes a "const struct dirent *"
378          parameter, and sometimes just a "struct dirent *".  We cast
379          to (void *) so that either way it is quietly accepted.  */
380       dent->num_files = scandir (filename, &dent->files, 
381                                  (void *) java_or_class_file, 
382                                  alphasort);
383       *slot = dent;
384     }
385   else
386     dent = *((memoized_dirlist_entry **) slot);
387
388   /* Put the separator back.  */
389   if (sep)
390     *sep = origsep;
391
392   /* If the file is not in the list, there is no need to stat it; it
393      does not exist.  */
394   if (dent->num_files != -1
395       && !bsearch (base, dent->files, dent->num_files,
396                    sizeof (struct dirent *), compare_path))
397     return -1;
398 #endif
399   
400   return stat (filename, buf);
401 }
402
403 /* Returns 1 if the CLASSNAME (really a char *) matches the name
404    stored in TABLE_ENTRY (also a char *).  */
405
406 static int
407 memoized_class_lookup_eq (const void *table_entry, const void *classname)
408 {
409   return strcmp ((const char *)classname, (const char *)table_entry) == 0;
410 }
411
412 /* A hash table keeping track of class names that were not found
413    during class lookup.  (There is no need to cache the values
414    associated with names that were found; they are saved in
415    IDENTIFIER_CLASS_VALUE.)  */
416 static htab_t memoized_class_lookups;
417
418 /* Returns a freshly malloc'd string with the fully qualified pathname
419    of the .class file for the class CLASSNAME.  CLASSNAME must be
420    allocated in permanent storage; this function may retain a pointer
421    to it.  Returns NULL on failure.  If JCF != NULL, it is suitably
422    initialized.  SOURCE_OK is true if we should also look for .java
423    file. */
424
425 const char *
426 find_class (const char *classname, int classname_length, JCF *jcf,
427             int source_ok)
428 {
429   int fd;
430   int i, k, java = -1, class = -1;
431   struct stat java_buf, class_buf;
432   char *dep_file;
433   void *entry;
434   char *java_buffer;
435   int buflen;
436   char *buffer;
437   hashval_t hash;
438
439   /* Create the hash table, if it does not already exist.  */
440   if (!memoized_class_lookups)
441     memoized_class_lookups = htab_create (37, 
442                                           htab_hash_string, 
443                                           memoized_class_lookup_eq,
444                                           NULL);
445
446   /* Loop for this class in the hashtable.  If it is present, we've
447      already looked for this class and failed to find it.  */
448   hash = htab_hash_string (classname);
449   if (htab_find_with_hash (memoized_class_lookups, classname, hash))
450     return NULL;
451
452   /* Allocate and zero out the buffer, since we don't explicitly put a
453      null pointer when we're copying it below.  */
454   buflen = jcf_path_max_len () + classname_length + 10;
455   buffer = ALLOC (buflen);
456   memset (buffer, 0, buflen);
457
458   java_buffer = alloca (buflen);
459
460   jcf->java_source = 0;
461
462   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
463     {
464       const char *path_name = jcf_path_name (entry);
465       if (class != 0)
466         {
467           int dir_len;
468
469           strcpy (buffer, path_name);
470           i = strlen (buffer);
471
472           /* This is right because we know that `.zip' entries will have a
473              trailing slash.  See jcf-path.c.  */
474           dir_len = i - 1;
475
476           for (k = 0; k < classname_length; k++, i++)
477             {
478               char ch = classname[k];
479               buffer[i] = ch == '.' ? '/' : ch;
480             }
481           strcpy (buffer+i, ".class");
482
483           if (jcf_path_is_zipfile (entry))
484             {
485               int err_code;
486               JCF _jcf;
487               buffer[dir_len] = '\0';
488               SOURCE_FRONTEND_DEBUG 
489                 (("Trying [...%s]:%s", 
490                   &buffer[dir_len-(dir_len > 15 ? 15 : dir_len)], 
491                   buffer+dir_len+1));
492               if (jcf == NULL)
493                 jcf = &_jcf;
494               err_code = open_in_zip (jcf, buffer, buffer+dir_len+1,
495                                       jcf_path_is_system (entry));
496               if (err_code == 0)
497                 {
498                   /* Should we check if .zip is out-of-date wrt .java? */
499                   buffer[dir_len] = '(';
500                   strcpy (buffer+i, ".class)");
501                   if (jcf == &_jcf)
502                     JCF_FINISH (jcf);
503                   return buffer;
504                 }
505               else
506                 continue;
507             }
508           class = caching_stat(buffer, &class_buf);
509         }
510
511       if (source_ok)
512         {
513           /* Compute name of .java file.  */
514           int l, m;
515           strcpy (java_buffer, path_name);
516           l = strlen (java_buffer);
517           for (m = 0; m < classname_length; ++m)
518             java_buffer[m + l] = (classname[m] == '.'
519                                   ? DIR_SEPARATOR : classname[m]);
520           strcpy (java_buffer + m + l, ".java");
521           java = caching_stat (java_buffer, &java_buf);
522           if (java == 0)
523             break;
524         }
525     }
526
527   /* We preferably pick a class file if we have a chance. If the source
528      file is newer than the class file, we issue a warning and parse the
529      source file instead.
530      There should be a flag to allow people have the class file picked
531      up no matter what. FIXME. */
532   if (! java && ! class && java_buf.st_mtime > class_buf.st_mtime)
533     {
534       if (flag_newer)
535         warning ("source file for class `%s' is newer than its matching class file.  Source file `%s' used instead", classname, java_buffer);
536       class = -1;
537     }
538
539   if (! java)
540     dep_file = java_buffer;
541   else
542     dep_file = buffer;
543   if (!class)
544     {
545       SOURCE_FRONTEND_DEBUG ((stderr, "[Class selected: %s]\n",
546                               classname+classname_length-
547                               (classname_length <= 30 ? 
548                                classname_length : 30)));
549       fd = JCF_OPEN_EXACT_CASE (buffer, O_RDONLY | O_BINARY);
550       if (fd >= 0)
551         goto found;
552     }
553   /* Give .java a try, if necessary */
554   if (!java)
555     {
556       strcpy (buffer, java_buffer);
557       SOURCE_FRONTEND_DEBUG ((stderr, "[Source selected: %s]\n",
558                               classname+classname_length-
559                               (classname_length <= 30 ? 
560                                classname_length : 30)));
561       fd = JCF_OPEN_EXACT_CASE (buffer, O_RDONLY);
562       if (fd >= 0)
563         {
564           jcf->java_source = 1;
565           goto found;
566         }
567     }
568
569   free (buffer);
570
571   /* Remember that this class could not be found so that we do not
572      have to look again.  */
573   *htab_find_slot_with_hash (memoized_class_lookups, classname, hash, INSERT) 
574     = (void *) classname;
575
576   return NULL;
577  found:
578   if (jcf->java_source)
579     {
580       JCF_ZERO (jcf);           /* JCF_FINISH relies on this */
581       jcf->java_source = 1;
582       jcf->filename = xstrdup (buffer);
583       close (fd);               /* We use STDIO for source file */
584     }
585   else
586     buffer = (char *) open_class (buffer, jcf, fd, dep_file);
587   jcf->classname = xstrdup (classname);
588   return buffer;
589 }
590
591 void
592 jcf_print_char (FILE *stream, int ch)
593 {
594   switch (ch)
595     {
596     case '\'':
597     case '\\':
598     case '\"':
599       fprintf (stream, "\\%c", ch);
600       break;
601     case '\n':
602       fprintf (stream, "\\n");
603       break;
604     case '\t':
605       fprintf (stream, "\\t");
606       break;
607     case '\r':
608       fprintf (stream, "\\r");
609       break;
610     default:
611       if (ch >= ' ' && ch < 127)
612         putc (ch, stream);
613       else if (ch < 256)
614         fprintf (stream, "\\%03x", ch);
615       else
616         fprintf (stream, "\\u%04x", ch);
617     }
618 }
619
620 /* Print UTF8 string at STR of length LENGTH bytes to STREAM. */
621
622 void
623 jcf_print_utf8 (FILE *stream, const unsigned char *str, int length)
624 {
625   const unsigned char * limit = str + length;
626   while (str < limit)
627     {
628       int ch = UTF8_GET (str, limit);
629       if (ch < 0)
630         {
631           fprintf (stream, "\\<invalid>");
632           return;
633         }
634       jcf_print_char (stream, ch);
635     }
636 }
637
638 /* Same as jcf_print_utf8, but print IN_CHAR as OUT_CHAR. */
639
640 void
641 jcf_print_utf8_replace (FILE *stream, const unsigned char *str, int length,
642                         int in_char, int out_char)
643 {
644   const unsigned char *limit = str + length;
645   while (str < limit)
646     {
647       int ch = UTF8_GET (str, limit);
648       if (ch < 0)
649         {
650           fprintf (stream, "\\<invalid>");
651           return;
652         }
653       jcf_print_char (stream, ch == in_char ? out_char : ch);
654     }
655 }
656
657 /* Check that all the cross-references in the constant pool are
658    valid.  Returns 0 on success.
659    Otherwise, returns the index of the (first) invalid entry.
660    Only checks internal consistency, but does not check that
661    any classes, fields, or methods are valid.*/
662
663 int
664 verify_constant_pool (JCF *jcf)
665 {
666   int i, n;
667   for (i = 1; i < JPOOL_SIZE (jcf); i++)
668     {
669       switch (JPOOL_TAG (jcf, i))
670         {
671         case CONSTANT_NameAndType:
672           n = JPOOL_USHORT2 (jcf, i);
673           if (n <= 0 || n >= JPOOL_SIZE(jcf)
674               || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
675             return i;
676           /* ... fall through ... */
677         case CONSTANT_Class:
678         case CONSTANT_String:
679           n = JPOOL_USHORT1 (jcf, i);
680           if (n <= 0 || n >= JPOOL_SIZE(jcf)
681               || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
682             return i;
683           break;
684         case CONSTANT_Fieldref:
685         case CONSTANT_Methodref:
686         case CONSTANT_InterfaceMethodref:
687           n = JPOOL_USHORT1 (jcf, i);
688           if (n <= 0 || n >= JPOOL_SIZE(jcf)
689               || JPOOL_TAG (jcf, n) != CONSTANT_Class)
690             return i;
691           n = JPOOL_USHORT2 (jcf, i);
692           if (n <= 0 || n >= JPOOL_SIZE(jcf)
693               || JPOOL_TAG (jcf, n) != CONSTANT_NameAndType)
694             return i;
695           break;
696         case CONSTANT_Long:
697         case CONSTANT_Double:
698           i++;
699           break;
700         case CONSTANT_Float:
701         case CONSTANT_Integer:
702         case CONSTANT_Utf8:
703         case CONSTANT_Unicode:
704           break;
705         default:
706           return i;
707         }
708     }
709   return 0;
710 }
711
712 void
713 format_uint (char *buffer, uint64 value, int base)
714 {
715 #define WRITE_BUF_SIZE (4 + sizeof(uint64) * 8)
716   char buf[WRITE_BUF_SIZE];
717   char *buf_ptr = buf+WRITE_BUF_SIZE; /* End of buf. */
718   int chars_written;
719   int i;
720
721   /* Now do the actual conversion, placing the result at the *end* of buf. */
722   /* Note this code does not pretend to be optimized. */
723   do {
724     int digit = value % base;
725     static const char digit_chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
726     *--buf_ptr = digit_chars[digit];
727     value /= base;
728   } while (value != 0);
729
730   chars_written = buf+WRITE_BUF_SIZE - buf_ptr;
731   for (i = 0; i < chars_written; i++)
732     buffer[i] = *buf_ptr++;
733   buffer[i] = 0;
734 }
735
736 void
737 format_int (char *buffer, jlong value, int base)
738 {
739   uint64 abs_value;
740   if (value < 0)
741     {
742       abs_value = -(uint64)value;
743       *buffer++ = '-';
744     }
745   else
746     abs_value = (uint64) value;
747   format_uint (buffer, abs_value, base);
748 }