text: 
  
  /*  pdrl.c                                             */  
   
  /*  Some code to allow the editing of a command-line.  */ 
  /*  You can also move around with the left and right   */ 
  /*  arrow keys, and recall previous commands with the  */ 
  /*  up-arrow key.                                      */ 
  /*  This code is released to the public domain.        */ 
  /*  "Share and enjoy...."  ;)                          */  
  /*  See the UNLICENSE file for details.                */ 
  
  /*  TO DO -                                            */ 
  /*  a) Add support for Home and End (of line) keys.    */ 
  /*  b) Add support for function keys.                  */ 
  /*  c) Add support for Insert key so that text can be  */ 
  /*     inserted.                                       */   
  /*  d) Put much of the code into a header file.        */    
  /*  e) Change so that pressing Enter adds the current  */  
  /*     line of commands to the command-history.        */ 
  /*     ( May look at using Ctrl-D to exit, as Python   */ 
  /*     does with its command-line. )                   */           
  /*  f) Add support for copying and pasting text via    */ 
  /*     Ctrl-C and Ctrl-V.                              */  
  
  
  #include <string.h>   
  #include <stdio.h> 
  #include <termios.h>  
  
  /* This implementation of getch() is from here - */ 
  /* http://wesley.vidiqatch.org/                  */ 
  /* Thanks, Wesley!                               */  
  static struct termios old, new;
  
  /* Initialize new terminal i/o settings */
  void initTermios(int echo) {
      tcgetattr(0, &old); /* grab old terminal i/o settings */
      new = old; /* make new settings same as old settings */
      new.c_lflag &= ~ICANON; /* disable buffered i/o */
      new.c_lflag &= echo ? ECHO : ~ECHO; /* set echo mode */
      tcsetattr(0, TCSANOW, &new); /* use these new terminal i/o settings now */
  }
  
  
  /* Restore old terminal i/o settings */
  void resetTermios(void) {
      tcsetattr(0, TCSANOW, &old);
  }
  
  
  /* Read 1 character - echo defines echo mode */
  char getch_(int echo) {
      char ch;
      initTermios(echo);
      ch = getchar();
      resetTermios();
      return ch;
  }
  
  
  /* Read 1 character without echo */
  char getch(void) {
      return getch_(0);
  }
  
  
  /* Read 1 character with echo */
  char getche(void) {
      return getch_(1);
  } 
  
  
  
  /*  Helper function, to let us see if a file */ 
  /*  exists in the current directory.  */ 
  int fexists(char *fname)
  {  
     FILE *fptr;  
     fptr = fopen(fname, "r") ;     
     if ( !fptr )  return -1 ;  /* File does not exist in dir. */ 		 
     fclose(fptr);  
     return 0;    /* File DOES exist in dir.  */   
  } 
  
  
  /* Helper function to chop newlines off the lines read in. */ 
  /* Without this being done, an extra newline is inserted */ 
  /* (which is usually not what is wanted). */ 
  char *chop(char *s)
  {
    s[strcspn(s,"\n")] = '\0'; 
    return s; 
  }
  
  
  /* An array to store the command-history file in. */ 
  /* Only 20 lines are read. */ 
  char hist[20][80];  
  
  
  
  /* Read the file into the array of strings.  */ 
  void readfile(char *fname) 
  { 
     int retval = fexists(fname); 
          
     int i; 
     if (retval == 0) { 
  	  /* File exists, so open it. */  
  	  /* We open it in read-write mode so we can */ 
  	  /* append new commands to it. */ 
  	  FILE *fptr;  
  	  fptr = fopen(fname, "rw"); 
  	 	  	   
  	  for(i=0; i<20; i++)  
  	  {  
  		chop(fgets(hist[i], 80, fptr) );  
  	  }
  	  
     }  /* retval == 0  */   	   
  	
  	else puts("Error! File does not exist. \n");  
  	
  } 	
  
  
  /* Helper function to print the command-history file. */  
  void printfile(void) 
  { 
    int j; 
    	
    for(j=0; j<20; j++) 
       { 
          puts(hist[j]);     	
       }    	
  } 	
  
  
  
  
  /* Helper function. Print a previous command-line WITHOUT */ 
  /* a newline. */ 
  void putline(char *str) 
  {   
    char *line = chop(str); 	
    printf("%s", line);          		
  } 	 
  
  
  
  
  int main(void) 
  { 
  
  /* Our "command-history" file.  */ 
  readfile("test.txt"); 
  
        
  /* "Pointer" for the history file. */ 
  int histpnt = 20;       
        
    
    while(1) 
      {  
                     
        int key = getch();               
         
        /* Printable chars. */  
        if ( (key >= 32)  && (key <= 126) ) 
        { 
  		/* We have a printable key so print it. */   
  		putchar(key);   	
        }  
                                                                         
        /* Up arrow is 27, 91, 65.    ( ESC [ A )   */   
        /* Down arrow is 27, 91, 66.  ( ESC [ B )   */ 
        /* Right arrow is 27, 91, 67. ( ESC [ C )   */ 
        /* Left arrow is 27, 91, 68.  ( ESC [ D )   */    
        /* Function keys.     */ 
        /* F2 is 27, 79, 81.  */  
        /* F3 is 27, 79, 82.  */  
        /* F4 is 27, 79, 83.  */  
        
        /* Backspace */ 
        else if(key == 127) 
        { 
  		 /* Move left 1 char and delete that char */ 		
  		 printf("\033[1D");
  		 printf("\040"); 
  		 printf("\033[1D");		 		 
  	  } 	      
          
       /* We have an escape key-sequence */                           
        else if(key == 27) 
          {
             key = getch(); 
             if(key == 91)               
             key = getch(); 
             
             if (key == 65)   /* Up Arrow */ 
            {   
  			  /* Move one command "back" in history. */  
  			  histpnt -= 1; 			  		  		
  			  /* Clear to end of line. */ 
  			  printf("\033[80D"); 
  			  printf("\033[K"); 			 
  			  /* Print the pointed-at command-sequence. */ 
  			  putline(hist[histpnt]); 			 
            }  
            
            if(key == 66)    /* Down Arrow */   			  
  		  {  
  			  /* Move one command "forward" in history. */  
  			  histpnt += 1;  							  			 
  			  /* Clear to end of line. */ 
  			  printf("\033[80D"); 
  			  printf("\033[K"); 			  			 
  			  /* Print the pointed-at command-sequence. */ 
  			  putline(hist[histpnt]); 			  
  		  }  
  		  
  		  if(key == 67)  /* Left arrow */ 
            { 	
  			 /* Move one character to the left. */ 				 
  			  printf("\033[1C"); 
            }
            
            if(key == 68)  /* Right arrow */ 
            { 	
  			/* Move one character to the right. */ 					  
  			  printf("\033[1D"); 
            }
  		 		  	  		
        }  /* End of key=27 key sequence. */ 
  					  			                                                   
                                                   
       /* The Enter key exits. Enter is 10 decimal */	  
          else if(key == 10)  
  		{ 
  			 puts("\n");  
  			 puts("Exiting... \n"); 					  					
               break;           
           }  /* Key = Enter */   
      }                
                                        
  	return 0;
  
  }  
  
  
  
  
  
  
  