/*

Copyright (C) 2003, 2005, 2006, 2007 John W. Eaton

This file is part of Octave.

Octave is free software; you can redistribute it and/or modify it

under the terms of the GNU General Public License as published by the

Free Software Foundation; either version 3 of the License, or (at your

option) any later version.

Octave is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with Octave; see the file COPYING.  If not, see

<http://www.gnu.org/licenses/>.

*/

#include "ls-ascii-helper.h"

#include <iostream>

#include <sstream>

// Helper functions when reading from ascii files.

// These function take care of CR/LF issues when files are opened in text-mode for reading 

// Skip characters from stream IS until a newline is reached.

// Depending on KEEP_NEWLINE, either eat newline from stream or

// keep it unread

void

skip_until_newline( std::istream& is, bool keep_newline )

{

  if (!is)

    return;

  char c,d;

  while (is)

  {

      c = is.peek();

      if (c == '\n' || c == '\r')

      {

	  // reached newline

	  if (keep_newline == false)

	  {

	      // eat the CR or LF character

	      is.get(d);

	      // make sure that for binary-mode opened ascii files containing CRLF line endings

	      // we skip the LF after CR...

	      if (c == '\r' && is.peek()=='\n')

	      {

		  // yes, LF following CR, eat it...

		  is.get(d);

	      }

	  }

	  // Newline was found, and read from stream if keep_newline==true, so exit loop

	  break;

      }

      else

	  // no newline charater peeked, so read it and proceed to next character

	  is.get(d);

  }

  return;

}

// If stream IS currently points to a newline (a leftover from a previous read)

// then eat newline(s) until a non-newline character is found

void

skip_preceeding_newline( std::istream& is )

{

  if (!is)

    return;

  char c,d;

  // Check if IS currently points to newline character

  c = is.peek();

  if (c == '\n' || c == '\r')

  {

      // Yes, at newline

      do {

	  // eat the CR or LF character

	  is.get(d);

	  // make sure that for binary-mode opened ascii files containing CRLF line endings

	  // we skip the LF after CR...

	  if (c == '\r' && is.peek() == '\n')

	  {

	      // yes, LF following CR, eat it...

	      is.get(d);

	  }

	  // Peek into next character

	  c = is.peek();

      // Loop while still a newline ahead

      } while( c == '\n' || c == '\r' );

  }

  return;

}

// Read charaters from stream IS until a newline is reached.

// Depending on KEEP_NEWLINE, either eat newline from stream or

// keep it unread

// Characters read are stored and returned as std::string

std::string

read_until_newline( std::istream& is, bool keep_newline )

{

  if (!is)

    return std::string();

  char c,d;

  std::ostringstream buf;

  while (is)

  {

      c = is.peek();

      if (c == '\n' || c == '\r')

      {

	  // reached newline

	  if (keep_newline == false)

	  {

	      // eat the CR or LF character

	      is.get(d);

	      // make sure that for binary-mode opened ascii files containing CRLF line endings

	      // we skip the LF after CR...

	      if (c == '\r' && is.peek() == '\n')

	      {

		  // yes, LF following CR, eat it...

		  is.get(d);

	      }

	  }

	  // Newline was found, and read from stream if keep_newline==true, so exit loop

	  break;

      }

      else

      {

	  // no newline charater peeked, so read it, store it, and proceed to next

	  is.get(d);

	  buf << d;

      }

  }

  return buf.str();

}