[BACK]Return to t.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitcli / example

Diff for /libaitcli/example/t.c between versions 1.1.2.1 and 1.1.2.2

version 1.1.2.1, 2010/06/02 17:17:56 version 1.1.2.2, 2010/06/03 23:29:32
Line 14 Line 14
 int freeLineCLI(linebuffer_t * __restrict buffer);  int freeLineCLI(linebuffer_t * __restrict buffer);
   
   
   static inline void
   clrscrEOL(linebuffer_t * __restrict buf)
   {
           register int i;
   
           if (buf) {
                   write(buf->line_out, K_CR, 1);
   
                   for (i = 0; i < buf->line_len; i++)
                           write(buf->line_out, K_SPACE, 1);
           }
   }
   
   static inline void
   printfEOL(linebuffer_t * __restrict buf, int len, int prompt)
   {
           if (buf) {
                   write(buf->line_out, K_CR, 1);
   
                   if (prompt && buf->line_prompt)
                           write(buf->line_out, buf->line_prompt, buf->line_bol);
   
   //              printf("buf=%s eol=%d bol=%d len=%d\n", buf->line_buf, buf->line_eol, buf->line_bol, buf->line_len);
                   write(buf->line_out, buf->line_buf, len == -1 ? buf->line_eol - buf->line_bol: len);
           }
   }
   
   static inline void
   printfCR(linebuffer_t * __restrict buf, int prompt)
   {
           if (buf) {
                   write(buf->line_out, K_CR, 1);
   
                   if (prompt)
                           if (prompt && buf->line_prompt)
                                   write(buf->line_out, buf->line_prompt, buf->line_bol);
           }
   }
   
   static inline void
   printfCLI(linebuffer_t * __restrict buf, const unsigned char *text, int textlen, int prompt)
   {
           if (buf && text && textlen) {
                   if (prompt && buf->line_prompt)
                           write(buf->line_out, buf->line_prompt, buf->line_bol);
   
                   write(buf->line_out, text, textlen);
           }
   }
   
   
 static int  static int
 catCh2Buf(int idx, void * __restrict buffer)  catCh2Buf(int idx, void * __restrict buffer)
 {  {
         linebuffer_t *buf = buffer;          linebuffer_t *buf = buffer;
        char *ptr;        int pos;
   
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        ptr = realloc(buf->line_buf, buf->line_len + buf->line_keys[idx].key_len);        pos = buf->line_eol - buf->line_bol;
        if (!ptr)
                return RETCODE_ERR;        if (buf->line_eol == buf->line_len - 1)
        else 
                 buf->line_len += buf->line_keys[idx].key_len;                  buf->line_len += buf->line_keys[idx].key_len;
           buf->line_eol += buf->line_keys[idx].key_len;
   
        memcpy(ptr + buf->line_eol, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);        memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
        ptr[buf->line_len - 1] = 0;        buf->line_buf[buf->line_len - 1] = 0;
   
         /* show */  
         write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);          write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
   
         buf->line_eol += buf->line_keys[idx].key_len;  
         buf->line_buf = ptr;  
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
 static int  static int
 bufEOL(int idx, void * __restrict buffer)  bufEOL(int idx, void * __restrict buffer)
 {  {
         linebuffer_t *buf = buffer;  
   
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        /* show */        printfCR(buffer, 1);
        write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); 
 
         return RETCODE_EOL;          return RETCODE_EOL;
 }  }
   
Line 62  bufEOF(int idx, void * __restrict buffer) Line 105  bufEOF(int idx, void * __restrict buffer)
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
         /* show */  
         write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);          write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
   
         return RETCODE_EOF;          return RETCODE_EOF;
 }  }
   
Line 86  static int Line 127  static int
 bufUP(int idx, void * __restrict buffer)  bufUP(int idx, void * __restrict buffer)
 {  {
         linebuffer_t *buf = buffer;          linebuffer_t *buf = buffer;
        char *ptr;        int pos;
        register int i; 
   
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 99  bufUP(int idx, void * __restrict buffer) Line 139  bufUP(int idx, void * __restrict buffer)
         if (!buf->line_h)          if (!buf->line_h)
                 return RETCODE_OK;                  return RETCODE_OK;
   
        /* clear line */        clrscrEOL(buf);
        write(buf->line_out, K_CR, 1);        freeLineCLI(buf);
        for (i = 0; i < buf->line_len; i++) 
                write(buf->line_out, K_SPACE, 1); 
   
        freeLineCLI(buffer);        pos = buf->line_eol - buf->line_bol;
        ptr = realloc(buf->line_buf, buf->line_len + buf->line_h->hist_len); 
        if (!ptr) 
                return RETCODE_ERR; 
        else 
                buf->line_len += buf->line_h->hist_len; 
   
        memcpy(ptr + buf->line_eol, buf->line_h->hist_line, buf->line_h->hist_len);        buf->line_len += buf->line_h->hist_len;
        ptr[buf->line_len - 1] = 0; 
 
         buf->line_eol += buf->line_h->hist_len;          buf->line_eol += buf->line_h->hist_len;
         buf->line_buf = ptr;  
   
        /* show */        memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
        write(buf->line_out, K_CR, 1);        buf->line_buf[buf->line_len - 1] = 0;
        write(buf->line_out, buf->line_buf, buf->line_len); 
   
           printfEOL(buf, -1, 1);
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
Line 128  static int Line 158  static int
 bufDOWN(int idx, void * __restrict buffer)  bufDOWN(int idx, void * __restrict buffer)
 {  {
         linebuffer_t *buf = buffer;          linebuffer_t *buf = buffer;
        char *ptr;        int pos;
        register int i; 
   
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
Line 141  bufDOWN(int idx, void * __restrict buffer) Line 170  bufDOWN(int idx, void * __restrict buffer)
         if (!buf->line_h)          if (!buf->line_h)
                 return RETCODE_OK;                  return RETCODE_OK;
   
        /* clear line */        clrscrEOL(buf);
        write(buf->line_out, K_CR, 1);        freeLineCLI(buf);
        for (i = 0; i < buf->line_len; i++) 
                write(buf->line_out, K_SPACE, 1); 
   
           pos = buf->line_eol - buf->line_bol;
   
           buf->line_len += buf->line_h->hist_len;
           buf->line_eol += buf->line_h->hist_len;
   
           memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
           buf->line_buf[buf->line_len - 1] = 0;
   
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
   static int
   bufClr(int idx, void * __restrict buffer)
   {
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           clrscrEOL(buffer);
         freeLineCLI(buffer);          freeLineCLI(buffer);
        ptr = realloc(buf->line_buf, buf->line_len + buf->line_h->hist_len);
        if (!ptr)        printfCR(buffer, 1);
         return RETCODE_OK;
 }
 
 static int
 bufBS(int idx, void * __restrict buffer)
 {
         linebuffer_t *buf = buffer;
 
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
         else  
                 buf->line_len += buf->line_h->hist_len;  
   
        memcpy(ptr + buf->line_eol, buf->line_h->hist_line, buf->line_h->hist_len);        if (buf->line_bol < buf->line_eol) {
        ptr[buf->line_len - 1] = 0;                clrscrEOL(buf);
   
        buf->line_eol += buf->line_h->hist_len;                buf->line_eol--;
        buf->line_buf = ptr;                buf->line_len--;
                 buf->line_buf[buf->line_eol - buf->line_bol] = 0;
   
        /* show */                printfEOL(buf, -1, 1);
        write(buf->line_out, K_CR, 1);        }
        write(buf->line_out, buf->line_buf, buf->line_len); 
   
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
 static int  static int
bufClr(int idx, void * __restrict buffer)bufMode(int idx, void * __restrict buffer)
 {  {
         linebuffer_t *buf = buffer;          linebuffer_t *buf = buffer;
         register int i;  
   
         if (!buffer || idx < 0 || idx > MAX_BINDKEY)          if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;                  return RETCODE_ERR;
   
        /* clear line */        buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS;
        write(buf->line_out, K_CR, 1);        return RETCODE_OK;
        for (i = 0; i < buf->line_len; i++)}
                write(buf->line_out, K_SPACE, 1); 
   
        freeLineCLI(buffer);static int
 bufBegin(int idx, void * __restrict buffer)
 {
         linebuffer_t *buf = buffer;
   
        write(buf->line_out, K_CR, 1);        if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                 return RETCODE_ERR;
 
         buf->line_eol = buf->line_bol;
 
         printfCR(buf, 1);
         return RETCODE_OK;          return RETCODE_OK;
 }  }
   
   static int
   bufEnd(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           buf->line_eol = buf->line_len - 1;
   
           printfEOL(buf, -1, 1);
           return RETCODE_OK;
   }
   
   static int
   bufLEFT(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_bol < buf->line_eol)
                   printfEOL(buf, --buf->line_eol - buf->line_bol, 1);
   
           return RETCODE_OK;
   }
   
   static int
   bufRIGHT(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_eol < buf->line_len - 1)
                   printfEOL(buf, ++buf->line_eol - buf->line_bol, 1);
   
           return RETCODE_OK;
   }
   
   static int
   bufDel(int idx, void * __restrict buffer)
   {
           linebuffer_t *buf = buffer;
   
           if (!buffer || idx < 0 || idx > MAX_BINDKEY)
                   return RETCODE_ERR;
   
           if (buf->line_bol < buf->line_eol) {
                   clrscrEOL(buf);
   
                   buf->line_eol--;
                   buf->line_len--;
                   buf->line_buf[buf->line_eol] = 0;
   
                   printfEOL(buf, -1, 1);
           }
   
           return RETCODE_OK;
   }
   
 // ---------------------------------------------------------------  // ---------------------------------------------------------------
   
 int  int
Line 206  bindKeyCLI(bindkey_t * __restrict key, linebuffer_t *  Line 328  bindKeyCLI(bindkey_t * __restrict key, linebuffer_t * 
 }  }
   
 linebuffer_t *  linebuffer_t *
initCLI(int fin, int fout)initCLI(int fin, int fout, const char *prompt)
 {  {
         linebuffer_t *buffer;          linebuffer_t *buffer;
         bindkey_t *keys;          bindkey_t *keys;
Line 225  initCLI(int fin, int fout) Line 347  initCLI(int fin, int fout)
                 buffer->line_out = fout;                  buffer->line_out = fout;
   
                 TAILQ_INIT(&buffer->line_history);                  TAILQ_INIT(&buffer->line_history);
   
                   if (prompt) {
                           buffer->line_prompt = strdup(prompt);
                           if (!buffer->line_prompt) {
                                   free(buffer);
                                   return NULL;
                           } else {
                                   buffer->line_bol = strlen(buffer->line_prompt);
                                   buffer->line_eol = buffer->line_bol;
                           }
                   }
         }          }
        buffer->line_buf = malloc(1);        buffer->line_buf = malloc(BUFSIZ);
         if (!buffer->line_buf) {          if (!buffer->line_buf) {
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
                 free(buffer);                  free(buffer);
                 return NULL;                  return NULL;
         } else {          } else {
                *buffer->line_buf = 0;                memset(buffer->line_buf, 0, BUFSIZ);
                buffer->line_len = 1;                buffer->line_len = 1 + buffer->line_eol;
         }          }
         keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));          keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
         if (!keys) {          if (!keys) {
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
                 free(buffer->line_buf);                  free(buffer->line_buf);
                 free(buffer);                  free(buffer);
                 return NULL;                  return NULL;
Line 252  initCLI(int fin, int fout) Line 389  initCLI(int fin, int fout)
                         keys[i].key_func = bufEOF;                          keys[i].key_func = bufEOF;
                 if (i == *K_CTRL_M || i == *K_CTRL_J)                  if (i == *K_CTRL_M || i == *K_CTRL_J)
                         keys[i].key_func = bufEOL;                          keys[i].key_func = bufEOL;
                   if (i == *K_CTRL_H || i == *K_BACKSPACE)
                           keys[i].key_func = bufBS;
                 if (i == *K_CTRL_C)                  if (i == *K_CTRL_C)
                         keys[i].key_func = bufClr;                          keys[i].key_func = bufClr;
                   if (i == *K_CTRL_A)
                           keys[i].key_func = bufBegin;
                   if (i == *K_CTRL_E)
                           keys[i].key_func = bufEnd;
                 if (i >= *K_SPACE && i < *K_BACKSPACE)                  if (i >= *K_SPACE && i < *K_BACKSPACE)
                         keys[i].key_func = catCh2Buf;                          keys[i].key_func = catCh2Buf;
                 if (i > *K_BACKSPACE && i < 0xff)                  if (i > *K_BACKSPACE && i < 0xff)
Line 324  initCLI(int fin, int fout) Line 467  initCLI(int fin, int fout)
         keys[i].key_len = sizeof K_CTRL_F12 - 1;          keys[i].key_len = sizeof K_CTRL_F12 - 1;
         memcpy(keys[i].key_ch, K_CTRL_F12, keys[i++].key_len);          memcpy(keys[i].key_ch, K_CTRL_F12, keys[i++].key_len);
         keys[i].key_len = sizeof K_HOME - 1;          keys[i].key_len = sizeof K_HOME - 1;
           keys[i].key_func = bufBegin;
         memcpy(keys[i].key_ch, K_HOME, keys[i++].key_len);          memcpy(keys[i].key_ch, K_HOME, keys[i++].key_len);
         keys[i].key_len = sizeof K_END - 1;          keys[i].key_len = sizeof K_END - 1;
           keys[i].key_func = bufEnd;
         memcpy(keys[i].key_ch, K_END, keys[i++].key_len);          memcpy(keys[i].key_ch, K_END, keys[i++].key_len);
         keys[i].key_len = sizeof K_UP - 1;          keys[i].key_len = sizeof K_UP - 1;
         keys[i].key_func = bufUP;          keys[i].key_func = bufUP;
Line 334  initCLI(int fin, int fout) Line 479  initCLI(int fin, int fout)
         keys[i].key_func = bufDOWN;          keys[i].key_func = bufDOWN;
         memcpy(keys[i].key_ch, K_DOWN, keys[i++].key_len);          memcpy(keys[i].key_ch, K_DOWN, keys[i++].key_len);
         keys[i].key_len = sizeof K_RIGHT - 1;          keys[i].key_len = sizeof K_RIGHT - 1;
           keys[i].key_func = bufRIGHT;
         memcpy(keys[i].key_ch, K_RIGHT, keys[i++].key_len);          memcpy(keys[i].key_ch, K_RIGHT, keys[i++].key_len);
         keys[i].key_len = sizeof K_LEFT - 1;          keys[i].key_len = sizeof K_LEFT - 1;
           keys[i].key_func = bufLEFT;
         memcpy(keys[i].key_ch, K_LEFT, keys[i++].key_len);          memcpy(keys[i].key_ch, K_LEFT, keys[i++].key_len);
         keys[i].key_len = sizeof K_BTAB - 1;          keys[i].key_len = sizeof K_BTAB - 1;
           keys[i].key_func = bufBS;
         memcpy(keys[i].key_ch, K_BTAB, keys[i++].key_len);          memcpy(keys[i].key_ch, K_BTAB, keys[i++].key_len);
         // 4 bytes          // 4 bytes
         keys[i].key_len = sizeof K_INS - 1;          keys[i].key_len = sizeof K_INS - 1;
           keys[i].key_func = bufMode;
         memcpy(keys[i].key_ch, K_INS, keys[i++].key_len);          memcpy(keys[i].key_ch, K_INS, keys[i++].key_len);
         keys[i].key_len = sizeof K_DEL - 1;          keys[i].key_len = sizeof K_DEL - 1;
           keys[i].key_func = bufDel;
         memcpy(keys[i].key_ch, K_DEL, keys[i++].key_len);          memcpy(keys[i].key_ch, K_DEL, keys[i++].key_len);
         keys[i].key_len = sizeof K_PGUP - 1;          keys[i].key_len = sizeof K_PGUP - 1;
         memcpy(keys[i].key_ch, K_PGUP, keys[i++].key_len);          memcpy(keys[i].key_ch, K_PGUP, keys[i++].key_len);
Line 388  endCLI(linebuffer_t * __restrict buffer) Line 538  endCLI(linebuffer_t * __restrict buffer)
                         free(h);                          free(h);
                 }                  }
   
                   if (buffer->line_prompt)
                           free(buffer->line_prompt);
   
                 if (buffer->line_keys)                  if (buffer->line_keys)
                         free(buffer->line_keys);                          free(buffer->line_keys);
                 if (buffer->line_buf)                  if (buffer->line_buf)
Line 398  endCLI(linebuffer_t * __restrict buffer) Line 551  endCLI(linebuffer_t * __restrict buffer)
         }          }
 }  }
   
   void
   setPromptCLI(linebuffer_t * __restrict buffer, const char *prompt)
   {
           if (buffer) {
                   if (buffer->line_prompt) {
                           free(buffer->line_prompt);
                           buffer->line_prompt = NULL;
                           buffer->line_bol = 0;
                   }
   
                   if (prompt) {
                           buffer->line_prompt = strdup(prompt);
                           if (buffer->line_prompt) {
                                   buffer->line_bol = strlen(buffer->line_prompt);
                                   buffer->line_eol = buffer->line_bol;
                                   buffer->line_len = 1 + buffer->line_eol;
                           }
                   }
           }
   }
   
 int  int
 freeLineCLI(linebuffer_t * __restrict buffer)  freeLineCLI(linebuffer_t * __restrict buffer)
 {  {
Line 407  freeLineCLI(linebuffer_t * __restrict buffer) Line 581  freeLineCLI(linebuffer_t * __restrict buffer)
                 if (buffer->line_buf)                  if (buffer->line_buf)
                         free(buffer->line_buf);                          free(buffer->line_buf);
   
                buffer->line_buf = malloc(1);                buffer->line_buf = malloc(BUFSIZ);
                 if (buffer->line_buf) {                  if (buffer->line_buf) {
                        *buffer->line_buf = 0;                        memset(buffer->line_buf, 0, BUFSIZ);
                        buffer->line_eol = 0;                        buffer->line_eol = buffer->line_bol;
                        buffer->line_len = 1;                        buffer->line_len = 1 + buffer->line_eol;
   
                         code = RETCODE_OK;                          code = RETCODE_OK;
                 }                  }
Line 435  readLineCLI(linebuffer_t * __restrict buffer) Line 609  readLineCLI(linebuffer_t * __restrict buffer)
         fds.fd = buffer->line_in;          fds.fd = buffer->line_in;
         fds.events = POLLIN;          fds.events = POLLIN;
   
           printfCR(buffer, 1);
         while (42) {          while (42) {
                 if (poll(&fds, 1, -1) < 1)                  if (poll(&fds, 1, -1) < 1)
                         return RETCODE_ERR;                          return RETCODE_ERR;
Line 511  addHistoryCLI(linebuffer_t * __restrict buffer, const  Line 686  addHistoryCLI(linebuffer_t * __restrict buffer, const 
 }  }
   
 int  int
saveHistoryCLI(linebuffer_t * __restrict buffer, const char *histfile)saveHistoryCLI(linebuffer_t * __restrict buffer, const char *histfile, int lines)
 {  {
         FILE *f;          FILE *f;
         mode_t mode;          mode_t mode;
Line 529  saveHistoryCLI(linebuffer_t * __restrict buffer, const Line 704  saveHistoryCLI(linebuffer_t * __restrict buffer, const
         f = fopen(szFName, "w");          f = fopen(szFName, "w");
         if (!f)          if (!f)
                 return RETCODE_ERR;                  return RETCODE_ERR;
        TAILQ_FOREACH(h, &buffer->line_history, hist_next)        TAILQ_FOREACH(h, &buffer->line_history, hist_next) {
                 fprintf(f, "%s\n", h->hist_line);                  fprintf(f, "%s\n", h->hist_line);
   
                   if (lines)
                           lines--;
                   else
                           break;
           }
         fclose(f);          fclose(f);
         umask(mode);          umask(mode);
   
Line 580  resetHistoryCLI(linebuffer_t * __restrict buffer) Line 761  resetHistoryCLI(linebuffer_t * __restrict buffer)
         buffer->line_h = NULL;          buffer->line_h = NULL;
 }  }
   
   // ------------------------------------------------------------
   
 int  int
 main()  main()
 {  {
         int ret;          int ret;
         bindkey_t key = { sizeof K_TAB - 1, K_TAB, bufTab };          bindkey_t key = { sizeof K_TAB - 1, K_TAB, bufTab };
        linebuffer_t *buffer = initCLI(STDIN_FILENO, STDOUT_FILENO);        linebuffer_t *buffer = initCLI(STDIN_FILENO, STDOUT_FILENO, /*CLI_PROMPT*/ NULL);
   
         bindKeyCLI(&key, buffer);          bindKeyCLI(&key, buffer);
   
Line 596  main() Line 778  main()
                 ret = readLineCLI(buffer);                  ret = readLineCLI(buffer);
                 addHistoryCLI(buffer, NULL);                  addHistoryCLI(buffer, NULL);
   
                printf("LINE=%s (%d)/%d CODE=%d\n", buffer->line_buf, buffer->line_len, buffer->line_eol, ret);                printf("LINE=%s (%d)/%d/%d CODE=%d\n", buffer->line_buf, buffer->line_len, buffer->line_eol, buffer->line_bol, ret);
   
                 freeLineCLI(buffer);                  freeLineCLI(buffer);
                 resetHistoryCLI(buffer);                  resetHistoryCLI(buffer);
Line 605  main() Line 787  main()
                         break;                          break;
         }          }
   
        saveHistoryCLI(buffer, NULL);        saveHistoryCLI(buffer, NULL, HISTORY_LINES);
   
         endCLI(buffer);          endCLI(buffer);
         return 0;          return 0;
Removed from v.1.1.2.1  
changed lines
  Added in v.1.1.2.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>