Patrick
/
Nife_v0
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Nife version Beta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
631 KiB
 
 
 
 
Tree: 883b36abe8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '883b36abe8'
${ noResults }
Nife_v0/src/histo.c

469 lines
13 KiB
Raw Blame History 

  1. /* Copyright (C) 2011-2014  Patrick H. E. Foubet - S.E.R.I.A.N.E.

  2. 

  3. This program is free software: you can redistribute it and/or modify

  4. it under the terms of the GNU General Public License as published by

  5. the Free Software Foundation, either version 3 of the License, or any

  6. later version.

  7. 

  8. This program is distributed in the hope that it will be useful,

  9. but WITHOUT ANY WARRANTY; without even the implied warranty of

  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11. GNU General Public License for more details.

  12. 

  13. You should have received a copy of the GNU General Public License

  14. along with this program.  If not, see <http://www.gnu.org/licenses/>

  15. *******************************************************************/

  16. /* histo.c */

  17. #include "conf.h"

  18. 

  19. #include <stdio.h>

  20. #include <stdlib.h>

  21. #include <string.h>

  22. #include <signal.h>

  23. #include <sys/types.h>

  24. #include <sys/wait.h>

  25. #include <sys/stat.h>

  26. #include <fcntl.h>

  27. #include <termios.h>

  28. #include <unistd.h>

  29. 

  30. #include "histo.h"

  31. #include "nife.h"

  32. #include "mth.h"

  33. #include "err.h"

  34. #include "lib.h"

  35. #include "debug.h"

  36. 

  37. 

  38. #define HISTOMAX 100

  39. static char * HIST[HISTOMAX];

  40. static int iH=0, iHt, iHl, iHFull=0;

  41. 

  42. #define FDMAX 128

  43. static int iFD=0;

  44. static int FD_T[FDMAX], FD_L[FDMAX]; /* fd table and line numbers */

  45. static void *FD_N[FDMAX];

  46. 

  47. void IF_showFD(void)

  48. {

  49.     printf("iFD=%d FD_T=%d FD_L=%d\n",iFD, FD_T[iFD], FD_L[iFD]);

  50. }

  51. 

  52. void addFD(int fd, char*S)

  53. {

  54. void *M;

  55.     iFD++;

  56.     /* printf("addFD iFD=%d\n",iFD); */

  57.     if (iFD == FDMAX) {

  58.        iFD--;

  59.        messErr(45);

  60.        return;

  61.     }

  62.     _MODIF_FD_IN_(fd);

  63.     FD_T[iFD]=fd;

  64.     FD_L[iFD]=0;

  65.     if ((M = malloc(strlen(S)+1)) == NULL) stopErr("addFD","malloc");

  66. #ifdef DEBUG_M

  67.     printf("New String address : %lu \n",(unsigned long)M);

  68. #endif

  69.     strcpy((char*)M,S);

  70.     FD_N[iFD]=M;

  71. }

  72. 

  73. void closeFD(void)

  74. {

  75.    /* printf("closeFD iFD=%d\n",iFD); */

  76.    close(FD_IN);

  77.    free(FD_N[iFD]);

  78.    iFD--;

  79.    if (iFD) _MODIF_FD_IN_(FD_T[iFD]);

  80.    else _MODIF_FD_IN_(0);

  81. }

  82. 

  83. int getFDlig(void)

  84. {

  85.     return FD_L[iFD];

  86. }

  87. 

  88. char * getFDname(void)

  89. {

  90.     return (char*)FD_N[iFD];

  91. }

  92. 

  93. void incFDlig(void)

  94. {

  95.     FD_L[iFD]++;

  96. }

  97. 

  98. 

  99. void razHisto(void)

  100. {

  101. int i;

  102.    for(i=0;i<iH;i++) free((void*)HIST[i]);

  103.    iH=0;

  104. }

  105. 

  106. void putHisto(char *C)

  107. {

  108. int L;

  109.     if ((L=strlen(C)) == 0) return;

  110.     HIST[iH] = (char*)malloc(L+1);

  111.     if (HIST[iH] != NULL) {

  112.        strcpy(HIST[iH],C);

  113.        iHt=iH; /* depart recherche */

  114.        iH++;

  115.        iHl=iH;

  116.        if (iH == HISTOMAX) {

  117.          iHFull=1;

  118.          iH=0;

  119.        }

  120.     }

  121. }

  122. 

  123. char * getHisto(char S) /* Sens A remonte, B descend */

  124. {

  125. char * C;

  126.    if (S == 'B') {

  127.        if (iHt == iH-1) {

  128.            iHl=iH;

  129.            printf("\a");

  130.            fflush(stdout);

  131.            C = NULL;

  132.        } else {

  133.            iHt++;

  134.            if (iHt == HISTOMAX) iHt=0;

  135.            if (iHl==iHt) iHt++;

  136.            C = HIST[iHt];

  137.            iHl=iHt;

  138.        }

  139.    } else { /* A */

  140.        if (iHt == -1) {

  141.            iHl=iHt;

  142.            printf("\a");

  143.            fflush(stdout);

  144.            C = NULL;

  145.        } else {

  146.           if (iHl==iHt) iHt--;

  147.           iHl=iHt;

  148.           C = HIST[iHt--];

  149.           if ((iHt < 0) && (iHFull)) iHt = HISTOMAX-1;

  150.        }

  151.    }

  152.    return(C);

  153. }

  154. 

  155. static struct termios t0, t1;

  156. int iTERM=0;

  157. 

  158. void termInit(void)

  159. {

  160. int nc;

  161.     for (iTERM=0; iTERM<3; iTERM++) {

  162.        if (tcgetattr(iTERM, &t0) != -1)  break;

  163.        if (iTERM<2) continue;

  164.        perror("No terminal found ! tcgetattr");  /* sauvegarde */

  165.        exit(2);

  166.     }

  167.     if (tcgetattr(iTERM, &t1) == -1) perror("tcgetattr"); 

  168.     /* cfmakeraw(&t1); */

  169.     t1.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP

  170.                            | INLCR | IGNCR | ICRNL | IXON);

  171.     /* t1.c_oflag &= ~OPOST; */

  172.     /* t1.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); */

  173.     t1.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);

  174.     t1.c_cflag &= ~(CSIZE | PARENB);

  175.     t1.c_cflag |= CS8;

  176.     if (tcsetattr(iTERM, TCSAFLUSH, &t1) == -1) perror("tcsetattr"); /* raw */

  177.     /* clear screen */

  178.     nc=system("clear");

  179. }

  180. 

  181. void termReset(void)

  182. {

  183.     if (tcsetattr(iTERM, TCSAFLUSH, &t0) == -1) perror("tcsetattr");/*restaure*/

  184. }

  185. 

  186. void enleve1(char * s)

  187. {

  188. char * w;

  189.     w=s;

  190.     while (*w != '\0') *w++ = *(w+1);

  191. }

  192. 

  193. void insertC(char c, char * s)

  194. {

  195. char *w;

  196.     w=s;

  197.     while (*w != '\0') w++;

  198.     while (w >= s) { *(w+1) = *w; w--; }

  199.     *s=c;

  200. }

  201. 

  202. int lireLigne(int fd, char *b, char *s, int nc)

  203. /* fd = file descriptor

  204.    b  = adresse du buffer

  205.    nc = nb de caracteres possible (longueur du buffer */

  206. {

  207. char *d, *f, c, c2, c3, *h, *w, *Wl, *rac;

  208. int n, i, l, ls=0, ins=0, ignTild=0, nbT=0, Nc;

  209. unsigned int j;

  210.    /* printf("lireLigne ... \n"); */

  211.    d = b;

  212.    f = b+nc;

  213.    while(d<f-ls) {

  214.      if (noErr()) {

  215.          n = -1;

  216.          break;

  217.      }

  218.      /* fprintf(stderr,"d-b=%d ins=%d s=<%s> b=<%s>\n",d-b,ins,s,b); */

  219.      if ((n=read(fd,d,1)) != 1) break;

  220.      c=*d;

  221.      if (ignTild && (c == '~')) {

  222.         ignTild=0; continue;

  223.      }

  224.      if ((c > 31) && (c < 127)) { /* de SPACE a TILDE */

  225.          if (!((FD_IN || iTERM) && ECHOOFF)) {

  226.                printf("%c",c);

  227.                if (ins) {

  228.                   if (ins==2)  /* rewrite */

  229.                      enleve1(s);

  230.                   if(*s =='\0') ins=0;

  231.                   else {

  232.                      printf("%s",s);

  233.                      for (j=0; j<strlen(s); j++) printf("\b");  

  234.                   }

  235.                }

  236.          }

  237.          fflush(stdout);

  238.          d++;

  239.      } else {

  240.          switch (c) {

  241.             /* Ctrl C

  242.             case '\003' : 

  243.               kill(getpid(), SIGINT);

  244.               break; */

  245.             case '\t': /* tab */

  246.               if (d>b) {

  247.                  *d='\0';

  248.                  w=d-1;

  249.                  while ((w>b) && (!(isSepa(*w,1)))) w--;

  250.                  if (isSepa(*w,0)) w++;

  251.                  /* fprintf(stderr,"d-b=%d  w=<%s>\n",d-b,w); */

  252.                  if (strlen(w) > 0) {

  253.                     j=nbLibBegin(w, &rac);

  254.                     /* fprintf(stderr,"j=%d  w=<%s>\n",j,w); */

  255.                     if (j==0) printf("\a");

  256.                     else {

  257.                        if (j==1) {

  258.                           Wl=getLibBegin(w);

  259.                           i=strlen(Wl)-strlen(w);

  260.                           /* fprintf(stderr,"i=%d  Wl=<%s>\n",i,Wl); */

  261.                           if (i>0) {

  262.                              strcpy(w,Wl);

  263.                              printf("%s ",d);

  264.                              d+=i;

  265.                              *d++ = ' ';

  266.                              if (ins) {

  267.                               printf("%s ",s);

  268.                               for (j=0; j<(strlen(s)+1); j++) printf("\b");  

  269.                              }

  270.                           } else { /* XXXX */

  271.                              if (i==0) {

  272.                                printf (" ");

  273.                                *d++ = ' ';

  274.                              }

  275.                           }

  276.                        } else {

  277.                           if (rac != NULL) {

  278.                              i=strlen(rac)-strlen(w);

  279.                              strcpy(w,rac);

  280.                              printf("%s",d);

  281.                              d+=i;

  282.                              if (ins) {

  283.                               printf("%s ",s);

  284.                               for (j=0; j<(strlen(s)+1); j++) printf("\b");  

  285.                              }

  286.                           } else {

  287.                             nbT++;

  288.                             if (nbT>1) {

  289.                                nbT=0;

  290.                                printf("\n");

  291.                                listLibBegin(w);

  292.                                *d='\0';

  293.                                printf("> %s",b);

  294.                                if (ins) {

  295.                                 printf("%s ",s);

  296.                                 for (j=0; j<(strlen(s)+1); j++) printf("\b");  

  297.                                }

  298.                                fflush(stdout);

  299.                             }

  300.                           }

  301.                        }

  302.                     }

  303.                     fflush(stdout);

  304.                  }

  305.               }

  306.               break;

  307.             case '\177':

  308.               if (d>b) {

  309.                  printf("\b \b");

  310.                  if (ins) {

  311.                   printf("%s ",s);

  312.                   for (j=0; j<(strlen(s)+1); j++) printf("\b");  

  313.                  }

  314.                  fflush(stdout);

  315.                  d--;

  316.               }

  317.               break;

  318.             case '\n':

  319.             case '\r':

  320.               if ((FD_IN || iTERM) && ECHOOFF) printf(".");

  321.               else {

  322.                  printf("\n");

  323.                  if (ins) {

  324.                      if (d+strlen(s) < f) {

  325.                         sprintf(d,"%s",s);

  326.                         d+=strlen(s);

  327.                      } else return(-1);

  328.                  }

  329.               }

  330.               goto finBoucle;

  331.          /* gestion des caracteres speciaux */

  332.             case '\033':   /* ESCAPE */

  333.               ignTild=1;

  334.               Nc=read(fd,&c2,1);

  335.               Nc=read(fd,&c3,1);

  336.               if (c2 == '[') {

  337.                   switch(c3) {

  338.                       case '2' : /* Insert */

  339.                         if (ins) {

  340.                            ins++;

  341.                            if (ins==3) ins=1;

  342.                         }

  343.                         break; 

  344.                       case '3' : /* Suppr */

  345.                         if (ins) {

  346.                            enleve1(s);

  347.                            if(*s =='\0') ins=0;

  348.                            printf("%s \b",s);

  349.                            for (j=0; j<strlen(s); j++) printf("\b");  

  350.                            fflush(stdout);

  351.                         }

  352.                         break; 

  353.                       case 'A' :

  354.                       case 'B' :

  355.                         ins = 0;

  356.                         /* efface la ligne en cours */

  357.                         l=d-b;

  358.                         for(i=0;i<l;i++) printf("\b \b");

  359.                         fflush(stdout);

  360.                         d=b;

  361.                         *d = '\0';

  362.                         if ((h=getHisto(c3)) != NULL) {

  363.                            strcpy(b,h);

  364.                            d=b+strlen(h);

  365. /*

  366.                            printf("\n%s (iH=%d iHt=%d)\n",h,iH,iHt);

  367.                            *d='\0';

  368. */

  369.                            printf("%s",b);

  370.                            fflush(stdout);

  371.                         }

  372.                         break; 

  373.                       case 'C' : /* -> */

  374.                         if (ins) {

  375.                            *d = *s;

  376.                            printf("%c",*d++);

  377.                            enleve1(s);

  378.                            if(*s =='\0') ins=0;

  379.                            else {

  380.                               printf("%s",s);

  381.                               for (j=0; j<strlen(s); j++) printf("\b");  

  382.                            }

  383.                            fflush(stdout);

  384.                         }

  385.                         break; 

  386.                       case 'D' : /* <- */

  387.                         if (d>b) {

  388.                            if (ins==0) {

  389.                               ins=1;

  390.                               *d='\0';

  391.                               strcpy(s,d-1);

  392.                            } else insertC(*(d-1),s);

  393.                            d--;

  394.                            printf("\b");

  395.                            fflush(stdout);

  396.                         }

  397.                         break; 

  398.                       default:

  399.                         printf("\nESC [ %d (%c) !\n",(int)c3, c3);

  400.                         *d='\0';

  401.                         printf("> %s",b);

  402.                         fflush(stdout);

  403.                   }

  404.               } else {

  405.                  if (c2 == 'O') {

  406.                     switch(c3) {

  407.                       case 'P' : /* F1 */

  408.                       break; 

  409.                       case 'Q' : /* F2 */

  410.                       break; 

  411.                       case 'R' : /* F3 */

  412.                       break; 

  413.                       case 'S' : /* F4 */

  414.                       break; 

  415.                     }

  416.                  } else {

  417.                   printf("\nESC %d %d (%c) !\n",(int)c2,(int)c3, c3);

  418.                   *d='\0';

  419.                   printf("> %s",b);

  420.                   fflush(stdout);

  421.                  }

  422.               }

  423.               break; 

  424.             default :

  425. /*

  426.               printf("\nCar = %d !\n",(int)c);

  427.               *d='\0';

  428.               printf("> %s",b);

  429.               fflush(stdout);

  430. */

  431.               break; 

  432.          }

  433.      }

  434.      if (ins) ls = strlen(s);

  435.    }

  436. finBoucle:

  437.    /* printf("fin lireLigne!\n"); */

  438.    if ((n<1) && (FD_IN !=0)) {

  439.       closeFD();  /* fichier loader */

  440.       if (ECHOOFF) printf("\n");

  441.       return 0;

  442.    }

  443.    if ((n<1) && iTERM) {

  444.       close(FD_IN);  /* pipe ou autre */

  445.       Nc=dup(iTERM); /* stdin on term */

  446.       iTERM = 0;

  447.       if (ECHOOFF) printf("\n");

  448.       return 0;

  449.    }

  450.    if (d == f) { /* cas du buffer trop petit */

  451. /*   d=b;

  452.      while (*d != '\n') read(fd,d,1);

  453. **** not in raw mode */

  454. #ifdef DEBUG

  455.      printf("lireLigne : erreur !\n");

  456. #endif

  457.      return(-1);

  458.    } 

  459.    *d = '\0';

  460. #ifdef DEBUG

  461.      printf("lireLigne : retour <%s> !\n",b);

  462. #endif

  463.    if (!FD_IN) putHisto(b);

  464.    incFDlig();

  465.    return(strlen(b));

  466. }

  467.