base/shell/cmd/history.c

   1 /*
   2  *  HISTORY.C - command line history.
   3  *
   4  *
   5  *  History:
   6  *
   7  *    14/01/95 (Tim Norman)
   8  *        started.
   9  *
  10  *    08/08/95 (Matt Rains)
  11  *        i have cleaned up the source code. changes now bring this source
  12  *        into guidelines for recommended programming practice.
  13  *
  14  *    27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
  15  *        added config.h include
  16  *
  17  *    25-Jan-1999 (Eric Kohl)
  18  *        Cleanup!
  19  *        Unicode and redirection safe!
  20  *
  21  *    25-Jan-1999 (Paolo Pantaleo <paolopan@freemail.it>)
  22  *        Added lots of comments (beginning studying the source)
  23  *        Added command.com's F3 support (see cmdinput.c)
  24  *
  25  */
  26
  27
  28
  29 /*
  30  *  HISTORY.C - command line history. Second version
  31  *
  32  *
  33  *  History:
  34  *
  35  *    06/12/99 (Paolo Pantaleo <paolopan@freemail.it>)
  36  *        started.
  37  *
  38  */
  39
  40 #include "precomp.h"
  41
  42 #ifdef FEATURE_HISTORY
  43
  44 typedef struct tagHISTORY
  45 {
  46     struct tagHISTORY *prev;
  47     struct tagHISTORY *next;
  48     LPTSTR string;
  49 } HIST_ENTRY, * LPHIST_ENTRY;
  50
  51 static INT size, max_size=100;
  52
  53 static LPHIST_ENTRY Top;
  54 static LPHIST_ENTRY Bottom;
  55
  56 static LPHIST_ENTRY curr_ptr=0;
  57
  58 VOID InitHistory(VOID);
  59 VOID History_move_to_bottom(VOID);
  60 VOID History (INT dir, LPTSTR commandline);
  61 VOID CleanHistory(VOID);
  62 VOID History_del_current_entry(LPTSTR str);
  63
  64 /*service functions*/
  65 static VOID del(LPHIST_ENTRY item);
  66 static VOID add_at_bottom(LPTSTR string);
  67 /*VOID add_before_last(LPTSTR string);*/
  68 VOID set_size(INT new_size);
  69
  70
  71 INT CommandHistory (LPTSTR param)
  72 {
  73     LPTSTR tmp;
  74     INT tmp_int;
  75     LPHIST_ENTRY h_tmp;
  76     TCHAR szBuffer[2048];
  77
  78     tmp=_tcschr(param,_T('/'));
  79
  80     if (tmp)
  81     {
  82         param=tmp;
  83         switch (_totupper(param[1]))
  84         {
  85             case _T('F'):/*delete history*/
  86                 CleanHistory();InitHistory();
  87                 break;
  88
  89             case _T('R'):/*read history from standard in*/
  90                 for(;;)
  91                 {
  92                     ConInString(szBuffer,sizeof(szBuffer)/sizeof(TCHAR));
  93                     if (*szBuffer!=_T('\0'))
  94                         History(0,szBuffer);
  95                     else
  96                         break;
  97                 }
  98                 break;
  99
 100             case _T('A'):/*add an antry*/
 101                 History(0,param+2);
 102                 break;
 103
 104             case _T('S'):/*set history size*/
 105                 if ((tmp_int=_ttoi(param+2)))
 106                     set_size(tmp_int);
 107                 break;
 108
 109             default:
 110                 return 1;
 111         }
 112     }
 113     else
 114     {
 115         for (h_tmp = Top->prev; h_tmp != Bottom; h_tmp = h_tmp->prev)
 116             ConErrPuts(h_tmp->string);
 117     }
 118     return 0;
 119 }
 120
 121 VOID set_size(INT new_size)
 122 {
 123     while (new_size<size)
 124         del(Top->prev);
 125
 126     max_size=new_size;
 127 }
 128
 129
 130 VOID InitHistory(VOID)
 131 {
 132     size=0;
 133
 134     Top = cmd_alloc(sizeof(HIST_ENTRY));
 135     Bottom = cmd_alloc(sizeof(HIST_ENTRY));
 136
 137     Top->prev = Bottom;
 138     Top->next = NULL;
 139     Top->string = NULL;
 140
 141     Bottom->prev = NULL;
 142     Bottom->next = Top;
 143     Bottom->string = NULL;
 144
 145     curr_ptr=Bottom;
 146 }
 147
 148
 149 VOID CleanHistory(VOID)
 150 {
 151     while (Bottom->next!=Top)
 152         del(Bottom->next);
 153
 154     cmd_free(Top);
 155     cmd_free(Bottom);
 156 }
 157
 158
 159 VOID History_del_current_entry(LPTSTR str)
 160 {
 161     LPHIST_ENTRY tmp;
 162
 163     if (size == 0)
 164         return;
 165
 166     if (curr_ptr == Bottom)
 167         curr_ptr=Bottom->next;
 168
 169     if (curr_ptr == Top)
 170         curr_ptr=Top->prev;
 171
 172
 173     tmp = curr_ptr;
 174     curr_ptr = curr_ptr->prev;
 175     del(tmp);
 176     History(-1, str);
 177 }
 178
 179
 180 static
 181 VOID del(LPHIST_ENTRY item)
 182 {
 183     if (item==NULL || item==Top || item==Bottom)
 184     {
 185         TRACE ("del in " __FILE__ ": returning\n"
 186                 "item is 0x%08x (Bottom is0x%08x)\n",
 187                 item, Bottom);
 188         return;
 189     }
 190
 191     /*free string's mem*/
 192     if (item->string)
 193         cmd_free(item->string);
 194
 195     /*set links in prev and next item*/
 196     item->next->prev=item->prev;
 197     item->prev->next=item->next;
 198
 199     cmd_free(item);
 200
 201     size--;
 202 }
 203
 204 static
 205 VOID add_at_bottom(LPTSTR string)
 206 {
 207     LPHIST_ENTRY tmp;
 208
 209     /*delete first entry if maximum number of entries is reached*/
 210     while(size>=max_size)
 211         del(Top->prev);
 212
 213     while (_istspace(*string))
 214         string++;
 215
 216     if (*string==_T('\0'))
 217         return;
 218
 219     /*if new entry is the same than the last do not add it*/
 220     if (size)
 221         if (_tcscmp(string,Bottom->next->string)==0)
 222             return;
 223
 224     /*fill bottom with string, it will become Bottom->next*/
 225     Bottom->string=cmd_alloc((_tcslen(string)+1)*sizeof(TCHAR));
 226     _tcscpy(Bottom->string,string);
 227
 228     /*save Bottom value*/
 229     tmp=Bottom;
 230
 231     /*create new void Bottom*/
 232     Bottom=cmd_alloc(sizeof(HIST_ENTRY));
 233     Bottom->next=tmp;
 234     Bottom->prev=NULL;
 235     Bottom->string=NULL;
 236
 237     tmp->prev=Bottom;
 238
 239     /*set new size*/
 240     size++;
 241 }
 242
 243
 244 VOID History_move_to_bottom(VOID)
 245 {
 246     curr_ptr=Bottom;
 247 }
 248
 249 LPCTSTR PeekHistory(INT dir)
 250 {
 251     LPHIST_ENTRY entry = curr_ptr;
 252
 253     if (dir == 0)
 254         return NULL;
 255
 256     if (dir < 0)
 257     {
 258         /* key up */
 259         if (entry->next == Top || entry == Top)
 260         {
 261 #ifdef WRAP_HISTORY
 262             entry = Bottom;
 263 #else
 264             return NULL;
 265 #endif
 266         }
 267         entry = entry->next;
 268     }
 269     else
 270     {
 271         /* key down */
 272         if (entry->next == Bottom || entry == Bottom)
 273         {
 274 #ifdef WRAP_HISTORY
 275             entry = Top;
 276 #else
 277             return NULL;
 278 #endif
 279         }
 280         entry = entry->prev;
 281     }
 282
 283     return entry->string;
 284 }
 285
 286 VOID History (INT dir, LPTSTR commandline)
 287 {
 288     if (dir==0)
 289     {
 290         add_at_bottom(commandline);
 291         curr_ptr=Bottom;
 292         return;
 293     }
 294
 295     if (size==0)
 296     {
 297         commandline[0]=_T('\0');
 298         return;
 299     }
 300
 301     if (dir<0)/*key up*/
 302     {
 303         if (curr_ptr->next==Top || curr_ptr==Top)
 304         {
 305 #ifdef WRAP_HISTORY
 306             curr_ptr=Bottom;
 307 #else
 308             curr_ptr=Top;
 309             commandline[0]=_T('\0');
 310             return;
 311 #endif
 312         }
 313
 314         curr_ptr = curr_ptr->next;
 315         if (curr_ptr->string)
 316             _tcscpy(commandline,curr_ptr->string);
 317     }
 318
 319     if (dir>0)
 320     {
 321         if (curr_ptr->prev==Bottom || curr_ptr==Bottom)
 322         {
 323 #ifdef WRAP_HISTORY
 324             curr_ptr=Top;
 325 #else
 326             curr_ptr=Bottom;
 327             commandline[0]=_T('\0');
 328             return;
 329 #endif
 330         }
 331
 332         curr_ptr=curr_ptr->prev;
 333         if (curr_ptr->string)
 334             _tcscpy(commandline,curr_ptr->string);
 335     }
 336 }
 337
 338 #endif //#if FEATURE_HISTORY