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.
1 Commit
1 Branch
631 KiB
 
 
 
 
Tree: 4c67895371
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4c67895371'
${ noResults }
Nife_v0/src/histo.c

461 lines
13 KiB
Raw Blame History 

  1. /* Copyright (C) 2011-2013  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.     for (iTERM=0; iTERM<3; iTERM++) {

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

  162.        if (iTERM<2) continue;

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

  164.        exit(2);

  165.     }

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

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

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

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

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

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

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

  173.     t1.c_cflag |= CS8;

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

  175. }

  176. 

  177. void termReset(void)

  178. {

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

  180. }

  181. 

  182. void enleve1(char * s)

  183. {

  184. char * w;

  185.     w=s;

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

  187. }

  188. 

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

  190. {

  191. char *w;

  192.     w=s;

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

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

  195.     *s=c;

  196. }

  197. 

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

  199. /* fd = file descriptor

  200.    b  = adresse du buffer

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

  202. {

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

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

  205. unsigned int j;

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

  207.    d = b;

  208.    f = b+nc;

  209.    while(d<f-ls) {

  210.      if (noErr()) {

  211.          n = -1;

  212.          break;

  213.      }

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

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

  216.      c=*d;

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

  218.         ignTild=0; continue;

  219.      }

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

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

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

  223.                if (ins) {

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

  225.                      enleve1(s);

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

  227.                   else {

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

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

  230.                   }

  231.                }

  232.          }

  233.          fflush(stdout);

  234.          d++;

  235.      } else {

  236.          switch (c) {

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

  238.               if (d>b) {

  239.                  *d='\0';

  240.                  w=d-1;

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

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

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

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

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

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

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

  248.                     else {

  249.                        if (j==1) {

  250.                           Wl=getLibBegin(w);

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

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

  253.                           if (i>0) {

  254.                              strcpy(w,Wl);

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

  256.                              d+=i;

  257.                              *d++ = ' ';

  258.                              if (ins) {

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

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

  261.                              }

  262.                           } else { /* XXXX */

  263.                              if (i==0) {

  264.                                printf (" ");

  265.                                *d++ = ' ';

  266.                              }

  267.                           }

  268.                        } else {

  269.                           if (rac != NULL) {

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

  271.                              strcpy(w,rac);

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

  273.                              d+=i;

  274.                              if (ins) {

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

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

  277.                              }

  278.                           } else {

  279.                             nbT++;

  280.                             if (nbT>1) {

  281.                                nbT=0;

  282.                                printf("\n");

  283.                                listLibBegin(w);

  284.                                *d='\0';

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

  286.                                if (ins) {

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

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

  289.                                }

  290.                                fflush(stdout);

  291.                             }

  292.                           }

  293.                        }

  294.                     }

  295.                     fflush(stdout);

  296.                  }

  297.               }

  298.               break;

  299.             case '\177':

  300.               if (d>b) {

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

  302.                  if (ins) {

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

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

  305.                  }

  306.                  fflush(stdout);

  307.                  d--;

  308.               }

  309.               break;

  310.             case '\n':

  311.             case '\r':

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

  313.               else {

  314.                  printf("\n");

  315.                  if (ins) {

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

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

  318.                         d+=strlen(s);

  319.                      } else return(-1);

  320.                  }

  321.               }

  322.               goto finBoucle;

  323.          /* gestion des caracteres speciaux */

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

  325.               ignTild=1;

  326.               read(fd,&c2,1);

  327.               read(fd,&c3,1);

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

  329.                   switch(c3) {

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

  331.                         if (ins) {

  332.                            ins++;

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

  334.                         }

  335.                         break; 

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

  337.                         if (ins) {

  338.                            enleve1(s);

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

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

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

  342.                            fflush(stdout);

  343.                         }

  344.                         break; 

  345.                       case 'A' :

  346.                       case 'B' :

  347.                         ins = 0;

  348.                         /* efface la ligne en cours */

  349.                         l=d-b;

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

  351.                         fflush(stdout);

  352.                         d=b;

  353.                         *d = '\0';

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

  355.                            strcpy(b,h);

  356.                            d=b+strlen(h);

  357. /*

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

  359.                            *d='\0';

  360. */

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

  362.                            fflush(stdout);

  363.                         }

  364.                         break; 

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

  366.                         if (ins) {

  367.                            *d = *s;

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

  369.                            enleve1(s);

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

  371.                            else {

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

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

  374.                            }

  375.                            fflush(stdout);

  376.                         }

  377.                         break; 

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

  379.                         if (d>b) {

  380.                            if (ins==0) {

  381.                               ins=1;

  382.                               *d='\0';

  383.                               strcpy(s,d-1);

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

  385.                            d--;

  386.                            printf("\b");

  387.                            fflush(stdout);

  388.                         }

  389.                         break; 

  390.                       default:

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

  392.                         *d='\0';

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

  394.                         fflush(stdout);

  395.                   }

  396.               } else {

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

  398.                     switch(c3) {

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

  400.                       break; 

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

  402.                       break; 

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

  404.                       break; 

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

  406.                       break; 

  407.                     }

  408.                  } else {

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

  410.                   *d='\0';

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

  412.                   fflush(stdout);

  413.                  }

  414.               }

  415.               break; 

  416.             default :

  417. /*

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

  419.               *d='\0';

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

  421.               fflush(stdout);

  422. */

  423.               break; 

  424.          }

  425.      }

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

  427.    }

  428. finBoucle:

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

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

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

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

  433.       return 0;

  434.    }

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

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

  437.       dup(iTERM); /* stdin on term */

  438.       iTERM = 0;

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

  440.       return 0;

  441.    }

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

  443. /*   d=b;

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

  445. **** not in raw mode */

  446. #ifdef DEBUG

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

  448. #endif

  449.      return(-1);

  450.    } 

  451.    *d = '\0';

  452. #ifdef DEBUG

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

  454. #endif

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

  456.    incFDlig();

  457.    return(strlen(b));

  458. }

  459.