home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume38 / menushell / part02 / string.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-30  |  8.2 KB  |  392 lines
  1. #include "mshell.h"
  2.  
  3. #ifdef BSD
  4. #define strchr    index
  5. #endif
  6.  
  7.  
  8. /* function to find the position of sub_string in main_string 
  9.  * ---------------------------------------------------------- */
  10.  
  11. strsearch (main_string, sub_string)
  12. char main_string[], sub_string[];
  13. {
  14.     int start_mstring = 0, start_sstring = 0, 
  15.         factor = 0, answer, main_pos = 0;
  16.  
  17.         while ( main_string[start_mstring] != EOS  &&
  18.             sub_string[start_sstring] != EOS )       {
  19.  
  20.             if ( main_string[start_mstring] !=
  21.                       sub_string[start_sstring] )  {
  22.                 ++main_pos;
  23.                 start_mstring = main_pos;
  24.                 start_sstring = 0;
  25.                 factor = 0;
  26.             }
  27.             else   {
  28.                 ++factor;
  29.                 ++start_mstring;
  30.                 ++start_sstring;
  31.             }        /* end if-else */
  32.  
  33.         }            /* end while */
  34.  
  35.         if (( sub_string[start_sstring] == EOS && factor > 0 ) ||
  36.             ( main_string[start_mstring] == EOS &&
  37.                sub_string[start_sstring] == EOS ))   {
  38.  
  39.             answer = main_pos;
  40.             return(answer);
  41.         }
  42.         else 
  43.             return(-1);    /* end if-else */
  44. }                    /* end function strsearch */
  45.  
  46. /* function to remove string starting at a specified position  
  47.  * ----------------------------------------------------------  */
  48.  
  49. remove_string (main_string, start_index, no_of_bytes )
  50. char main_string[];
  51. int  start_index, no_of_bytes;
  52.  
  53. {
  54.     int index, offset;
  55.  
  56.     offset = strlen (main_string) - no_of_bytes;
  57.     /* offset is defined as the index no of the last element which
  58.      * will be present in the new string or the unremoved bytes +
  59.      * bytes that need to be repositioned */
  60.  
  61.     for ( index = start_index; index < offset; ++ index ) 
  62.         main_string [index] = main_string [index + no_of_bytes];
  63.  
  64.     main_string[index] = EOS;
  65.  
  66. }                /* end of function remove_string */
  67.  
  68. /* replace string function 
  69.  * ----------------------- */
  70.  
  71. int replace_string (main_string, old_string, new_string)
  72. char main_string[256], old_string[256], new_string[256]; 
  73.  
  74. {
  75.     int  pos;
  76.  
  77.     pos = strsearch (main_string, old_string);
  78.  
  79.     if ( pos >= 0 ) {
  80.         remove_string (main_string, pos, strlen(old_string));
  81.         insert_string (main_string, new_string, pos);
  82.         return (TRUE);
  83.     /*     printf ("\n\n\tnew string is  %s\n\n", main_string); */
  84.     }
  85.     else
  86.         return (FALSE);
  87. }     /* end function replace_string */
  88.  
  89. /* function to find insert sub-string in main-string at a specific position
  90.  * ------------------------------------------------------------------------ */
  91.  
  92. insert_string ( main_string, sub_string, position )
  93. char main_string [], sub_string [];
  94. int  position;
  95.  
  96. {
  97.     int i, j, offset;
  98.  
  99.     if (sub_string) {
  100.         offset = strlen(sub_string);
  101.         j = strlen (main_string);
  102.  
  103.         for (i = j; i >= position; i--)
  104.             main_string [i+offset] = main_string [i];
  105.  
  106.         for (i=0; i < offset ; i++) 
  107.             main_string [i+position] = sub_string [i];
  108.  
  109.         main_string [j+offset] = EOS;
  110.     }
  111. }
  112.  
  113. #include <ctype.h>
  114.  
  115. #define NULL    0
  116. #define STRLEN    256
  117.  
  118. char *
  119. findvar(s)
  120. char *s;
  121. {
  122.     static char var[STRLEN];
  123.     char *p, *v = var, *strchr();
  124.  
  125.     if ((p = strchr(s, '$')) == NULL)
  126.         return (NULL);
  127.  
  128.     p++;    /* skip $ */
  129.  
  130.     while (isalnum(*p))
  131.         *v++ = *p++;
  132.  
  133.     *v = '\0';
  134.  
  135.     return(var);
  136. }
  137.  
  138. substitute(s)
  139. char *s;
  140. {
  141.     char var[STRLEN], *v_in_s, *getenv();
  142.  
  143.     if ((v_in_s = findvar(s)) == NULL)
  144.         return(0);
  145.     
  146.     sprintf(var, "$%s", v_in_s);
  147.     replace_string(s, var, getenv(v_in_s));
  148.     return(1);
  149. }
  150.  
  151. #ifdef DEBUGGING
  152. main()
  153. {
  154.     char s[STRLEN];
  155.  
  156.     while (1) {
  157.         printf("s-> ");
  158.         gets(s);
  159.         substitute(s);
  160.         printf("--> %s\n", s);
  161.     }
  162. }
  163. #endif
  164.  
  165. all_blanks (string)
  166. char * string;
  167. {
  168.     for ( ; ((*string == BLANK) && (*string != EOS)) ; ++string);
  169.  
  170.     if ( *string == EOS ) 
  171.         return (TRUE);
  172.     else
  173.         return (FALSE);
  174. }
  175.  
  176. /* function to find position  of sub string in a main string 
  177.  * ---------------------------------------------------------- */
  178.  
  179. /* ========================================= */
  180. char * find_string (main_string, sub_string)
  181. /* ========================================= */
  182. char main_string[], sub_string[];
  183. {
  184.     int start_mstring = 0, start_sstring = 0, 
  185.         factor = 0, answer, main_pos = 0;
  186.  
  187.         while ( main_string[start_mstring] != EOS  &&
  188.             sub_string[start_sstring] != EOS )       {
  189.  
  190.             if ( main_string[start_mstring] !=
  191.                       sub_string[start_sstring] )  {
  192.                 ++main_pos;
  193.                 start_mstring = main_pos;
  194.                 start_sstring = 0;
  195.                 factor = 0;
  196.             }
  197.             else   {
  198.                 ++factor;
  199.                 ++start_mstring;
  200.                 ++start_sstring;
  201.             }        /* end if-else */
  202.  
  203.         }            /* end while */
  204.  
  205.         if (( sub_string[start_sstring] == EOS && factor > 0 ) ||
  206.             ( main_string[start_mstring] == EOS &&
  207.                sub_string[start_sstring] == EOS ))   {
  208.  
  209.             answer = main_pos;
  210.             return(&main_string[main_pos]);
  211.         }
  212.         else  {
  213.             /* answer = -1; */
  214.             return(NULL);    /* end if-else */
  215.         }
  216. }                    /* end function find_string */
  217.  
  218. /******************************************************************************
  219.  * reads a line of input string from the terminal and keeps doing so until    *
  220.  * input string contains no colons                                            *
  221.  *****************************************************************************/
  222.  
  223.  
  224. struct inp_link {
  225.     DL_NODE n;
  226.     char *input;
  227. };
  228. static DLIST inputstack;
  229.  
  230. read_input_line(string)
  231. char *string;
  232. {
  233.     extern int G_shell_ok;
  234.     char *p;
  235.  
  236.     if (string == NULL) {    /* just read and trash line */
  237.         int c;
  238.         while ((c = getchar()) != '\n' && c != EOF)
  239.             ;
  240.         return;
  241.     }
  242.  
  243.     if (inputstack == NULL)
  244.         inputstack = dl_create(DL_FREE);
  245.  
  246.     do {
  247.         /* if any input (e.g., from last time) on stack use that... */
  248.         if (dl_size(inputstack) > 0) {
  249.             struct inp_link *l;
  250.             l = (struct inp_link *) dl_shead(inputstack);
  251.             strcpy(string, l->input);
  252.             free(l->input);
  253.             dl_delete(inputstack);
  254.         } /* ... else get some new input */
  255.         else if (gets(string) == NULL) {
  256.             printf("End of input -- quitting...\n");
  257.             exit(1);
  258.         }
  259.  
  260.         /* if it has a multi-command delim, save rest for next time */
  261. #define MULTI_CMD_DELIM ','
  262.         if (p = index(string, MULTI_CMD_DELIM)) {
  263.             char *strsave();
  264.             struct inp_link *l;
  265.             *p++ = EOS;
  266.             if ((l=getnode(sizeof(*l))) && (l->input=strsave(p)))
  267.                 dl_prepend(inputstack, l);
  268.         }
  269.  
  270.         filter_leading_trailing_blanks_tabs (string);
  271.  
  272.         /* if macro, then expand & push definition on stack */
  273. #define MACRO_DELIM '#'
  274.         if (string[0] == MACRO_DELIM) {
  275.             char *mac_lookup();
  276.             char *def = mac_lookup(string+1);
  277.             struct inp_link *l;
  278.             if (def && (l = getnode(sizeof(*l))) &&
  279.                         (l->input = strsave(def)))
  280.                 dl_prepend(inputstack, l);
  281.         }
  282.     } while (string[0] == MACRO_DELIM);
  283.  
  284.     /* if not allowing shell, then chop off at funny chars */
  285.     if (! G_shell_ok)
  286.         truncate_at_invalid_chars (string);
  287.  
  288. }  /* end function read_input_line */
  289.  
  290. int moreinput()
  291. {
  292.     return (inputstack && dl_size(inputstack) > 0);
  293. }
  294.  
  295.  
  296. /****************************************************************************
  297.  * Function to filter out all leading and trailing blanks from a strings    *
  298.  * Takes a character string as a parameter                                  *
  299.  ****************************************************************************/
  300.  
  301. void filter_leading_trailing_blanks_tabs ( string )
  302. char * string;
  303. {
  304.     int i, j ;
  305.  
  306.     for ( i = 0 ; (( string[i] != EOS ) && (( string[i] == BLANK )
  307.                         ||  ( string[i] == TAB   )) ); ++i )
  308.         ;
  309.     for ( j = 0 ; ( string[j] != EOS ) ; ++j ) 
  310.         string[j] = string[j + i];
  311.  
  312.     string[j] = EOS;
  313.  
  314.     for ( i = strlen(string) - 1 ; ( i >= 0 ) ; --i )
  315.         if (( string[i] != BLANK ) && ( string[i] != TAB ))
  316.             break;
  317.  
  318.     string[i+1] = EOS; 
  319.  
  320.     return ;
  321. }
  322.  
  323. char *
  324. strsave(s)
  325. char *s;
  326. {
  327.     char *p, *malloc();
  328.     if (s == NULL || (p=malloc(strlen(s)+1)) == NULL)
  329.         return(NULL);
  330.     strcpy(p, s);
  331.  
  332.     return(p);
  333. }
  334.  
  335. /* assumes d was malloc'd -- then makes large enough to cat s onto it */
  336. char *
  337. strcatsave(d, s)
  338. char *d, *s;
  339. {
  340.     char *realloc();
  341.  
  342.     if (d && (d = realloc(d, strlen(d)+strlen(s)+2)))
  343.         strcat(d, s);
  344.  
  345.     return(d);
  346. }
  347.  
  348. /* replace _ with space */
  349. char *
  350. ufix(s)
  351. char *s;
  352. {
  353.     char *p;
  354.     for (p = s; p && *p; p++)
  355.         if (*p == '_')
  356.             *p = ' ';
  357.     return(s);
  358. }
  359.  
  360. strcontains(s, chars)
  361. char *s, *chars;
  362. {
  363.     while (*chars)
  364.         if (index(s, *chars++))
  365.             return(1);
  366.     return(0);
  367. }
  368.  
  369. /* remove string from no-no chars on */
  370. truncate_at_invalid_chars (string)
  371. char *string;
  372. {
  373.     char *p, *index();
  374.     /* XXX - update to use strpbrk */
  375.     if (p = index(string, ';'))
  376.         *p = EOS;
  377.     if (p = index(string, '`'))
  378.         *p = EOS;
  379.     if (p = index(string, '|'))
  380.         *p = EOS;
  381.     if (p = index(string, '<'))
  382.         *p = EOS;
  383.     if (p = index(string, '>'))
  384.         *p = EOS;
  385.     if (p = index(string, '^'))
  386.         *p = EOS;
  387.     if (p = index(string, '('))
  388.         *p = EOS;
  389.     if (p = index(string, '&'))
  390.         *p = EOS;
  391. }
  392.