home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / bc-1.03-src.tgz / tar.out / fsf / bc / util.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  17KB  |  819 lines
  1. /* util.c: Utility routines for bc. */
  2.  
  3. /*  This file is part of bc written for MINIX.
  4.     Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
  5.  
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License , or
  9.     (at your option) any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; see the file COPYING.  If not, write to
  18.     the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.     You may contact the author by:
  21.        e-mail:  phil@cs.wwu.edu
  22.       us-mail:  Philip A. Nelson
  23.                 Computer Science Department, 9062
  24.                 Western Washington University
  25.                 Bellingham, WA 98226-9062
  26.        
  27. *************************************************************************/
  28.  
  29.  
  30. #include "bcdefs.h"
  31. #ifndef VARARGS
  32. #include <stdarg.h>
  33. #else
  34. #include <varargs.h>
  35. #endif
  36. #include "global.h"
  37. #include "proto.h"
  38.  
  39.  
  40. /* strcopyof mallocs new memory and copies a string to to the new
  41.    memory. */
  42.  
  43. char *
  44. strcopyof (str)
  45.      char *str;
  46. {
  47.   char *temp;
  48.  
  49.   temp = (char *) bc_malloc (strlen (str)+1);
  50.   return (strcpy (temp,str));
  51. }
  52.  
  53.  
  54. /* nextarg adds another value to the list of arguments. */
  55.  
  56. arg_list *
  57. nextarg (args, val)
  58.      arg_list *args;
  59.      int val;
  60. { arg_list *temp;
  61.  
  62.   temp = (arg_list *) bc_malloc (sizeof (arg_list));
  63.   temp->av_name = val;
  64.   temp->next = args;
  65.  
  66.   return (temp);
  67. }
  68.  
  69.  
  70. /* For generate, we must produce a string in the form
  71.     "val,val,...,val".  We also need a couple of static variables
  72.    for retaining old generated strings.  It also uses a recursive
  73.    function that builds the string. */
  74.  
  75. static char *arglist1 = NULL, *arglist2 = NULL;
  76.  
  77.  
  78. /* make_arg_str does the actual construction of the argument string.
  79.    ARGS is the pointer to the list and LEN is the maximum number of
  80.    characters needed.  1 char is the minimum needed. 
  81.  */
  82.  
  83. _PROTOTYPE (static char *make_arg_str, (arg_list *args, int len));
  84.  
  85. static char *
  86. make_arg_str (args, len)
  87.       arg_list *args;
  88.       int len;
  89. {
  90.   char *temp;
  91.   char sval[20];
  92.  
  93.   /* Recursive call. */
  94.   if (args != NULL)
  95.     temp = make_arg_str (args->next, len+11);
  96.   else
  97.     {
  98.       temp = (char *) bc_malloc (len);
  99.       *temp = 0;
  100.       return temp;
  101.     }
  102.  
  103.   /* Add the current number to the end of the string. */
  104.   if (len != 1) 
  105.     sprintf (sval, "%d,", args->av_name);
  106.   else
  107.     sprintf (sval, "%d", args->av_name);
  108.   temp = strcat (temp, sval);
  109.   return (temp);
  110. }
  111.  
  112. char *
  113. arg_str (args)
  114.      arg_list *args;
  115. {
  116.   if (arglist2 != NULL) 
  117.     free (arglist2);
  118.   arglist2 = arglist1;
  119.   arglist1 = make_arg_str (args, 1);
  120.   return (arglist1);
  121. }
  122.  
  123. char *
  124. call_str (args)
  125.      arg_list *args;
  126. {
  127.   arg_list *temp;
  128.   int       arg_count;
  129.   int       ix;
  130.   
  131.   if (arglist2 != NULL) 
  132.     free (arglist2);
  133.   arglist2 = arglist1;
  134.  
  135.   /* Count the number of args and add the 0's and 1's. */
  136.   for (temp = args, arg_count = 0; temp != NULL; temp = temp->next)
  137.     arg_count++;
  138.   arglist1 = (char *) bc_malloc(arg_count+1);
  139.   for (temp = args, ix=0; temp != NULL; temp = temp->next)
  140.     arglist1[ix++] = ( temp->av_name ? '1' : '0');
  141.   arglist1[ix] = 0;
  142.       
  143.   return (arglist1);
  144. }
  145.  
  146. /* free_args frees an argument list ARGS. */
  147.  
  148. void
  149. free_args (args)
  150.       arg_list *args;
  151. { 
  152.   arg_list *temp;
  153.  
  154.   temp = args;
  155.   while (temp != NULL)
  156.     {
  157.       args = args->next;
  158.       free (temp);
  159.       temp = args;
  160.     }
  161. }
  162.  
  163.  
  164. /* Check for valid parameter (PARAMS) and auto (AUTOS) lists.
  165.    There must be no duplicates any where.  Also, this is where
  166.    warnings are generated for array parameters. */
  167.  
  168. void
  169. check_params ( params, autos )
  170.      arg_list *params, *autos;
  171. {
  172.   arg_list *tmp1, *tmp2;
  173.  
  174.   /* Check for duplicate parameters. */
  175.   if (params != NULL)
  176.     {
  177.       tmp1 = params;
  178.       while (tmp1 != NULL)
  179.     {
  180.       tmp2 = tmp1->next;
  181.       while (tmp2 != NULL)
  182.         {
  183.           if (tmp2->av_name == tmp1->av_name) 
  184.         yyerror ("duplicate parameter names");
  185.           tmp2 = tmp2->next;
  186.         }
  187.       if (tmp1->av_name < 0)
  188.         warn ("Array parameter");
  189.       tmp1 = tmp1->next;
  190.     }
  191.     }
  192.  
  193.   /* Check for duplicate autos. */
  194.   if (autos != NULL)
  195.     {
  196.       tmp1 = autos;
  197.       while (tmp1 != NULL)
  198.     {
  199.       tmp2 = tmp1->next;
  200.       while (tmp2 != NULL)
  201.         {
  202.           if (tmp2->av_name == tmp1->av_name) 
  203.         yyerror ("duplicate auto variable names");
  204.           tmp2 = tmp2->next;
  205.         }
  206.       tmp1 = tmp1->next;
  207.     }
  208.     }
  209.  
  210.   /* Check for duplicate between parameters and autos. */
  211.   if ((params != NULL) && (autos != NULL))
  212.     {
  213.       tmp1 = params;
  214.       while (tmp1 != NULL)
  215.     {
  216.       tmp2 = autos;
  217.       while (tmp2 != NULL)
  218.         {
  219.           if (tmp2->av_name == tmp1->av_name) 
  220.         yyerror ("variable in both parameter and auto lists");
  221.           tmp2 = tmp2->next;
  222.         }
  223.       tmp1 = tmp1->next;
  224.     }
  225.     }
  226. }
  227.  
  228.  
  229. /* Initialize the code generator the parser. */
  230.  
  231. void
  232. init_gen ()
  233. {
  234.   /* Get things ready. */
  235.   break_label = 0;
  236.   continue_label = 0;
  237.   next_label  = 1;
  238.   out_count = 2;
  239.   if (compile_only) 
  240.     printf ("@i");
  241.   else
  242.     init_load ();
  243.   had_error = FALSE;
  244.   did_gen = FALSE;
  245. }
  246.  
  247.  
  248. /* generate code STR for the machine. */
  249.  
  250. void
  251. generate (str)
  252.       char *str;
  253. {
  254.   did_gen = TRUE;
  255.   if (compile_only)
  256.     {
  257.       printf ("%s",str);
  258.       out_count += strlen(str);
  259.       if (out_count > 60)
  260.     {
  261.       printf ("\n");
  262.       out_count = 0;
  263.     }
  264.     }
  265.   else
  266.     load_code (str);
  267. }
  268.  
  269.  
  270. /* Execute the current code as loaded. */
  271.  
  272. void
  273. run_code()
  274. {
  275.   /* If no compile errors run the current code. */
  276.   if (!had_error && did_gen)
  277.     {
  278.       if (compile_only)
  279.     {
  280.       printf ("@r\n"); 
  281.       out_count = 0;
  282.     }
  283.       else
  284.     execute ();
  285.     }
  286.  
  287.   /* Reinitialize the code generation and machine. */
  288.   if (did_gen)
  289.     init_gen();
  290.   else
  291.     had_error = FALSE;
  292. }
  293.  
  294.  
  295. /* Output routines: Write a character CH to the standard output.
  296.    It keeps track of the number of characters output and may
  297.    break the output with a "\<cr>". */
  298.  
  299. void
  300. out_char (ch)
  301.      char ch;
  302. {
  303.   if (ch == '\n')
  304.     {
  305.       out_col = 0;
  306.       putchar ('\n');
  307.     }
  308.   else
  309.     {
  310.       out_col++;
  311.       if (out_col == 70)
  312.     {
  313.       putchar ('\\');
  314.       putchar ('\n');
  315.       out_col = 1;
  316.     }
  317.       putchar (ch);
  318.     }
  319. }
  320.  
  321.  
  322. /* The following are "Symbol Table" routines for the parser. */
  323.  
  324. /*  find_id returns a pointer to node in TREE that has the correct
  325.     ID.  If there is no node in TREE with ID, NULL is returned. */
  326.  
  327. id_rec *
  328. find_id (tree, id)
  329.      id_rec *tree;
  330.      char   *id;
  331. {
  332.   int cmp_result;
  333.   
  334.   /* Check for an empty tree. */
  335.   if (tree == NULL)
  336.     return NULL;
  337.  
  338.   /* Recursively search the tree. */
  339.   cmp_result = strcmp (id, tree->id);
  340.   if (cmp_result == 0)
  341.     return tree;  /* This is the item. */
  342.   else if (cmp_result < 0)
  343.     return find_id (tree->left, id);
  344.   else
  345.     return find_id (tree->right, id);  
  346. }
  347.  
  348.  
  349. /* insert_id_rec inserts a NEW_ID rec into the tree whose ROOT is
  350.    provided.  insert_id_rec returns TRUE if the tree height from
  351.    ROOT down is increased otherwise it returns FALSE.  This is a
  352.    recursive balanced binary tree insertion algorithm. */
  353.  
  354. int insert_id_rec (root, new_id)
  355.      id_rec **root;
  356.      id_rec *new_id;
  357. {
  358.   id_rec *A, *B;
  359.  
  360.   /* If root is NULL, this where it is to be inserted. */
  361.   if (*root == NULL)
  362.     {
  363.       *root = new_id;
  364.       new_id->left = NULL;
  365.       new_id->right = NULL;
  366.       new_id->balance = 0;
  367.       return (TRUE);
  368.     }
  369.  
  370.   /* We need to search for a leaf. */
  371.   if (strcmp (new_id->id, (*root)->id) < 0)
  372.     {
  373.       /* Insert it on the left. */
  374.       if (insert_id_rec (&((*root)->left), new_id))
  375.     {
  376.       /* The height increased. */
  377.       (*root)->balance --;
  378.       
  379.       switch ((*root)->balance)
  380.     {
  381.     case  0:  /* no height increase. */
  382.       return (FALSE);
  383.     case -1:  /* height increase. */
  384.       return (FALSE);
  385.     case -2:  /* we need to do a rebalancing act. */
  386.       A = *root;
  387.       B = (*root)->left;
  388.       if (B->balance <= 0)
  389.         {
  390.           /* Single Rotate. */
  391.           A->left = B->right;
  392.           B->right = A;
  393.           *root = B;
  394.           A->balance = 0;
  395.           B->balance = 0;
  396.         }
  397.       else
  398.         {
  399.           /* Double Rotate. */
  400.           *root = B->right;
  401.           B->right = (*root)->left;
  402.           A->left = (*root)->right;
  403.           (*root)->left = B;
  404.           (*root)->right = A;
  405.           switch ((*root)->balance)
  406.         {
  407.         case -1:
  408.           A->balance = 1;
  409.           B->balance = 0;
  410.           break;
  411.         case  0:
  412.           A->balance = 0;
  413.           B->balance = 0;
  414.           break;
  415.         case  1:
  416.           A->balance = 0;
  417.           B->balance = -1;
  418.           break;
  419.         }
  420.           (*root)->balance = 0;
  421.         }
  422.     }     
  423.     } 
  424.     }
  425.   else
  426.     {
  427.       /* Insert it on the right. */
  428.       if (insert_id_rec (&((*root)->right), new_id))
  429.     {
  430.       /* The height increased. */
  431.       (*root)->balance ++;
  432.       switch ((*root)->balance)
  433.         {
  434.         case 0:  /* no height increase. */
  435.           return (FALSE);
  436.         case 1:  /* height increase. */
  437.           return (FALSE);
  438.         case 2:  /* we need to do a rebalancing act. */
  439.           A = *root;
  440.           B = (*root)->right;
  441.           if (B->balance >= 0)
  442.         {
  443.           /* Single Rotate. */
  444.           A->right = B->left;
  445.           B->left = A;
  446.           *root = B;
  447.           A->balance = 0;
  448.           B->balance = 0;
  449.         }
  450.           else
  451.         {
  452.           /* Double Rotate. */
  453.           *root = B->left;
  454.           B->left = (*root)->right;
  455.           A->right = (*root)->left;
  456.           (*root)->left = A;
  457.           (*root)->right = B;
  458.           switch ((*root)->balance)
  459.             {
  460.             case -1:
  461.               A->balance = 0;
  462.               B->balance = 1;
  463.               break;
  464.             case  0:
  465.               A->balance = 0;
  466.               B->balance = 0;
  467.               break;
  468.             case  1:
  469.               A->balance = -1;
  470.               B->balance = 0;
  471.               break;
  472.             }
  473.           (*root)->balance = 0;
  474.         }
  475.         }     
  476.     } 
  477.     }
  478.   
  479.   /* If we fall through to here, the tree did not grow in height. */
  480.   return (FALSE);
  481. }
  482.  
  483.  
  484. /* Initialize variables for the symbol table tree. */
  485.  
  486. void
  487. init_tree()
  488. {
  489.   name_tree  = NULL;
  490.   next_array = 1;
  491.   next_func  = 1;
  492.   next_var   = 4;  /* 0 => ibase, 1 => obase, 2 => scale, 3 => last. */
  493. }
  494.  
  495.  
  496. /* Lookup routines for symbol table names. */
  497.  
  498. int
  499. lookup (name, namekind)
  500.      char *name;
  501.      int  namekind;
  502. {
  503.   id_rec *id;
  504.  
  505.   /* Warn about non-standard name. */
  506.   if (strlen(name) != 1)
  507.     warn ("multiple letter name - %s", name);
  508.  
  509.   /* Look for the id. */
  510.   id = find_id (name_tree, name);
  511.   if (id == NULL)
  512.     {
  513.       /* We need to make a new item. */
  514.       id = (id_rec *) bc_malloc (sizeof (id_rec));
  515.       id->id = strcopyof (name);
  516.       id->a_name = 0;
  517.       id->f_name = 0;
  518.       id->v_name = 0;
  519.       insert_id_rec (&name_tree, id);
  520.     }
  521.  
  522.   /* Return the correct value. */
  523.   switch (namekind)
  524.     {
  525.       
  526.     case ARRAY:
  527.       /* ARRAY variable numbers are returned as negative numbers. */
  528.       if (id->a_name != 0)
  529.     {
  530.       free (name);
  531.       return (-id->a_name);
  532.     }
  533.       id->a_name = next_array++;
  534.       a_names[id->a_name] = name;
  535.       if (id->a_name < MAX_STORE)
  536.     {
  537.       if (id->a_name >= a_count)
  538.         more_arrays ();
  539.       return (-id->a_name);
  540.     }
  541.       yyerror ("Too many array variables");
  542.       exit (1);
  543.  
  544.     case FUNCT:
  545.     case FUNCTDEF:
  546.       if (id->f_name != 0)
  547.     {
  548.       free(name);
  549.       /* Check to see if we are redefining a math lib function. */ 
  550.       if (use_math && namekind == FUNCTDEF && id->f_name <= 6)
  551.         id->f_name = next_func++;
  552.       return (id->f_name);
  553.     }
  554.       id->f_name = next_func++;
  555.       f_names[id->f_name] = name;
  556.       if (id->f_name < MAX_STORE)
  557.     {
  558.       if (id->f_name >= f_count)
  559.         more_functions ();
  560.       return (id->f_name);
  561.     }
  562.       yyerror ("Too many functions");
  563.       exit (1);
  564.  
  565.     case SIMPLE:
  566.       if (id->v_name != 0)
  567.     {
  568.       free(name);
  569.       return (id->v_name);
  570.     }
  571.       id->v_name = next_var++;
  572.       v_names[id->v_name - 1] = name;
  573.       if (id->v_name <= MAX_STORE)
  574.     {
  575.       if (id->v_name >= v_count)
  576.         more_variables ();
  577.       return (id->v_name);
  578.     }
  579.       yyerror ("Too many variables");
  580.       exit (1);
  581.     }
  582. }
  583.  
  584.  
  585. /* Print the welcome banner. */
  586.  
  587. void 
  588. welcome()
  589. {
  590.   printf ("This is free software with ABSOLUTELY NO WARRANTY.\n");
  591.   printf ("For details type `warranty'. \n");
  592. }
  593.  
  594.  
  595. /* Print out the warranty information. */
  596.  
  597. void 
  598. warranty(prefix)
  599.      char *prefix;
  600. {
  601.   printf ("\n%s%s\n\n", prefix, BC_VERSION);
  602.   printf ("%s%s%s%s%s%s%s%s%s%s%s",
  603. "    This program is free software; you can redistribute it and/or modify\n",
  604. "    it under the terms of the GNU General Public License as published by\n",
  605. "    the Free Software Foundation; either version 2 of the License , or\n",
  606. "    (at your option) any later version.\n\n",
  607. "    This program is distributed in the hope that it will be useful,\n",
  608. "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
  609. "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
  610. "    GNU General Public License for more details.\n\n",
  611. "    You should have received a copy of the GNU General Public License\n",
  612. "    along with this program. If not, write to the Free Software\n",
  613. "    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.\n\n");
  614. }
  615.  
  616. /* Print out the limits of this program. */
  617.  
  618. void
  619. limits()
  620. {
  621.   printf ("BC_BASE_MAX     = %d\n",  BC_BASE_MAX);
  622.   printf ("BC_DIM_MAX      = %ld\n", (long) BC_DIM_MAX);
  623.   printf ("BC_SCALE_MAX    = %d\n",  BC_SCALE_MAX);
  624.   printf ("BC_STRING_MAX   = %d\n",  BC_STRING_MAX);
  625.   printf ("MAX Exponent    = %ld\n", (long) LONG_MAX);
  626.   printf ("MAX code        = %ld\n", (long) BC_MAX_SEGS * (long) BC_SEG_SIZE);
  627.   printf ("multiply digits = %ld\n", (long) LONG_MAX / (long) 90);
  628.   printf ("Number of vars  = %ld\n", (long) MAX_STORE);
  629. #ifdef OLD_EQ_OP
  630.   printf ("Old assignment operatiors are valid. (=-, =+, ...)\n");
  631. #endif 
  632. }
  633.  
  634. /* bc_malloc will check the return value so all other places do not
  635.    have to do it!  SIZE is the number of types to allocate. */
  636.  
  637. char *
  638. bc_malloc (size)
  639.      int size;
  640. {
  641.   char *ptr;
  642.  
  643.   ptr = (char *) malloc (size);
  644.   if (ptr == NULL)
  645.     out_of_memory ();
  646.  
  647.   return ptr;
  648. }
  649.  
  650.  
  651. /* The following routines are error routines for various problems. */
  652.  
  653. /* Malloc could not get enought memory. */
  654.  
  655. void
  656. out_of_memory()
  657. {
  658.   fprintf (stderr, "Fatal error: Out of memory for malloc.\n");
  659.   exit (1);
  660. }
  661.  
  662.  
  663.  
  664. /* The standard yyerror routine.  Built with variable number of argumnets. */
  665.  
  666. #ifndef VARARGS
  667. #ifdef __STDC__
  668. void
  669. yyerror (char *str, ...)
  670. #else
  671. void
  672. yyerror (str)
  673.      char *str;
  674. #endif
  675. #else
  676. void
  677. yyerror (str, va_alist)
  678.      char *str;
  679. #endif
  680. {
  681.   char *name;
  682.   va_list args;
  683.  
  684. #ifndef VARARGS   
  685.    va_start (args, str);
  686. #else
  687.    va_start (args);
  688. #endif
  689.   if (is_std_in)
  690.     name = "(standard_in)";
  691.   else
  692.     name = g_argv[optind-1];
  693.   fprintf (stderr,"%s %d: ",name,line_no);
  694.   vfprintf (stderr, str, args);
  695.   fprintf (stderr, "\n");
  696.   had_error = TRUE;
  697.   va_end (args);
  698. }
  699.  
  700.  
  701. /* The routine to produce warnings about non-standard features
  702.    found during parsing. */
  703.  
  704. #ifndef VARARGS
  705. #ifdef __STDC__
  706. void 
  707. warn (char *mesg, ...)
  708. #else
  709. void
  710. warn (mesg)
  711.      char *mesg;
  712. #endif
  713. #else
  714. void
  715. warn (mesg, va_alist)
  716.      char *mesg;
  717. #endif
  718. {
  719.   char *name;
  720.   va_list args;
  721.  
  722. #ifndef VARARGS   
  723.   va_start (args, mesg);
  724. #else
  725.   va_start (args);
  726. #endif
  727.   if (std_only)
  728.     {
  729.       if (is_std_in)
  730.     name = "(standard_in)";
  731.       else
  732.     name = g_argv[optind-1];
  733.       fprintf (stderr,"%s %d: ",name,line_no);
  734.       vfprintf (stderr, mesg, args);
  735.       fprintf (stderr, "\n");
  736.       had_error = TRUE;
  737.     }
  738.   else
  739.     if (warn_not_std)
  740.       {
  741.     if (is_std_in)
  742.       name = "(standard_in)";
  743.     else
  744.       name = g_argv[optind-1];
  745.     fprintf (stderr,"%s %d: (Warning) ",name,line_no);
  746.     vfprintf (stderr, mesg, args);
  747.     fprintf (stderr, "\n");
  748.       }
  749.   va_end (args);
  750. }
  751.  
  752. /* Runtime error will  print a message and stop the machine. */
  753.  
  754. #ifndef VARARGS
  755. #ifdef __STDC__
  756. void
  757. rt_error (char *mesg, ...)
  758. #else
  759. void
  760. rt_error (mesg)
  761.      char *mesg;
  762. #endif
  763. #else
  764. void
  765. rt_error (mesg, va_alist)
  766.      char *mesg;
  767. #endif
  768. {
  769.   va_list args;
  770.   char error_mesg [255];
  771.  
  772. #ifndef VARARGS   
  773.   va_start (args, mesg);
  774. #else
  775.   va_start (args);
  776. #endif
  777.   vsprintf (error_mesg, mesg, args);
  778.   va_end (args);
  779.   
  780.   fprintf (stderr, "Runtime error (func=%s, adr=%d): %s\n",
  781.        f_names[pc.pc_func], pc.pc_addr, error_mesg);
  782.   runtime_error = TRUE;
  783. }
  784.  
  785.  
  786. /* A runtime warning tells of some action taken by the processor that
  787.    may change the program execution but was not enough of a problem
  788.    to stop the execution. */
  789.  
  790. #ifndef VARARGS
  791. #ifdef __STDC__
  792. void
  793. rt_warn (char *mesg, ...)
  794. #else
  795. void
  796. rt_warn (mesg)
  797.      char *mesg;
  798. #endif
  799. #else
  800. void
  801. rt_warn (mesg, va_alist)
  802.      char *mesg;
  803. #endif
  804. {
  805.   va_list args;
  806.   char error_mesg [255];
  807.  
  808. #ifndef VARARGS   
  809.   va_start (args, mesg);
  810. #else
  811.   va_start (args);
  812. #endif
  813.   vsprintf (error_mesg, mesg, args);
  814.   va_end (args);
  815.  
  816.   fprintf (stderr, "Runtime warning (func=%s, adr=%d): %s\n",
  817.        f_names[pc.pc_func], pc.pc_addr, error_mesg);
  818. }
  819.