home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 531.lha / Less_v1.4Z / src.LZH / src / os.c < prev    next >
C/C++ Source or Header  |  1991-07-03  |  7KB  |  313 lines
  1. /*
  2.  * Operating system dependent routines.
  3.  *
  4.  * Most of the stuff in here is based on Unix, but an attempt
  5.  * has been made to make things work on other operating systems.
  6.  * This will sometimes result in a loss of functionality, unless
  7.  * someone rewrites code specifically for the new operating system.
  8.  *
  9.  * The makefile provides defines to decide whether various
  10.  * Unix features are present.
  11.  */
  12.  
  13. #ifdef AMIGA
  14. /* Compile with -HPreHeader.q to get "less.h"! */
  15. #else
  16. #include "less.h"
  17. #endif
  18.  
  19. #include <signal.h>
  20.  
  21. #ifdef AMIGA
  22. #ifndef STAT
  23. #define STAT 1
  24. #endif
  25. #endif
  26.  
  27. #if EDITOR || SHELL_ESCAPE
  28. char *getenv();
  29.  
  30. /*
  31.  * Pass the specified command to a shell to be executed.
  32.  * Like plain "system()", but handles resetting terminal modes, etc.
  33.  */
  34.         public void
  35. lsystem(cmd)
  36.         char *cmd;
  37. {
  38.         int inp;
  39.         char cmdbuf[256];
  40.         char *shell;
  41.  
  42.         /*
  43.          * Print the command which is to be executed,
  44.          * unless the command starts with a "-".
  45.          */
  46.         if (cmd[0] == '-')
  47.                 cmd++;
  48.         else
  49.         {
  50.                 lower_left();
  51.                 clear_eol();
  52.                 putstr("!");
  53.                 putstr(cmd);
  54.                 putstr("\n");
  55.         }
  56.  
  57.         /*
  58.          * De-initialize the terminal and take out of raw mode.
  59.          */
  60.         deinit();
  61.         flush();
  62.         raw_mode(0);
  63.  
  64. #ifdef AMIGA
  65.         { extern int called_from_WB;
  66.           extern long tty;
  67.  
  68.         if (called_from_WB)
  69.                 error("can't execute a CLI command from Workbench, sorry!");
  70.         else
  71.                 if (cmd && *cmd)
  72.                         /* run a one shot */
  73.                         Execute(cmd, 0L, tty);
  74.         }
  75. #else
  76.         /*
  77.          * Restore signals to their defaults.
  78.          */
  79.         SIGNAL(SIGINT, SIG_DFL);
  80. #ifdef SIGTSTP
  81.         SIGNAL(SIGTSTP, SIG_DFL);
  82. #endif
  83.         /*
  84.          * Force standard input to be the terminal, "/dev/tty",
  85.          * even if less's standard input is coming from a pipe.
  86.          */
  87.         inp = dup(0);
  88.         close(0);
  89.         if (open("/dev/tty", 0) < 0)
  90.                 dup(inp);
  91.  
  92.         /*
  93.          * Pass the command to the system to be executed.
  94.          */
  95.         if ((shell = getenv("SHELL")) != NULL)
  96.         {
  97.                 sprintf(cmdbuf, "%s -c \"%s\"", shell, cmd);
  98.                 cmd = cmdbuf;
  99.         }
  100.         system(cmd);
  101.  
  102.         /*
  103.          * Restore standard input, reset signals, raw mode, etc.
  104.          */
  105.         close(0);
  106.         dup(inp);
  107.         close(inp);
  108.  
  109.         init_signals();
  110.         raw_mode(1);
  111.         init();
  112. #endif
  113. }
  114. #endif
  115.  
  116.  
  117. /*
  118.  * Expand a filename, substituting any environment variables, etc.
  119.  * The implementation of this is necessarily very operating system
  120.  * dependent.  This implementation is unabashedly only for Unix systems.
  121.  */
  122. #if GLOB
  123.  
  124. #include <stdio.h>
  125. FILE *popen();
  126.  
  127.         public char *
  128. glob(filename)
  129.         char *filename;
  130. {
  131.         FILE *f;
  132.         char *p;
  133.         int ch;
  134.         static char ECHO[] = "echo ";
  135.         static char filebuf[FILENAME+sizeof(ECHO)+1];
  136.  
  137.         if (filename[0] == '#')
  138.                 return (filename);
  139.         strcpy(filebuf, ECHO);
  140.         strtcpy(filebuf+sizeof(ECHO)-1, filename, sizeof(filebuf)-sizeof(ECHO));
  141.         if ((f = popen(filebuf, "r")) == NULL)
  142.                 return (filename);
  143.         for (p = filebuf;  p < &filebuf[sizeof(filebuf)-1];  p++)
  144.         {
  145.                 if ((ch = getc(f)) == '\n' || ch == EOF)
  146.                         break;
  147.                 *p = ch;
  148.         }
  149.         *p = '\0';
  150.         pclose(f);
  151.         return (filebuf);
  152. }
  153.  
  154. #else
  155.  
  156. #ifdef __STDC__
  157. char *glob (char *filename)
  158. #else
  159.         public char *
  160. glob(filename)
  161.         char *filename;
  162. #endif
  163. {
  164.         return (filename);
  165. }
  166.  
  167. #endif
  168.  
  169.  
  170. /*
  171.  * Returns NULL if the file can be opened and
  172.  * is an ordinary file, otherwise an error message
  173.  * (if it cannot be opened or is a directory, etc.)
  174.  */
  175.  
  176. #if STAT
  177.  
  178. #include <sys/types.h>
  179. #include <sys/stat.h>
  180.  
  181. static char *stat_erm
  182.     __PROTO((char *filename, char *message, int len, char *erm));
  183.  
  184.  
  185. #ifdef __STDC__
  186. char *bad_file (char *filename, char *message, int len)
  187. #else
  188.         public char *
  189. bad_file(filename, message, len)
  190.         char *filename;
  191.         char *message;
  192.         int len;
  193. #endif
  194. {
  195.         struct stat statbuf;
  196.  
  197. #ifdef AMIGA
  198.         /* On the Amiga, you can't stat a pipe: file, for some reason */
  199.         if (strnicmp(filename, "pipe:", 5) == 0)  /* kludge! */
  200.                 return NULL;
  201. #endif
  202.         if (stat(filename, &statbuf) < 0)
  203.                 return (errno_message(filename, message, len));
  204.         if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
  205.         {
  206. #ifdef AMIGA
  207.                 return stat_erm(filename, message, len, " is a directory");
  208. #else
  209.                 static char is_dir[] = " is a directory";
  210.                 strtcpy(message, filename, len-sizeof(is_dir)-1);
  211.                 strcat(message, is_dir);
  212.                 return (message);
  213. #endif
  214.         }
  215.         if ((statbuf.st_mode & S_IFMT) != S_IFREG)
  216.         {
  217. #ifdef AMIGA
  218.                 return stat_erm
  219.                     (filename, message, len, " is not a regular file");
  220. #else
  221.                 static char not_reg[] = " is not a regular file";
  222.                 strtcpy(message, filename, len-sizeof(not_reg)-1);
  223.                 strcat(message, not_reg);
  224.                 return (message);
  225. #endif
  226.         }
  227. #ifdef AMIGA
  228.         if (!(statbuf.st_mode & S_IREAD))
  229.                 return
  230.                     stat_erm(filename, message, len, " is read-protected");
  231. #endif
  232.         return (NULL);
  233. }
  234.  
  235. #ifdef AMIGA
  236. static char *stat_erm(char *filename, char *message, int len, char *erm)
  237. {
  238.         strtcpy(message, filename, len - strlen(erm));
  239.         strcat(message, erm);
  240.         return (message);
  241. }
  242. #endif
  243.  
  244. #else
  245.  
  246. #ifdef __STDC__
  247. char *bad_file (char *filename, char *message, int len)
  248. #else
  249.         public char *
  250. bad_file(filename, message, len)
  251.         char *filename;
  252.         char *message;
  253.         int len;
  254. #endif
  255. {
  256.         return (NULL);
  257. }
  258.  
  259. #endif
  260.  
  261. /*
  262.  * Return an error message based on the value of "errno".
  263.  */
  264.  
  265. #if PERROR
  266.  
  267. #ifdef __STDC__
  268. char *errno_message (char *filename, char *message, int len)
  269. #else
  270.         public char *
  271. errno_message(filename, message, len)
  272.         char *filename;
  273.         char *message;
  274.         int len;
  275. #endif
  276. {
  277.         char *p;
  278.         static char msg[16];
  279.  
  280.         extern char *sys_errlist[];
  281.         extern int sys_nerr;
  282.         extern int errno;
  283.  
  284.         if (errno < sys_nerr)
  285.                 p = sys_errlist[errno];
  286.         else
  287.         {
  288.                 sprintf(msg, "Error %d", errno);
  289.                 p = msg;
  290.         }
  291.         strtcpy(message, filename, len-strlen(p)-3);
  292.         strcat(message, ": ");
  293.         strcat(message, p);
  294.         return (message);
  295. }
  296.  
  297. #else
  298.  
  299.         public char *
  300. errno_message(filename, message, len)
  301.         char *filename;
  302.         char *message;
  303.         int len;
  304. {
  305.         static char msg[] = ": cannot open";
  306.  
  307.         strtcpy(message, filename, len-sizeof(msg)-1);
  308.         strcat(message, msg);
  309.         return (message);
  310. }
  311.  
  312. #endif
  313.