/*                             FIX v1.8
                                  by
                             Dave Huntoon
                               12/25/86

Can be reached at
  Rochester Connection BBS
  Rochester, NY
  716-223-8133
  300/1200 BAUD

CIS 73317,3325

*/

/*  LANGUAGE ==> AZTEC C II
                 Compile using "-tiny" switch for smaller .com size

**************************************************************************

    FIX will open a specified file and search for the selected
    character (CR, LF, TAB, SP, NULL) and add or change as follows:


         -ANn   adds <n> NULLS after every LF for slow printers.
                  value can be from 1 to 9, default = 5

         -AL    adds a line feed (LF) after every carriage return CR.

         -AC    adds a carriage return (CR) after every LF.

         -ESn  exchanges SPACEs for TABs on character boundary of <n>
                  values can be from 2 to 8, default = 8.

         -ETn  exchanges TABs for SPACEs on character boundary of <n>
                  values can be from 2 to 8, default = 8.

         -EC   exchanges CR for LF

         -EL   exchanges LF for CR

         -RL   removes all LF's

         -RC   removes all CR's

         -RN   removes all NULL's

         -M    mask off 8th bit of all characters

    All changes will be written to <filename>.CNG, Drive can be selected.
*/


#include "stdio.h"
#include "ctype.h"

#define TRUE    1
#define FALSE   0
#define ERROR   0
#define NULL    0
#define MAX     8
#define NMAX    9
#define MIN     1
#define TMIN    2
#define NOM     8
#define NNOM    5
#define MASKVAL 0x7F
#define SP      0x20
#define LF      0x0a
#define CR      0x0d
#define TAB     0x09
#define BELL    0x07
#define CMD     '-'



main(argc,argv)
int  argc  ;
char *argv[]  ;

{
 int   i,j,length, length1, temp,space_count,ch1,
      drive,point,change,add,exchange,remove,mask  ;

 FILE  *f1, *f2, *fopen()  ;

 char  filenm[20], ch[5], ch2[5], name[20] ;


  printf("\n\n  FIX...Ver 1.8\n")  ;
  printf("\t  by Dave Huntoon 12/25/86\n\n")  ;

  if (argc==1 || argc != 3 )
      syntax()  ;

  strcpy(ch,argv[2])  ;

  if((ch[0] != CMD) || (strlen(ch) > 4))
      {
       printf("\n*** Command format error ***\n")  ;
       syntax()  ;
      }

 ch1=ch[1]  ;  /* Get primary command */
 strcpy(filenm,argv[1])  ;
 printf("Input file  ==> %s\n",filenm)  ;

 j= point = drive = FALSE  ; /* Initialize */

 printf("\nDrive [n] to write output to or <return> if same ==> ")  ;
 temp=getchar() ;

 if (iscntrl(temp)==0)
  {                         /* add drive specs to filename to write to */
   temp = toupper(temp)  ;
   if ((temp < 'A') || (temp > 'P'))
    {
     printf("\n\t*** Drive spec ERROR ***\n")  ;
     exit(0)  ;
    }
   drive=TRUE  ;
   name[0]=temp  ;
   name[1]=':'  ;
   point= 2 ;
  }                         /* end adding drive to name */

 j=-1  ;
   for(i=point; i<11; i++)  /* make file name string with/without drive extension  */
     {                      /*   and add/change extension to .cng  */
       j = ++j  ;
       name[i]=filenm[j]  ;
       if(name[i] == ':' && drive == TRUE) /* If input file name had drive */
         i=(point-1)  ;                    /*  extension get rid of it if  */  
                                           /*  new drive was selected.     */
       if(name[i] == NULL)   /* filename had no DOT extension */
          name[i] = '.'  ;    

       if(name[i] == '.')    /* Are we at the end of file name ? */
        {
         name[i+1]=NULL  ;
         strcat(name,"CNG")  ; /* Add CNG extension */
         break  ;
        }
      }

  printf("\nOutput file ==> %s\n",name) ;/* Finaly...we have output file name */

  if ((f1=fopen(argv[1],"r"))==NULL) /* Open input file */
   {
    printf("\nError opening input file ==>>%s\n",argv[1])  ;
    exit(1)  ;
   }
  if ((f2=fopen(name,"w"))==NULL) /* Open output file */
   {
    printf("\nError opening output file ==>>%s\n",name)  ;
    exit(1)  ;
   }

       /*  Decide on command to invoke */

mask = exchange = remove = FALSE  ; /* Initialize */

    switch(ch1) /* Primary command */
    {

     case 'A':       /* ADD */
     case 'a': 

               if (ch[2]=='C' || ch[2]=='c') /* Secondary command */
                {
                 printf("\nAdding CR for each LF\n")  ;
                 add=(char)CR  ;
                 change=(char)LF  ;
                 break  ;
                }

              if (ch[2] == 'L' || ch[2] == 'l')
                {
                 printf("\nAdding LF for each CR\n")  ;
                 add=(char)LF  ;
                 change=(char)CR  ;
                 break  ;
                }


               if (ch[2] == 'N' || ch[2] == 'n') 
                 {
                  ch2[0]=ch[3]  ;
                  ch2[1]=NULL  ;
                  length=atoi(ch2)  ;
                  if(length < MIN || length > NMAX) /* decide on # of NULLs to add */
                    length = NNOM  ;
                  printf("\nAdding %d NULLs after each LF\n",length)  ;
                  add = NULL  ;
                  change = LF  ;
                  break  ;
                 }
             printf("\nUnknown ADD extension => %c\n",ch[2])  ;
             exit(1)  ;

      case 'E':    /* Exchange */
      case 'e':  

                  if (ch[2] == 'S' || ch[2] == 's')
                    {    
                      ch2[0]=ch[3]  ;
                      ch2[1]=NULL  ;
                      length=atoi(ch2)  ;
                      if(length < TMIN || length > MAX) /* decide on char boundary */
                        length = NOM  ;
                      printf("\nExchanging SPACEs for TABs on char boundary of %d\n",length)  ;
                      add=(char)SP  ;
                      change=(char)TAB  ;
                      exchange=TRUE  ;
                      break  ;
                     }
                  if (ch[2] == 'T' || ch[2] == 't')
                    {    
                      ch2[0]=ch[3]  ;
                      ch2[1]=NULL  ;
                      length=atoi(ch2)  ;
                      if(length < TMIN || length > MAX) /* decide on character boundary */
                        length = NOM  ;
                      printf("\nExchanging TABs for SPACEs on char boundary of %d\n",length)  ;
                      add=(char)TAB  ;
                      change=(char)SP  ;
                      exchange=TRUE  ;
                      break  ;
                     }
                  if (ch[2] == 'c' || ch[2] == 'C')
                    {
                     printf ("\nExchanging CR for LF\n")  ;
                     add = CR  ;
                     change = LF  ;
                     exchange = TRUE  ;
                     break  ;
                    }
                  if (ch[2] == 'l' || ch[2] == 'L')
                    {
                     printf("\nExchanging LF for CR\n")  ;
                     add = LF  ;
                     change = CR  ;
                     exchange = TRUE  ;
                     break  ;
                    }
               printf("\nUnknown EXCHANGE extension => %c\n",ch[2])  ;
               exit(1) ;

     case 'R':     /* Remove */
     case 'r':  

                 if (ch[2] == 'c' || ch[2] == 'C')
                   {
                    printf ("\nRemoving all CR's\n")  ;
                    change = CR  ;
                    remove = TRUE  ;
                    break  ;
                   }
                 if (ch[2] == 'l' || ch[2] == 'L')
                   {
                    printf("\nRemoving all LF's\n")  ;
                    change = LF  ;
                    remove = TRUE  ;
                    break  ;
                   }
                 if (ch[2] == 'n' || ch[2] == 'N')
                   {
                    printf("\nRemoving all NULL's\n")  ;
                    change = NULL  ;
                    remove = TRUE  ;
                    break  ;
                   }
                 printf("\nUnknown REMOVE extension => %c\n",ch[2])  ;
                 exit(1)  ;

     case 'M':     /* Mask */
     case 'm':  
                   {
                    printf ("\nMasking off bit 8\n")  ;
                    mask = TRUE  ;
                    break  ;
                   }

    default:    {
                  printf("\nUnknown command ==>  %s\n\n",ch)  ;
                  exit(0)  ;
                }
    }                                      /* end of command */


   /* Go Fix the file */

    j=0  ;                                 /* char counter */
    space_count = 0  ;                     /* counter for entab */ 


    while((ch1=getc(f1)) != EOF)
      {
       if(j>=length || ch1==CR || ch1==LF) /* keep track of character position */
         j=0  ;                            /*  for EnTAB/DeTABing   */
       length1=length-j  ;

       j=j+1  ;                            /* character position counter for boundary calculations */

       if(ch1==CR || ch1==LF)              /* reset counter at new line */
         j=0  ;

       if(ch1==change)                     /* Is it character to be changed? */ 
        {
          switch(ch1)
          {

            case TAB:    {        /* DeTAB */
                          ch1=(char)SP  ;
                          j=0  ;
                          for(i=0; i<length1; i++) /* replace TABs with n SPACEs */
                          sputc(ch1,f2)  ;
                          break  ;
                          }
            case SP:      {       /*  EnTAB  */
                           if(exchange)  
                            {
                             if(length1==1)
                               {
                                if(space_count==0)
                                  sputc(SP,f2)  ; /* don't replace single space with TAB */
                               else   sputc(TAB,f2)  ;/* 2 or more spaces replace with TAB */
                                space_count=0  ;
                               }
                             else  space_count += 1  ;
                            }
                            break  ;
                           }

            case CR:
            case NULL:
                          {
                           if (remove)  /* remove CR or NULL */
                             break  ;

                           if(exchange) /* exchange - remove CR add LF */
                             {
                              sputc(add,f2)  ;
                              break  ;
                             }

                           sputc(change,f2)  ; /* add - add LF */
                           sputc(add,f2)  ;
                           break  ;
                           }

             case LF:      {
                            if (remove)
                              break  ;

                            if (exchange)
                              {
                               sputc(add,f2) ;
                               break  ;
                              }
                            sputc(change,f2)  ;

                            if (add == CR)
                              sputc(add,f2)  ;

                            if (add == NULL)
                              {
                               ch1=(char)NULL  ; /* add n NULLs for LF */
                               for (i=0; i<length; i++)
                               sputc(ch1,f2)  ;
                              }
                            break  ;
                           }

          }
        }
    else 
     {
      if((add==TAB) && (ch1 != SP) && (space_count>0)) /* reset space counter if character */
       {                                 /*  isn't a space */
        for(i=0; i<space_count;  i++)    /* if spaces don't fall on character */
          sputc(SP,f2)  ;                /*   boundary then put them back     */
        space_count=0  ;                 /* and restart count  */
       }
     if (mask)                           /* Mask off bit 8  */
      ch1 &= MASKVAL  ;
     sputc(ch1,f2)  ; /* char isn't CR,LF,TAB,SPACE,NULL so send to file */
    }
   }

 fclose(f1)  ;  /* done */
 fclose(f2)  ;


}  /* end of Fix */

sputc(och,f2)   /* Output character and check if file error */

char och  ;
FILE  *f2  ;

    {

    if (putc(och,f2) == -1)
      {
      printf("\n\t***   Disk ERROR   ***%c\n",BELL)  ;
      fclose(f2)  ;
      exit(1)  ;
      }
    }    /* end of sputc */



syntax()

        /*  Incorrect syntax -- INFORM user!  */

    {
    printf("Correct syntax is:\n\n")  ;
    printf("\tFIX <filename> -ANn  add n NULLS for each LF\n")  ;
    printf("\t                       n = 1 to 9, default = 5\n")  ;
    printf("\t               -AL   adds LF after each CR\n")  ;
    printf("\t               -AC   adds CR after each LF\n")  ;
    printf("\t               -EC   exchanges CR for LF\n")  ;
    printf("\t               -EL   exchanges LF for CR\n")  ;
    printf("\t               -ESn  exchanges SPACEs for TABs (DeTAB)\n")  ;
    printf("\t                       n = 2 to 8, default = 8 (character boundary)\n")  ;
    printf("\t               -ETn  exchanges TABs for SPACEs (EnTAB)\n")  ;
    printf("\t                       n = 2 to 8, default = 8 (character boundary)\n")  ;
    printf("\t               -RC   removes all CR's\n")  ;
    printf("\t               -RL   removes all LF's\n")  ;
    printf("\t               -RN   removes all NULL's\n")  ;
    printf("\t               -M    mask off 8th bit of all characters\n")  ;
    printf("\n\t<filename>.CNG = file with changes.\n")  ;
    exit(0)  ;
    }  /* end of syntax */