# include <cstdlib>
# include <iostream>
# include <iomanip>
# include <fstream>
# include <ctime>

using namespace std;

int main ( int argc, char *argv[] );
int handle ( char file_in_name[], char file_out_name[], 
  int wrap_length );
int s_len_trim ( char *s );
int s_to_i4 ( char *s, int *last, bool *error );
void timestamp ( void );

//****************************************************************************80

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

//****************************************************************************80
//
//  Purpose:
//
//    MAIN is the main program for WRAP.
//
//  Discussion:
//
//    WRAP wraps long lines in a file.
//
//    This program reads a file, and tries to insert a carriage return
//    after the current line is seen to contain at least 80 characters.
//
//  Usage:
//
//    wrap file1 file2 wrap_length
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license. 
//
//  Modified:
//
//    26 November 2003
//
//  Author:
//
//    John Burkardt
//
{
  bool error;
  char file_in_name[80];
  char file_out_name[80];
  int last;
  int result;
  char string[80];
  bool VERBOSE = false;
  int wrap_length = 80;

  if ( VERBOSE )
  {
    timestamp ( );
    cout << "\n";
    cout << "WRAP:\n";
    cout << "  C++ version\n";
    cout << "\n";
    cout << "  Insert new lines where necessary into a copy of the input\n";
    cout << "  file, so that the lines of the output file are no longer\n";
    cout << "  than a given number of characters.\n";
    cout << "\n";
    cout << "  Compiled on " << __DATE__ << " at " << __TIME__ << ".\n";
  }
//
//  If the input file was not on the command line, get it now.
//
  if ( argc < 2 ) 
  {
    cout << "\n";
    cout << "WRAP:\n";
    cout << "  Please enter the INPUT file name:\n";

    cin.getline ( file_in_name, sizeof ( file_in_name ) );
  }
  else 
  {
    strcpy ( file_in_name, argv[1] );
  }
//
//  If the output file was not on the command line, get it now.
//
  if ( argc < 3 ) 
  {
    cout << "\n";
    cout << "WRAP:\n";
    cout << "  Please enter the OUTPUT file name:\n";

    cin.getline ( file_out_name, sizeof ( file_out_name ) );
  }
  else 
  {
    strcpy ( file_out_name, argv[2] );
  }
//
//  If the wrapping length was not on the command line, get it now.
//
  if ( argc < 4 ) 
  {
    cout << "\n";
    cout << "WRAP:\n";
    cout << "  Please enter the wrapping length:\n";
    cin >> wrap_length;
  }
  else 
  {
    strcpy ( string, argv[3] );
    wrap_length = s_to_i4 ( string, &last, &error );
  }
//
//  Now we know the input and output file names, so go to it.
//
  result = handle ( file_in_name, file_out_name, wrap_length );

  if ( VERBOSE )
  {
    cout << "\n";
    cout << "WRAP:\n";
    cout << "  Normal end of execution.\n";
    cout << "\n";
    timestamp ( );
  }

  return result;
}
//****************************************************************************80

int handle ( char file_in_name[], char file_out_name[], 
  int wrap_length )

//****************************************************************************80
//
//  Purpose:
//
//    HANDLE makes a copy of a file in which no line exceeds a given length.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license. 
//
//  Modified:
//
//    18 January 2003
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    Input, char FILE_IN_NAME[], the name of the input file.
//
//    Input, char FILE_OUT_NAME[], the name of the output file.
//
//    Input, int WRAP_LENGTH, is the maximum line length.
//
//    Output, int HANDLE, is 0 for success, or 1 if there was an error.
//
{
  char c;
  int column;
  ifstream file_in;
  ofstream file_out;
  int in_char;
  int out_char;
  bool VERBOSE = false;
  int wrap_num;
//
//  Open the input and output files.
//
  file_in.open( file_in_name );

  if ( !file_in )
  {
    cout << "\n";
    cout << "WRAP - Fatal error!\n";
    cout << "  Cannot open the input file " << file_in_name << ".\n";
    return 1;
  }

  file_out.open ( file_out_name );

  if ( !file_out ) 
  {
    cout << "\n";
    cout << "WRAP - Fatal error!\n";
    cout << "  Cannot open the output file " << file_out_name << ".\n";
    return 1;
  }
//
//  Transfer characters from the input file to the output file.
//
  in_char = 0;
  out_char = 0;
  column = 0;
  wrap_num = 0;

  while ( 1 ) 
  {
    file_in.get ( c );
 
    if ( file_in.eof ( ) )
    {
      break;
    }

    in_char = in_char + 1;

    file_out.put ( c );
    out_char = out_char + 1;

    if ( c == '\n' ) 
    {
      column = 0;
    }
    else
    {
      column = column + 1;
    }

    if ( wrap_length <= column )
    {
      c = '\n';
      file_out.put ( c );
      out_char = out_char + 1;
      column = 0;
      wrap_num = wrap_num + 1;
    }
  }
//
//  Close the files.
//
  file_in.close ( );

  file_out.close ( );
//
//  Report.
//
  if ( VERBOSE )
  {
    cout << "\n";
    cout << "  The input file contains  " <<  in_char << " characters.\n";
    cout << "  The output file contains " << out_char << " characters.\n";
    cout << "  Number of new lines inserted was " << wrap_num << ".\n";
  }

  return 0;
}
//****************************************************************************80

int s_len_trim ( char *s )

//****************************************************************************80
//
//  Purpose:
//
//    S_LEN_TRIM returns the length of a string to the last nonblank.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license. 
//
//  Modified:
//
//    26 April 2003
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    Input, char *S, a pointer to a string.
//
//    Output, int S_LEN_TRIM, the length of the string to the last nonblank.
//    If S_LEN_TRIM is 0, then the string is entirely blank.
//
{
  int n;
  char *t;

  n = strlen ( s );
  t = s + strlen ( s ) - 1;

  while ( 0 < n ) 
  {
    if ( *t != ' ' )
    {
      return n;
    }
    t--;
    n--;
  }

  return n;
}
//****************************************************************************80

int s_to_i4 ( char *s, int *last, bool *error )

//****************************************************************************80
//
//  Purpose:
//
//    S_TO_I4 reads an I4 from a string.
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license. 
//
//  Modified:
//
//    13 June 2003
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    Input, char *S, a string to be examined.
//
//    Output, int *LAST, the last character of S used to make IVAL.
//
//    Output, bool *ERROR is TRUE if an error occurred.
//
//    Output, int *S_TO_I4, the integer value read from the string.
//    If the string is blank, then IVAL will be returned 0.
//
{
  char c;
  int i;
  int isgn;
  int istate;
  int ival;

  *error = false;
  istate = 0;
  isgn = 1;
  i = 0;
  ival = 0;

  while ( *s ) 
  {
    c = s[i];
    i = i + 1;
//
//  Haven't read anything.
//
    if ( istate == 0 )
    {
      if ( c == ' ' )
      {
      }
      else if ( c == '-' )
      {
        istate = 1;
        isgn = -1;
      }
      else if ( c == '+' )
      {
        istate = 1;
        isgn = + 1;
      }
      else if ( '0' <= c && c <= '9' )
      {
        istate = 2;
        ival = c - '0';
      }
      else
      {
        *error = true;
        return ival;
      }
    }
//
//  Have read the sign, expecting digits.
//
    else if ( istate == 1 )
    {
      if ( c == ' ' )
      {
      }
      else if ( '0' <= c && c <= '9' )
      {
        istate = 2;
        ival = c - '0';
      }
      else
      {
        *error = true;
        return ival;
      }
    }
//
//  Have read at least one digit, expecting more.
//
    else if ( istate == 2 )
    {
      if ( '0' <= c && c <= '9' )
      {
        ival = 10 * (ival) + c - '0';
      }
      else
      {
        ival = isgn * ival;
        *last = i - 1;
        return ival;
      }

    }
  }
//
//  If we read all the characters in the string, see if we're OK.
//
  if ( istate == 2 )
  {
    ival = isgn * ival;
    *last = s_len_trim ( s );
  }
  else
  {
    *error = true;
    *last = 0;
  }

  return ival;
}
//****************************************************************************80 

void timestamp ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TIMESTAMP prints the current YMDHMS date as a time stamp.
//
//  Example:
//
//    May 31 2001 09:45:54 AM
//
//  Licensing:
//
//    This code is distributed under the GNU LGPL license. 
//
//  Modified:
//
//    04 October 2003
//
//  Author:
//
//    John Burkardt
//
//  Parameters:
//
//    None
//
{
# define TIME_SIZE 40

  static char time_buffer[TIME_SIZE];
  const struct tm *tm;
  size_t len;
  time_t now;

  now = time ( NULL );
  tm = localtime ( &now );

  len = strftime ( time_buffer, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );

  cout << time_buffer << "\n";

  return;
# undef TIME_SIZE
}