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

493 lines
14 KiB
Raw Permalink Blame History 

  1. /* Copyright (C) 2011-2022  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 getiFD(void)

  84. {

  85.     return iFD;

  86. }

  87. 

  88. int getFDlig(void)

  89. {

  90.     return FD_L[iFD];

  91. }

  92. 

  93. char * getFDname(void)

  94. {

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

  96. }

  97. 

  98. void incFDlig(void)

  99. {

  100.     FD_L[iFD]++;

  101. }

  102. 

  103. 

  104. void razHisto(void)

  105. {

  106. int i;

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

  108.    iH=0;

  109. }

  110. 

  111. void putHisto(char *C)

  112. {

  113. int L;

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

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

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

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

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

  119.        iH++;

  120.        iHl=iH;

  121.        if (iH == HISTOMAX) {

  122.          iHFull=1;

  123.          iH=0;

  124.        }

  125.     }

  126. }

  127. 

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

  129. {

  130. char * C;

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

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

  133.            iHl=iH;

  134.            printf("\a");

  135.            fflush(stdout);

  136.            C = NULL;

  137.        } else {

  138.            iHt++;

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

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

  141.            C = HIST[iHt];

  142.            iHl=iHt;

  143.        }

  144.    } else { /* A */

  145.        if (iHt == -1) {

  146.            iHl=iHt;

  147.            printf("\a");

  148.            fflush(stdout);

  149.            C = NULL;

  150.        } else {

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

  152.           iHl=iHt;

  153.           C = HIST[iHt--];

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

  155.        }

  156.    }

  157.    return(C);

  158. }

  159. 

  160. static struct termios t0, t1;

  161. int iTERM=0;

  162. 

  163. void termInit(void)

  164. {

  165. int nc;

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

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

  168.        if (iTERM<2) continue;

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

  170.        exit(2);

  171.     }

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

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

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

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

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

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

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

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

  180.     t1.c_cflag |= CS8;

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

  182.     /* clear screen */

  183.     nc=system("clear");

  184. }

  185. 

  186. void termReset(void)

  187. {

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

  189. }

  190. 

  191. void enleve1(char * s)

  192. {

  193. char * w;

  194.     w=s;

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

  196. }

  197. 

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

  199. {

  200. char *w;

  201.     w=s;

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

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

  204.     *s=c;

  205. }

  206. 

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

  208. /* fd = file descriptor

  209.    b  = adresse du buffer

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

  211. {

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

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

  214. unsigned int j;

  215. char bufd[50];

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

  217.    d = b;

  218.    f = b+nc;

  219.    while(d<f-ls) {

  220.      if (noErr()) {

  221.          n = -1;

  222.          break;

  223.      }

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

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

  226.      c=*d;

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

  228.         ignTild=0; continue;

  229.      }

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

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

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

  233.                if (ins) {

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

  235.                      enleve1(s);

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

  237.                   else {

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

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

  240.                   }

  241.                }

  242.          }

  243.          fflush(stdout);

  244.          d++;

  245.      } else {

  246.          switch (c) {

  247.             /* Ctrl C

  248.             case '\003' : 

  249.               kill(getpid(), SIGINT);

  250.               break; */

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

  252.               if (d>b) {

  253.                  *d='\0';

  254.                  w=d-1;

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

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

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

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

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

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

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

  262.                     else {

  263.                        if (j==1) {

  264.                           Wl=getLibBegin(w);

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

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

  267.                           if (i>0) {

  268.                              strcpy(w,Wl);

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

  270.                              d+=i;

  271.                              *d++ = ' ';

  272.                              if (ins) {

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

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

  275.                              }

  276.                           } else { /* XXXX */

  277.                              if (i==0) {

  278.                                printf (" ");

  279.                                *d++ = ' ';

  280.                              }

  281.                           }

  282.                        } else {

  283.                           if (rac != NULL) {

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

  285.                              strcpy(w,rac);

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

  287.                              d+=i;

  288.                              if (ins) {

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

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

  291.                              }

  292.                           } else {

  293.                             nbT++;

  294.                             if (nbT>1) {

  295.                                nbT=0;

  296.                                printf("\n");

  297.                                listLibBegin(w);

  298.                                *d='\0';

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

  300.                                if (ins) {

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

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

  303.                                }

  304.                                fflush(stdout);

  305.                             }

  306.                           }

  307.                        }

  308.                     }

  309.                     fflush(stdout);

  310.                  }

  311.               }

  312.               break;

  313.             case '\177':

  314.               if (d>b) {

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

  316.                  if (ins) {

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

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

  319.                  }

  320.                  fflush(stdout);

  321.                  d--;

  322.               }

  323.               break;

  324.             case '\n':

  325.             case '\r':

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

  327.               else {

  328.                  printf("\n");

  329.                  if (ins) {

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

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

  332.                         d+=strlen(s);

  333.                      } else return(-1);

  334.                  }

  335.               }

  336.               goto finBoucle;

  337.          /* gestion des caracteres speciaux */

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

  339.               ignTild=1;

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

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

  342.               if (c2 == '[') { /* CSI - see XTerm Control Sequences */

  343.                   switch(c3) {

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

  345.                         if (ins) {

  346.                            ins++;

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

  348.                         }

  349.                         break; 

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

  351.                         if (ins) {

  352.                            enleve1(s);

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

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

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

  356.                            fflush(stdout);

  357.                         }

  358.                         break; 

  359.                       case 'A' : /* UpArrow */

  360.                       case 'B' : /* DownArrow */

  361.                         ins = 0;

  362.                         /* efface la ligne en cours */

  363.                         l=d-b;

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

  365.                         fflush(stdout);

  366.                         d=b;

  367.                         *d = '\0';

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

  369.                            strcpy(b,h);

  370.                            d=b+strlen(h);

  371. /*

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

  373.                            *d='\0';

  374. */

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

  376.                            fflush(stdout);

  377.                         }

  378.                         break; 

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

  380.                         if (ins) {

  381.                            *d = *s;

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

  383.                            enleve1(s);

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

  385.                            else {

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

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

  388.                            }

  389.                            fflush(stdout);

  390.                         }

  391.                         break; 

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

  393.                         if (d>b) {

  394.                            if (ins==0) {

  395.                               ins=1;

  396.                               *d='\0';

  397.                               strcpy(s,d-1);

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

  399.                            d--;

  400.                            printf("\b");

  401.                            fflush(stdout);

  402.                         }

  403.                         break; 

  404.                       case 'H' : /* home : debug terms ON */

  405.                       case '1' : /* home numeric */

  406.                         IFD_DebugTOn();

  407.                         break; 

  408.                       case 'F' : /* end : debug terms OFF */

  409.                       case '4' : /* end numeric */

  410.                         IFD_DebugTOff();

  411.                         break; 

  412.                       default:

  413.                         sprintf(bufd,"# ignore : ESC [ %d (%c) !",(int)c3, c3);

  414.                         D_Tracenl(bufd);

  415.                         *d='\0';

  416.                         /* **************

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

  418.                         fflush(stdout); */

  419.                   }

  420.               } else {

  421.                  if (c2 == 'O') { /* SS3 - see XTerm Control Sequences */

  422.                     switch(c3) {

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

  424.                       break; 

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

  426.                       break; 

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

  428.                       break; 

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

  430.                       break; 

  431.                       case 'H' : /* home : debug terms ON */

  432.                         IFD_DebugTOn();

  433.                         break; 

  434.                       case 'F' : /* end : debug terms OFF */

  435.                         IFD_DebugTOff();

  436.                         break; 

  437.                     }

  438.                  } else {

  439.                   sprintf(bufd,"# ignore : ESC %d %d (%c) !",(int)c2,(int)c3, c3);

  440.                   D_Tracenl(bufd);

  441.                   *d='\0';

  442.                   /* **************

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

  444.                   fflush(stdout); */

  445.                  }

  446.               }

  447.               break; 

  448.             default :

  449. /*

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

  451.               *d='\0';

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

  453.               fflush(stdout);

  454. */

  455.               break; 

  456.          }

  457.      }

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

  459.    }

  460. finBoucle:

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

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

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

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

  465.       return 0;

  466.    }

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

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

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

  470.       iTERM = 0;

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

  472.       return 0;

  473.    }

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

  475. /*   d=b;

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

  477. **** not in raw mode */

  478. #ifdef DEBUG

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

  480. #endif

  481.      return(-1);

  482.    } 

  483.    *d = '\0';

  484. #ifdef DEBUG

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

  486. #endif

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

  488.    incFDlig();

  489.    return(strlen(b));

  490. }

  491.