home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / ils / input.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-28  |  4.9 KB  |  262 lines
  1. #include    <curses.h>
  2. #include    "ils.h"
  3. #include    "get.h"
  4.  
  5. extern    int    syms;    /* number of symbols on symbol table */
  6. extern    struct    symbol    *symtab[];
  7. extern    char    *pnam;
  8. extern    int    a_num;    /* number of arguments in list */
  9. extern    int    a_ind;    /* index into current argument */
  10. extern    char    *args[ILS_MAX_ARGS];
  11. extern    char    cur_path[];        /* pointer to active path */
  12. extern    int    modes;    /* what special flags might be set */
  13.  
  14. process_input(c,list,entry,entries,p,x,y,rx)
  15. struct    d_entry    *list[];
  16. int    entry, entries,x,y,rx;
  17. char    p[],c;
  18. {
  19.     struct    value    *v;
  20.     char    line[256];
  21.  
  22.     int    i=0;
  23.  
  24.     if(c==ILS_FORCE_KEYBOARD) {
  25.         evaluate_line(line,p,list,entry,entries,x,y,rx);
  26.         ils_doit(line);        /* execute the statement */
  27.     }
  28.     else {
  29.         for(i=0;i<syms;i++)
  30.             if(strcmp(symtab[i]->name,p)==0){/* found the command */
  31.                 perform_command(!c,symtab[i]->val,list,entry,entries,x,y,rx);
  32.                 break;        /* get out of loop */
  33.             }
  34.         if(i==syms)
  35.             flash();
  36.     }
  37. }
  38.  
  39. perform_command(c,v,list,entry,entries,x,y,rx)
  40. struct    value    *v;
  41. struct    d_entry    *list[];
  42. int    entry, entries,x,y,rx;
  43. {
  44.     char    line[256];
  45.     int    i;
  46.  
  47.     while(v != (struct value *) NULL) {
  48.         evaluate_line(line,v->v,list,entry,entries,x,y,rx);
  49.         ils_doit(line);        /* execute the statement */
  50.         v = v->next;
  51.     }
  52.     dealloc(args);
  53. }
  54.  
  55. ils_doit(line)
  56. char    *line;
  57. {
  58.     noraw();
  59.     echo();
  60.     clear();
  61.     if(modes & ILS_ECHO_COMS)
  62.         printw("%s\n",line);
  63.     refresh();
  64. #ifdef BSD
  65.     endwin();
  66. #endif
  67.  
  68.     system(line);        /* execute the statement */
  69. #ifdef BSD
  70.     printf("PRESS RETURN TO RETURN TO %s\n",pnam);
  71.     getchar();
  72.     initscr();
  73.     scrollok(stdscr,TRUE);
  74.     raw();
  75.     noecho();
  76. #endif
  77.  
  78. #ifdef SYSTEMV
  79.     raw();
  80.     noecho();
  81.     standout();
  82.     printw("Press any key to return to %s",pnam);
  83.     standend();
  84.     refresh();
  85.     getch();
  86. #endif SYSTEMV
  87. }    
  88.  
  89. evaluate_line(line,s,list,entry,entries,x,y,rx)
  90. char    s[], line[];
  91. struct    d_entry    *list[];
  92. int    entry, entries,x,y,rx;
  93. {
  94.     char        c, lable[160], arg[160], new_line[256];
  95.     register    int    k;
  96.     int        l, a=0, j, white=0, d, ln=0, i, line_ind=0;
  97.  
  98.     l = strlen(s);
  99.     for(i=0;i<l;i++) {
  100.         switch(c=s[i]) {
  101.             case ILS_METACHAR:
  102.                 i++;
  103.                 for(k=d=0;i<l && d==0;i++) {
  104.                     switch(c=s[i]) {
  105.                         case META1:  /* possible delimeters */    
  106.                         case META2:    
  107.                         case META3:    
  108.                         case META4:    
  109.                         case META5:    
  110.                         case META6:    
  111.                         case META7:    
  112.                         case META8:    
  113.                         case META9:    
  114.                         case META10:    
  115.                         case META11:    
  116.                         case META12:    
  117.                         case META13:    
  118.                         case META14:    
  119.                         case META15:    
  120.                         case META16:    
  121.                         case META17:    
  122.                         case META18:    
  123.                         case ' ':
  124.                         case '\T':
  125.                             i--;
  126.                             d=1;
  127.                             break;
  128.                         default:
  129.                             lable[k++]=c;
  130.                             break;
  131.                     }
  132.                 }
  133.                 lable[k]='\0';
  134.                 insert_value(new_line,lable,list,entry,entries,s,&i,x,y,rx);
  135.                 i--;
  136.                 for(j=0;new_line[j]!='\0';j++,line_ind++)
  137.                     line[line_ind] = new_line[j];
  138.                 white=0;
  139.                 break;
  140.             case ' ':
  141.             case '\t':
  142.                 if(white)
  143.                     break;
  144.                 white=1;
  145.                 line[line_ind++]=' ';
  146.                 break;
  147.             default:
  148.                 white=0;
  149.                 line[line_ind++]=c;
  150.                 break;
  151.         }
  152.     }
  153.     line[line_ind]='\0';
  154. }
  155.  
  156. dealloc(args)
  157. char    *args[];
  158. {
  159.     register int    i;
  160.  
  161.     for(i=0;i<ILS_MAX_ARGS && args[i]!=(char *)NULL;i++)
  162.         free(args[i]);
  163. }
  164.  
  165. insert_value(line,lable,list,entry,entries,s,ii,x,y,rx)
  166. char    line[],lable[], s[];
  167. int    *ii,x,y,rx;
  168. struct    d_entry    *list[];
  169. int    entry, entries;
  170. {
  171.     char    *c, prompt[256], new_prompt[256];
  172.     register    int    i, parens, k;
  173.     int    l;
  174.  
  175.     if(strcmp(lable,CURRENT_FILE)==0)
  176.         strcpy(line,list[entry]->name);
  177.     else if(strcmp(lable,PREFIX)==0) {
  178.         for(i=0;i<strlen(list[entry]->name) && list[entry]->name[i]!='.';i++)
  179.             line[i] = list[entry]->name[i];
  180.         line[i]='\0';
  181.     }
  182.     else if(strcmp(lable,PWD_PATH)==0) {
  183.         for(i=0;cur_path[i]!='\0';i++)
  184.             line[i] = cur_path[i];
  185.         line[i]='\0';
  186.     }
  187.     else if(strcmp(lable,INPUT)==0) {
  188.         (*ii)++;
  189.         for(parens=1,k=0;parens && s[*ii]!='\0';(*ii)++)
  190.             switch(s[*ii]) {
  191.                 case ')':
  192.                     parens--;
  193.                     if(parens)
  194.                         prompt[k++]=s[*ii];
  195.                     break;
  196.                 case '(':
  197.                     parens++;
  198.                 default:
  199.                     prompt[k++]=s[*ii];
  200.                     break;
  201.             }
  202.         if(parens)
  203.             return(1);
  204.         prompt[k]='\0';
  205.  
  206.         move(y,x);
  207.         
  208.         evaluate_line(new_prompt,prompt,list,entry,entries,x,y,rx);
  209.         l=strlen(new_prompt);
  210.         printw(new_prompt);
  211.         line[0]='\0';
  212.         if(getst(rx-x-l-1,x+l,y,line,rx-x-l,&l,ALL_ALPHA,NULL)!=GET_RETURN)
  213.             return(1);
  214.     }
  215. #ifdef SYSTEMV
  216.     else if((c=(char *)getenv(lable))!=NULL)
  217.         strcpy(line,c);
  218. #endif SYSTEMV
  219. }
  220.  
  221. /* add to the argument list */
  222. /* c is for passing a single character, str is for passing a string,
  223.  * type==0 for char, 1 for string */
  224. add_to_args(c,str,type)
  225. char    c, str[];
  226. int    type;
  227. {
  228.     int    l,i;
  229.  
  230.     if(type) {
  231.         l=strlen(str);
  232.         for(i=0;i<l;i++)
  233.             add_char_to_args(str[i]);
  234.     }
  235.     else
  236.         add_char_to_args(c);
  237. }
  238.  
  239. add_char_to_args(c)
  240. char    c;
  241. {
  242.     static    char    line[256];
  243.     static    int    line_ind=0;
  244.  
  245.     switch(c) {
  246.         case ' ':
  247.         case '\t':
  248.             line[line_ind]='\0';
  249.             args[a_num] = (char *) malloc(strlen(line)+1);
  250.             strcpy(args[a_num],line);
  251.             a_num++;
  252.             a_ind=0;
  253.             line_ind=0;
  254.             break;
  255.         default:
  256.             line[line_ind++]=c;
  257.             if(line_ind>254)
  258.                 line_ind=254;
  259.             break;
  260.     }
  261. }
  262.