home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / g77-0.5.15-src.tgz / tar.out / fsf / g77 / f / sts.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  6KB  |  271 lines
  1. /* sts.c -- Implementation File (module.c template V1.0)
  2.    Copyright (C) 1995 Free Software Foundation, Inc.
  3.    Contributed by James Craig Burley (burley@gnu.ai.mit.edu).
  4.  
  5. This file is part of GNU Fortran.
  6.  
  7. GNU Fortran 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. GNU Fortran 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 GNU Fortran; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.    Related Modules:
  22.       None (despite the name, it doesn't really depend on ffest*)
  23.  
  24.    Description:
  25.       Provides an arbitrary-length string facility for the limited needs of
  26.       GNU Fortran FORMAT statement generation.
  27.  
  28.    Modifications:
  29. */
  30.  
  31. /* Include files. */
  32.  
  33. #include "proj.h"
  34. #include "sts.h"
  35. #include "com.h"
  36. #include "malloc.h"
  37.  
  38. /* Externals defined here. */
  39.  
  40.  
  41. /* Simple definitions and enumerations. */
  42.  
  43.  
  44. /* Internal typedefs. */
  45.  
  46.  
  47. /* Private include files. */
  48.  
  49.  
  50. /* Internal structure definitions. */
  51.  
  52.  
  53. /* Static objects accessed by functions in this module. */
  54.  
  55.  
  56. /* Static functions (internal). */
  57.  
  58.  
  59. /* Internal macros. */
  60.  
  61.  
  62. /* ffests_kill -- Kill a varying-length string
  63.  
  64.    ffests s;
  65.    ffests_kill(s);
  66.  
  67.    The storage associated with the string <s> is freed.     */
  68.  
  69. void
  70. ffests_kill (ffests s)
  71. {
  72.   if (s->text_ != NULL)
  73.     malloc_kill_ksr (s->pool_, s->text_, s->max_);
  74. }
  75.  
  76. /* ffests_new -- Make a varying-length string
  77.  
  78.    ffests s;
  79.    ffests_new(s,malloc_pool_image(),0);
  80.  
  81.    The string is initialized to hold, in this case, 0 characters, and
  82.    current and future heap manipulations to hold the string will use
  83.    the image pool.  */
  84.  
  85. void
  86. ffests_new (ffests s, mallocPool pool, ffestsLength size)
  87. {
  88.   s->pool_ = pool;
  89.   s->len_ = 0;
  90.   s->max_ = size;
  91.  
  92.   if (size == 0)
  93.     s->text_ = NULL;
  94.   else
  95.     s->text_ = malloc_new_ksr (pool, "ffests", size);
  96. }
  97.  
  98. /* ffests_printf_1D -- printf("...%ld...",(long)) to a string
  99.  
  100.    ffests s;
  101.    ffests_printf_1D(s,"...%ld...",1);
  102.  
  103.    Like printf, but into a string.  */
  104.  
  105. void
  106. ffests_printf_1D (ffests s, char *ctl, long arg1)
  107. {
  108.   char quickbuf[40];
  109.   char *buff;
  110.   ffestsLength len;
  111.  
  112.   if ((len = strlen (ctl) + 21) < ARRAY_SIZE (quickbuf))
  113.     /* No # bigger than 20 digits. */
  114.     {
  115.       sprintf (&quickbuf[0], ctl, arg1);
  116.       ffests_puttext (s, &quickbuf[0], strlen (quickbuf));
  117.     }
  118.   else
  119.     {
  120.       buff = malloc_new_ks (malloc_pool_image (), "ffests_printf_1D", len);
  121.       sprintf (buff, ctl, arg1);
  122.       ffests_puttext (s, buff, strlen (buff));
  123.       malloc_kill_ks (malloc_pool_image (), buff, len);
  124.     }
  125. }
  126.  
  127. /* ffests_printf_1U -- printf("...%lu...",(unsigned long)) to a string
  128.  
  129.    ffests s;
  130.    ffests_printf_1U(s,"...%lu...",1);
  131.  
  132.    Like printf, but into a string.  */
  133.  
  134. void
  135. ffests_printf_1U (ffests s, char *ctl, unsigned long arg1)
  136. {
  137.   char quickbuf[40];
  138.   char *buff;
  139.   ffestsLength len;
  140.  
  141.   if ((len = strlen (ctl) + 21) < ARRAY_SIZE (quickbuf))
  142.     /* No # bigger than 20 digits. */
  143.     {
  144.       sprintf (&quickbuf[0], ctl, arg1);
  145.       ffests_puttext (s, &quickbuf[0], strlen (quickbuf));
  146.     }
  147.   else
  148.     {
  149.       buff = malloc_new_ks (malloc_pool_image (), "ffests_printf_1U", len);
  150.       sprintf (buff, ctl, arg1);
  151.       ffests_puttext (s, buff, strlen (buff));
  152.       malloc_kill_ks (malloc_pool_image (), buff, len);
  153.     }
  154. }
  155.  
  156. /* ffests_printf_1s -- printf("...%s...",(char *)) to a string
  157.  
  158.    ffests s;
  159.    ffests_printf_1s(s,"...%s...","hi there!");
  160.  
  161.    Like printf, but into a string.  */
  162.  
  163. void
  164. ffests_printf_1s (ffests s, char *ctl, char *arg1)
  165. {
  166.   char quickbuf[40];
  167.   char *buff;
  168.   ffestsLength len;
  169.  
  170.   if ((len = strlen (ctl) + strlen (arg1) - 1) < ARRAY_SIZE (quickbuf))
  171.     {
  172.       sprintf (&quickbuf[0], ctl, arg1);
  173.       ffests_puttext (s, &quickbuf[0], strlen (quickbuf));
  174.     }
  175.   else
  176.     {
  177.       buff = malloc_new_ks (malloc_pool_image (), "ffests_printf_1s", len);
  178.       sprintf (buff, ctl, arg1);
  179.       ffests_puttext (s, buff, strlen (buff));
  180.       malloc_kill_ks (malloc_pool_image (), buff, len);
  181.     }
  182. }
  183.  
  184. /* ffests_printf_2Us -- printf("...%lu...%s...",...) to a string
  185.  
  186.    ffests s;
  187.    ffests_printf_2Us(s,"...%lu...%s...",1,"hi there!");
  188.  
  189.    Like printf, but into a string.  */
  190.  
  191. void
  192. ffests_printf_2Us (ffests s, char *ctl, unsigned long arg1, char *arg2)
  193. {
  194.   char quickbuf[60];
  195.   char *buff;
  196.   ffestsLength len;
  197.  
  198.   if ((len = strlen (ctl) + 21 + strlen (arg2) - 1) < ARRAY_SIZE (quickbuf))
  199.     /* No # bigger than 20 digits. */
  200.     {
  201.       sprintf (&quickbuf[0], ctl, arg1, arg2);
  202.       ffests_puttext (s, &quickbuf[0], strlen (quickbuf));
  203.     }
  204.   else
  205.     {
  206.       buff = malloc_new_ks (malloc_pool_image (), "ffests_printf_2Us", len);
  207.       sprintf (buff, ctl, arg1, arg2);
  208.       ffests_puttext (s, buff, strlen (buff));
  209.       malloc_kill_ks (malloc_pool_image (), buff, len);
  210.     }
  211. }
  212.  
  213. /* ffests_putc -- Put a single character into string
  214.  
  215.    ffests s;
  216.    ffests_putc(s,'*');    */
  217.  
  218. void
  219. ffests_putc (ffests s, char c)
  220. {
  221.   ffests_puttext (s, &c, 1);
  222. }
  223.  
  224. /* ffests_puts -- Put a zero-terminated (C-style) string into string
  225.  
  226.    ffests s;
  227.    ffests_puts(s,"append me");    */
  228.  
  229. void
  230. ffests_puts (ffests s, char *string)
  231. {
  232.   ffests_puttext (s, string, strlen (string));
  233. }
  234.  
  235. /* ffests_puttext -- Put a number of characters into string
  236.  
  237.    ffests s;
  238.    ffests_puttext(s,"hi there",8);
  239.  
  240.    The string need not be 0-terminated, because the passed length is used,
  241.    and may be 0.  */
  242.  
  243. void
  244. ffests_puttext (ffests s, char *text, ffestsLength length)
  245. {
  246.   ffestsLength newlen;
  247.   ffestsLength newmax;
  248.  
  249.   if (length <= 0)
  250.     return;
  251.  
  252.   newlen = s->len_ + length;
  253.   if (newlen > s->max_)
  254.     if (s->text_ == NULL)
  255.       {
  256.     s->max_ = 40;
  257.     s->text_ = malloc_new_ksr (s->pool_, "ffests", s->max_);
  258.       }
  259.     else
  260.       {
  261.     newmax = s->max_ << 1;
  262.     while (newmax < newlen)
  263.       newmax <<= 1;
  264.     s->text_ = malloc_resize_ksr (s->pool_, s->text_, newmax, s->max_);
  265.     s->max_ = newmax;
  266.       }
  267.  
  268.   memcpy (s->text_ + s->len_, text, length);
  269.   s->len_ = newlen;
  270. }
  271.