home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / octave-1.1.1p1-base.tgz / octave-1.1.1p1-base.tar / fsf / octave / src / utils.cc < prev    next >
C/C++ Source or Header  |  1995-02-14  |  15KB  |  842 lines
  1. // utils.cc                                              -*- C++ -*-
  2. /*
  3.  
  4. Copyright (C) 1992, 1993, 1994, 1995 John W. Eaton
  5.  
  6. This file is part of Octave.
  7.  
  8. Octave is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. Octave is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with Octave; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. */
  23.  
  24. #ifdef HAVE_CONFIG_H
  25. #include "config.h"
  26. #endif
  27.  
  28. #include <sys/types.h>
  29. #ifdef HAVE_UNISTD_H
  30. #include <unistd.h>
  31. #endif
  32. #include <sys/param.h>
  33. #include <string.h>
  34. #include <limits.h>
  35. #include <iostream.h>
  36. #include <strstream.h>
  37. #include <fstream.h>
  38.  
  39. #include <Complex.h>
  40.  
  41. extern "C"
  42. {
  43. #include <setjmp.h>
  44.  
  45. #ifndef HAVE_STRNCASECMP
  46. extern int strncasecmp (const char*, const char*, size_t);
  47. #endif
  48.  
  49. #define boolean kpathsea_boolean
  50. #define false kpathsea_false
  51. #define true kpathsea_true
  52. #include <kpathsea/pathsearch.h>
  53.  
  54. #if defined (HAVE_TERMIOS_H)
  55. #include <termios.h>
  56. #elif defined (HAVE_TERMIO_H)
  57. #include <termio.h>
  58. #elif defined (HAVE_SGTTY_H)
  59. #include <sgtty.h>
  60. #else
  61. LOSE! LOSE!
  62. #endif
  63.  
  64. #include <readline/tilde.h>
  65. }
  66.  
  67. // This mess suggested by the autoconf manual.
  68. // unistd.h defines _POSIX_VERSION on POSIX.1 systems.
  69. #if defined (HAVE_DIRENT_H) || defined (_POSIX_VERSION)
  70. #include <dirent.h>
  71. #define NLENGTH(dirent) (strlen((dirent)->d_name))
  72. #else
  73. #define dirent direct
  74. #define NLENGTH(dirent) ((dirent)->d_namlen)
  75. #if defined (HAVE_SYS_NDIR_H)
  76. #include <sys/ndir.h>
  77. #endif
  78. #if defined (HAVE_SYS_DIR_H)
  79. #include <sys/dir.h>
  80. #endif
  81. #if defined (HAVE_NDIR_H)
  82. #include <ndir.h>
  83. #endif
  84. #endif
  85.  
  86. #include "SLStack.h"
  87.  
  88. #include "procstream.h"
  89. #include "user-prefs.h"
  90. #include "variables.h"
  91. #include "dirfns.h"
  92. #include "defun.h"
  93. #include "error.h"
  94. #include "help.h"
  95. #include "gripes.h"
  96. #include "pager.h"
  97. #include "utils.h"
  98. #include "input.h"
  99. #include "octave.h"
  100. #include "oct-obj.h"
  101. #include "mappers.h"
  102. #include "tree-const.h"
  103. #include "unwind-prot.h"
  104. #include "octave-hist.h"
  105.  
  106. // Top level context (?)
  107. extern jmp_buf toplevel;
  108.  
  109. // Save a string.
  110.  
  111. char *
  112. strsave (const char *s)
  113. {
  114.   if (! s)
  115.     return 0;
  116.  
  117.   int len = strlen (s);
  118.   char *tmp = new char [len+1];
  119.   tmp = strcpy (tmp, s);
  120.   return tmp;
  121. }
  122.  
  123. // Concatenate two strings.
  124.  
  125. char *
  126. strconcat (const char *s, const char *t)
  127. {
  128.   int len = strlen (s) + strlen (t);
  129.   char *tmp = new char [len+1];
  130.   strcpy (tmp, s);
  131.   return strcat (tmp, t);
  132. }
  133.  
  134. // Throw away input until a given character is read.
  135.  
  136. void
  137. discard_until (istream& stream, char character)
  138. {
  139.   int c;
  140.   for (;;)
  141.     {
  142.       stream >> c;
  143.       if (c == EOF || c == character)
  144.     break;
  145.     }
  146.   if (c != EOF)
  147.     stream.putback ((char) c);
  148. } 
  149.  
  150. #if 0
  151.  
  152. // XXX UNTESTED XXX
  153.  
  154. // Read input until a given character is read.  Returns characters
  155. // read in a new string that must be freed by the caller.
  156.  
  157. char *
  158. read_until (istream& stream, char character)
  159. {
  160.   int grow_size = 8;
  161.   int limit = grow_size;
  162.   char *buf = new char [limit];
  163.   char *bp = buf;
  164.  
  165.  get_more:
  166.   is.getline (bp, limit, character);
  167.  
  168.   if (is.gcount () == 0)
  169.     {
  170.       delete [] buf;
  171.       return 0;
  172.     }
  173.  
  174.   if (is.gcount () == limit && buf[limit-1] != '\0')
  175.     {
  176.       char *tmp = new char [limit + grow_size];
  177.       strcpy (tmp, buf);
  178.       delete [] buf;
  179.       buf = tmp;
  180.       bp = tmp + limit - 1;
  181.       limit += grow_size;
  182.       grow_size *= 2;
  183.       goto get_more;
  184.     }
  185.  
  186.   return buf;
  187. }
  188. #endif
  189.  
  190. // Get a temporary file name.
  191.  
  192. char *
  193. octave_tmp_file_name (void)
  194. {
  195.   static char *retval = 0;
  196.  
  197.   if (retval)
  198.     free (retval);
  199.  
  200.   retval = tempnam (0, "oct-");
  201.  
  202.   if (! retval)
  203.     error ("can't open temporary file!");
  204.  
  205.   return retval;
  206. }
  207.  
  208. DEFUN ("octave_tmp_file_name", Foctave_tmp_file_name,
  209.        Soctave_tmp_file_name, 0, 1,
  210.  "octave_tmp_file_name ()")
  211. {
  212.   tree_constant retval;
  213.  
  214.   if (args.length () == 0)
  215.     retval = octave_tmp_file_name ();
  216.   else
  217.     print_usage ("octave_tmp_file_name");
  218.  
  219.   return retval;
  220. }
  221.  
  222. char **
  223. pathstring_to_vector (char *pathstring)
  224. {
  225.   static char **path = 0;
  226.  
  227.   if (pathstring)
  228.     {
  229.       int nelem = 0;
  230.       char *tmp_path = strsave (pathstring);
  231.       if (*tmp_path != '\0')
  232.     {
  233.       nelem++;
  234.       char *ptr = tmp_path;
  235.       while (*ptr != '\0')
  236.         {
  237.           if (*ptr == SEPCHAR)
  238.         nelem++;
  239.           ptr++;
  240.         }
  241.     }
  242.  
  243.       char **foo = path;
  244.       while (foo && *foo)
  245.     delete [] *foo++;
  246.       delete [] path;
  247.  
  248.       path = new char * [nelem+1];
  249.       path[nelem] = 0;
  250.  
  251.       int i = 0;
  252.       char *ptr = tmp_path;
  253.       while (i < nelem)
  254.     {
  255.       char *end = strchr (ptr, SEPCHAR);
  256.       if (end)
  257.         *end = '\0';
  258.       char *result = tilde_expand (ptr);
  259.       path[i] = strsave (result);
  260.       free (result);
  261.       ptr = end + 1;
  262.       i++;
  263.     }
  264.  
  265.       delete [] tmp_path;
  266.     }
  267.  
  268.   return path;
  269. }
  270.  
  271. // Return to the main command loop in octave.cc.
  272.  
  273. void
  274. jump_to_top_level (void)
  275. {
  276.   run_all_unwind_protects ();
  277.  
  278.   longjmp (toplevel, 1);
  279. }
  280.  
  281. int
  282. almost_match (const char *std, const char *s, int min_match_len,
  283.           int case_sens)
  284. {
  285.   int stdlen = strlen (std);
  286.   int slen = strlen (s);
  287.  
  288.   return (slen <= stdlen
  289.       && slen >= min_match_len
  290.       && (case_sens
  291.           ? (strncmp (std, s, slen) == 0)
  292.           : (strncasecmp (std, s, slen) == 0)));
  293. }
  294.  
  295. // Ugh.
  296.  
  297. int
  298. keyword_almost_match (const char **std, int *min_len, const char *s,
  299.               int min_toks_to_match, int max_toks)
  300. {
  301.   int status = 0;
  302.   int tok_count = 0;
  303.   int toks_matched = 0;
  304.  
  305.   if (! s || *s == '\0' || max_toks < 1)
  306.     return status;
  307.  
  308.   char *kw = strsave (s);
  309.  
  310.   char *t = kw;
  311.   while (*t != '\0')
  312.     {
  313.       if (*t == '\t')
  314.     *t = ' ';
  315.       t++;
  316.     }
  317.  
  318.   char *beg = kw;
  319.   while (*beg == ' ')
  320.     beg++;
  321.  
  322.   if (*beg == '\0')
  323.     return status;
  324.  
  325.  
  326.   char **to_match = new char * [max_toks + 1];
  327.   const char **s1 = std;
  328.   char **s2 = to_match;
  329.  
  330.   if (! s1 || ! s2)
  331.     goto done;
  332.  
  333.   s2[tok_count] = beg;
  334.   char *end;
  335.   while ((end = strchr (beg, ' ')) != 0)
  336.     {
  337.       *end = '\0';
  338.       beg = end + 1;
  339.  
  340.       while (*beg == ' ')
  341.     beg++;
  342.  
  343.       if (*beg == '\0')
  344.     break;
  345.  
  346.       tok_count++;
  347.       if (tok_count >= max_toks)
  348.     goto done;
  349.  
  350.       s2[tok_count] = beg;
  351.     }
  352.   s2[tok_count+1] = 0;
  353.  
  354.   s2 = to_match;
  355.  
  356.   for (;;)
  357.     {
  358.       if (! almost_match (*s1, *s2, min_len[toks_matched], 0))
  359.     goto done;
  360.  
  361.       toks_matched++;
  362.  
  363.       s1++;
  364.       s2++;
  365.  
  366.       if (! *s2)
  367.     {
  368.       status = (toks_matched >= min_toks_to_match);
  369.       goto done;
  370.     }
  371.  
  372.       if (! *s1)
  373.     goto done;
  374.     }
  375.  
  376.  done:
  377.  
  378.   delete [] kw;
  379.   delete [] to_match;
  380.  
  381.   return status;
  382. }
  383.  
  384. char **
  385. get_fcn_file_names (int& num, const char *dir, int no_suffix)
  386. {
  387.   static int num_max = 256;
  388.   char **retval = new char * [num_max];
  389.   int i = 0;
  390.  
  391.   DIR *dirp = opendir (dir);
  392.   if (dirp)
  393.     {
  394.       struct dirent *entry;
  395.       while ((entry = readdir (dirp)) != 0)
  396.     {
  397.       int len = NLENGTH (entry);
  398. #ifdef WITH_DLD
  399.       if ((len > 2
  400.            && entry->d_name[len-2] == '.'
  401.            && entry->d_name[len-1] == 'm')
  402.           || (len > 4
  403.           && entry->d_name[len-4] == '.'
  404.           && entry->d_name[len-3] == 'o'
  405.           && entry->d_name[len-2] == 'c'
  406.           && entry->d_name[len-1] == 't'))
  407. #else
  408.       if (len > 2
  409.           && entry->d_name[len-2] == '.'
  410.           && entry->d_name[len-1] == 'm')
  411. #endif
  412.         {
  413.           retval[i] = strsave (entry->d_name);
  414.           if (no_suffix)
  415.         {
  416.           if (retval[i][len-1] == 'm')
  417.             retval[i][len-2] = '\0';
  418.           else
  419.             retval[i][len-4] = '\0';
  420.         }
  421.  
  422.           i++;
  423.  
  424.           if (i == num_max - 1)
  425.         {
  426. // Reallocate the array.  Only copy pointers, not the strings they
  427. // point to, then only delete the original array of pointers, and not
  428. // the strings they point to.
  429.  
  430.           num_max += 256;
  431.           char **tmp = new char * [num_max];
  432.           for (int j = 0; j < i; j++)
  433.             tmp[j] = retval[j];
  434.  
  435.           delete [] retval;
  436.  
  437.           retval = tmp;
  438.         }
  439.         }
  440.     }
  441.       closedir (dirp);
  442.     }
  443.  
  444.   retval[i] = 0;
  445.   num = i;
  446.  
  447.   return retval;
  448. }
  449.  
  450. char **
  451. get_fcn_file_names (int& num, int no_suffix)
  452. {
  453.   static int num_max = 1024;
  454.   char **retval = new char * [num_max];
  455.   int i = 0;
  456.  
  457.   char *path_elt = kpse_path_element (user_pref.loadpath);
  458.  
  459.   while (path_elt)
  460.     {
  461.       str_llist_type *elt_dirs = kpse_element_dirs (path_elt);
  462.  
  463.       str_llist_elt_type *dir;
  464.       for (dir = *elt_dirs; dir; dir = STR_LLIST_NEXT (*dir))
  465.     {
  466.       char *elt_dir = STR_LLIST (*dir);
  467.  
  468.       if (elt_dir)
  469.         {
  470.           int tmp_num;
  471.           char **names = get_fcn_file_names (tmp_num, elt_dir, no_suffix);
  472.  
  473.           if (i + tmp_num >= num_max - 1)
  474.         {
  475. // Reallocate the array.  Only copy pointers, not the strings they
  476. // point to, then only delete the original array of pointers, and not
  477. // the strings they point to.
  478.  
  479.           num_max += 1024;
  480.           char **tmp = new char * [num_max];
  481.           for (int j = 0; j < i; j++)
  482.             tmp[j] = retval[j];
  483.  
  484.           delete [] retval;
  485.  
  486.           retval = tmp;
  487.         }
  488.  
  489.           int k = 0;
  490.           while (k < tmp_num)
  491.         retval[i++] = names[k++];
  492.         }
  493.     }
  494.  
  495.       path_elt = kpse_path_element (0);
  496.     }
  497.  
  498.   retval[i] = 0;
  499.   num = i;
  500.  
  501.   return retval;
  502. }
  503.  
  504. // Convert X to the nearest integer value.  Should not pass NaN to
  505. // this function.
  506.  
  507. int
  508. NINT (double x)
  509. {
  510.   if (x > INT_MAX)
  511.     return INT_MAX;
  512.   else if (x < INT_MIN)
  513.     return INT_MIN;
  514.   else
  515.     return (x > 0) ? ((int) (x + 0.5)) : ((int) (x - 0.5));
  516. }
  517.  
  518. double
  519. D_NINT (double x)
  520. {
  521.   if (xisinf (x) || xisnan (x))
  522.     return x;
  523.   else
  524.     return floor (x + 0.5);
  525. }
  526.  
  527. // XXX FIXME XXX --  put these in some file, and make them extern.
  528.  
  529. static int
  530. all_strings (const Octave_object& args)
  531. {
  532.   int n = args.length ();
  533.   for (int i = 0; i < n; i++)
  534.     if (! args(i).is_string ())
  535.       return 0;
  536.   return 1;
  537. }
  538.  
  539. char **
  540. make_argv (const Octave_object& args, const char *fcn_name)
  541. {
  542.   char **argv = 0;
  543.   if (all_strings (args))
  544.     {
  545.       int n = args.length ();
  546.       argv = new char * [n + 1];
  547.       argv[0] = strsave (fcn_name);
  548.       for (int i = 0; i < n; i++)
  549.     argv[i+1] = strsave (args(i).string_value ());
  550.     }
  551.   else
  552.     error ("%s: expecting all arguments to be strings", fcn_name);
  553.  
  554.   return argv;
  555. }
  556.  
  557. // Return non-zero if either NR or NC is zero.  Return -1 if this
  558. // should be considered fatal; return 1 if this is ok.
  559.  
  560. int
  561. empty_arg (const char *name, int nr, int nc)
  562. {
  563.   int is_empty = 0;
  564.  
  565.   if (nr == 0 || nc == 0)
  566.     {
  567.       int flag = user_pref.propagate_empty_matrices;
  568.  
  569.       if (flag < 0)
  570.     {
  571.       gripe_empty_arg (name, 0);
  572.       is_empty = 1;
  573.     }
  574.       else if (flag == 0)
  575.     {
  576.       gripe_empty_arg (name, 1);
  577.       is_empty = -1;
  578.     }
  579.       else
  580.     is_empty = 1;
  581.     }
  582.  
  583.   return is_empty;
  584. }
  585.  
  586. // Format a list in neat columns.  Mostly stolen from GNU ls.  This
  587. // should maybe be in utils.cc.
  588.  
  589. ostrstream&
  590. list_in_columns (ostrstream& os, char **list)
  591. {
  592. // Compute the maximum name length.
  593.  
  594.   int max_name_length = 0;
  595.   int total_names = 0;
  596.   for (char **names = list; *names; names++)
  597.     {
  598.       total_names++;
  599.       int name_length = strlen (*names);
  600.       if (name_length > max_name_length)
  601.     max_name_length = name_length;
  602.     }
  603.  
  604. // Allow at least two spaces between names.
  605.  
  606.   max_name_length += 2;
  607.  
  608. // Calculate the maximum number of columns that will fit.
  609.  
  610.   int line_length = terminal_columns ();
  611.   int cols = line_length / max_name_length;
  612.   if (cols == 0)
  613.     cols = 1;
  614.  
  615. // Calculate the number of rows that will be in each column except
  616. // possibly  for a short column on the right.
  617.  
  618.   int rows = total_names / cols + (total_names % cols != 0);
  619.  
  620. // Recalculate columns based on rows.
  621.  
  622.   cols = total_names / rows + (total_names % rows != 0);
  623.  
  624.   names = list;
  625.   int count;
  626.   for (int row = 0; row < rows; row++)
  627.     {
  628.       count = row;
  629.       int pos = 0;
  630.  
  631. // Print the next row.
  632.  
  633.       while (1)
  634.     {
  635.       os << *(names + count);
  636.       int name_length = strlen (*(names + count));
  637.  
  638.       count += rows;
  639.       if (count >= total_names)
  640.         break;
  641.  
  642.       int spaces_to_pad = max_name_length - name_length;
  643.       for (int i = 0; i < spaces_to_pad; i++)
  644.         os << " ";
  645.       pos += max_name_length;
  646.     }
  647.       os << "\n";
  648.     }
  649.  
  650.   return os;
  651. }
  652.  
  653. // See if the given file is in the path.
  654.  
  655. char *
  656. search_path_for_file (const char *path, const char *name)
  657. {
  658.   char *retval = 0;
  659.  
  660.   char *tmp = kpse_path_search (path, name, kpathsea_true);
  661.  
  662.   if (tmp)
  663.     {
  664.       retval = make_absolute (tmp, the_current_working_directory);
  665.       free (tmp);
  666.     }
  667.  
  668.   return retval;
  669. }
  670.  
  671. DEFUN ("file_in_path", Ffile_in_path, Sfile_in_path, 3, 1,
  672.   "file_in_path (PATH, NAME)")
  673. {
  674.   Octave_object retval;
  675.  
  676.   DEFINE_ARGV("file_in_path");
  677.  
  678.   if (argc == 3)
  679.     {
  680.       char *fname = search_path_for_file (argv[1], argv[2]);
  681.  
  682.       if (fname)
  683.     retval = fname;
  684.       else
  685.     retval = Matrix ();
  686.     }
  687.   else
  688.     print_usage ("file_in_path");
  689.  
  690.   DELETE_ARGV;
  691.  
  692.   return retval;
  693. }
  694.  
  695.  
  696. char *
  697. file_in_path (const char *name, const char *suffix)
  698. {
  699.   char *retval = 0;
  700.  
  701.   char *nm = strsave (name);
  702.  
  703.   if (suffix)
  704.     {
  705.       char *tmp = nm;
  706.       nm = strconcat (tmp, suffix);
  707.       delete [] tmp;
  708.     }
  709.  
  710.   if (! the_current_working_directory)
  711.     get_working_directory ("file_in_path");
  712.  
  713.   retval = search_path_for_file (user_pref.loadpath, nm);
  714.  
  715.   delete [] nm;
  716.  
  717.   return retval;
  718. }
  719.  
  720. // See if there is an function file in the path.  If so, return the
  721. // full path to the file.
  722.  
  723. char *
  724. fcn_file_in_path (const char *name)
  725. {
  726.   if (name)
  727.     {
  728.       int len = strlen (name);
  729.  
  730.       if (name [len - 2] == '.' && name [len - 1] == 'm')
  731.     return file_in_path (name, "");
  732.       else
  733.     return file_in_path (name, ".m");
  734.     }
  735.   else
  736.     return 0;
  737. }
  738.  
  739. // See if there is an octave file in the path.  If so, return the
  740. // full path to the file.
  741.  
  742. char *
  743. oct_file_in_path (const char *name)
  744. {
  745.   if (name)
  746.     {
  747.       int len = strlen (name);
  748.  
  749.       if (name [len - 4] == '.' && name [len - 3] == 'o'
  750.       && name [len - 2] == 'c' && name [len - 1] == 't')
  751.     return file_in_path (name, "");
  752.       else
  753.     return file_in_path (name, ".oct");
  754.     }
  755.   else
  756.     return 0;
  757. }
  758.  
  759. char *
  760. undo_string_escape (char c)
  761. {
  762.   static char retval[2];
  763.   retval[1] = '\0';
  764.  
  765.   if (! c)
  766.     return 0;
  767.  
  768.   switch (c)
  769.     {
  770.     case '\a':
  771.       return "\\a";
  772.  
  773.     case '\b': // backspace
  774.       return "\\b";
  775.  
  776.     case '\f': // formfeed
  777.       return "\\f";
  778.  
  779.     case '\n': // newline
  780.       return "\\n";
  781.  
  782.     case '\r': // carriage return
  783.       return "\\r";
  784.  
  785.     case '\t': // horizontal tab
  786.       return "\\t";
  787.  
  788.     case '\v': // vertical tab
  789.       return "\\v";
  790.  
  791.     case '\\': // backslash
  792.       return "\\\\";
  793.  
  794.     case '"': // double quote
  795.       return "\\\"";
  796.  
  797.     default:
  798.       retval[0] = c;
  799.       return retval;
  800.     }
  801. }
  802.  
  803. char *
  804. undo_string_escapes (char *s)
  805. {
  806.   ostrstream buf;
  807.  
  808.   char *t;
  809.   while (t = undo_string_escape (*s++))
  810.     buf << t;
  811.   buf << ends;
  812.  
  813.   return buf.str ();
  814. }
  815.  
  816. DEFUN ("undo_string_escapes", Fundo_string_escapes,
  817.        Sundo_string_escapes, 1, 1,
  818.   "undo_string_escapes (STRING)")
  819. {
  820.   tree_constant retval;
  821.  
  822.   int nargin = args.length ();
  823.  
  824.   if (nargin == 1 && args(0).is_string ())
  825.     {
  826.       char *str = undo_string_escapes (args(0).string_value ());
  827.       retval = str;
  828.       delete [] str;
  829.     }
  830.   else
  831.     print_usage ("undo_string_escapes");
  832.  
  833.   return retval;
  834. }
  835.  
  836. /*
  837. ;;; Local Variables: ***
  838. ;;; mode: C++ ***
  839. ;;; page-delimiter: "^/\\*" ***
  840. ;;; End: ***
  841. */
  842.