/* glpsdf.c (plain data file reading routines) */

/***********************************************************************

*  This code is part of GLPK (GNU Linear Programming Kit).

*

*  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

*  2009, 2010 Andrew Makhorin, Department for Applied Informatics,

*  Moscow Aviation Institute, Moscow, Russia. All rights reserved.

*  E-mail: <mao@gnu.org>.

*

*  GLPK 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.

*

*  GLPK 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 GLPK. If not, see <http://www.gnu.org/licenses/>.

***********************************************************************/

#define GLPSDF_H

#define GLP_DATA_DEFINED

typedef struct glp_data glp_data;

#include "glpapi.h"

struct glp_data

{     /* plain data file */

      char *fname;

      /* name of data file */

      XFILE *fp;

      /* stream assigned to data file */

      void *jump; /* jmp_buf jump; */

      /* label for go to in case of error */

      int count;

      /* line count */

      int c;

      /* current character of XEOF */

      char item[255+1];

      /* current data item */

};

static void next_char(glp_data *data);

glp_data *glp_sdf_open_file(const char *fname)

{     /* open plain data file */

      glp_data *data = NULL;

      XFILE *fp;

      jmp_buf jump;

      fp = xfopen(fname, "r");

      if (fp == NULL)

      {  xprintf("Unable to open `%s' - %s\n", fname, xerrmsg());

         goto done;

      }

      data = xmalloc(sizeof(glp_data));

      data->fname = xmalloc(strlen(fname)+1);

      strcpy(data->fname, fname);

      data->fp = fp;

      data->jump = NULL;

      data->count = 0;

      data->c = '\n';

      data->item[0] = '\0';

      /* read the very first character */

      if (setjmp(jump))

      {  glp_sdf_close_file(data);

         data = NULL;

         goto done;

      }

      data->jump = jump;

      next_char(data);

      data->jump = NULL;

done: return data;

}

void glp_sdf_set_jump(glp_data *data, void *jump)

{     /* set up error handling */

      data->jump = jump;

      return;

}

void glp_sdf_error(glp_data *data, const char *fmt, ...)

{     /* print error message */

      va_list arg;

      xprintf("%s:%d: ", data->fname, data->count);

      va_start(arg, fmt);

      xvprintf(fmt, arg);

      va_end(arg);

      if (data->jump == NULL)

         xerror("");

      else

         longjmp(data->jump, 1);

      /* no return */

}

void glp_sdf_warning(glp_data *data, const char *fmt, ...)

{     /* print warning message */

      va_list arg;

      xprintf("%s:%d: warning: ", data->fname, data->count);

      va_start(arg, fmt);

      xvprintf(fmt, arg);

      va_end(arg);

      return;

}

static void next_char(glp_data *data)

{     /* read next character */

      int c;

      if (data->c == XEOF)

         glp_sdf_error(data, "unexpected end of file\n");

      else if (data->c == '\n')

         data->count++;

      c = xfgetc(data->fp);

      if (c < 0)

      {  if (xferror(data->fp))

            glp_sdf_error(data, "read error - %s\n", xerrmsg());

         else if (data->c == '\n')

            c = XEOF;

         else

         {  glp_sdf_warning(data, "missing final end of line\n");

            c = '\n';

         }

      }

      else if (c == '\n')

         ;

      else if (isspace(c))

         c = ' ';

      else if (iscntrl(c))

         glp_sdf_error(data, "invalid control character 0x%02X\n", c);

      data->c = c;

      return;

}

static void skip_pad(glp_data *data)

{     /* skip uninteresting characters and comments */

loop: while (data->c == ' ' || data->c == '\n')

         next_char(data);

      if (data->c == '/')

      {  next_char(data);

         if (data->c != '*')

            glp_sdf_error(data, "invalid use of slash\n");

         next_char(data);

         for (;;)

         {  if (data->c == '*')

            {  next_char(data);

               if (data->c == '/')

               {  next_char(data);

                  break;

               }

            }

            next_char(data);

         }

         goto loop;

      }

      return;

}

static void next_item(glp_data *data)

{     /* read next item */

      int len;

      skip_pad(data);

      len = 0;

      while (!(data->c == ' ' || data->c == '\n'))

      {  data->item[len++] = (char)data->c;

         if (len == sizeof(data->item))

            glp_sdf_error(data, "data item `%.31s...' too long\n",

               data->item);

         next_char(data);

      }

      data->item[len] = '\0';

      return;

}

int glp_sdf_read_int(glp_data *data)

{     /* read integer number */

      int x;

      next_item(data);

      switch (str2int(data->item, &x))

      {  case 0:

            break;

         case 1:

            glp_sdf_error(data, "integer `%s' out of range\n",

               data->item);

         case 2:

            glp_sdf_error(data, "cannot convert `%s' to integer\n",

               data->item);

         default:

            xassert(data != data);

      }

      return x;

}

double glp_sdf_read_num(glp_data *data)

{     /* read floating-point number */

      double x;

      next_item(data);

      switch (str2num(data->item, &x))

      {  case 0:

            break;

         case 1:

            glp_sdf_error(data, "number `%s' out of range\n",

               data->item);

         case 2:

            glp_sdf_error(data, "cannot convert `%s' to number\n",

               data->item);

         default:

            xassert(data != data);

      }

      return x;

}

const char *glp_sdf_read_item(glp_data *data)

{     /* read data item */

      next_item(data);

      return data->item;

}

const char *glp_sdf_read_text(glp_data *data)

{     /* read text until end of line */

      int c, len = 0;

      for (;;)

      {  c = data->c;

         next_char(data);

         if (c == ' ')

         {  /* ignore initial spaces */

            if (len == 0) continue;

            /* and multiple ones */

            if (data->item[len-1] == ' ') continue;

         }

         else if (c == '\n')

         {  /* remove trailing space */

            if (len > 0 && data->item[len-1] == ' ') len--;

            /* and stop reading */

            break;

         }

         /* add current character to the buffer */

         data->item[len++] = (char)c;

         if (len == sizeof(data->item))

            glp_sdf_error(data, "line too long\n", data->item);

      }

      data->item[len] = '\0';

      return data->item;

}

int glp_sdf_line(glp_data *data)

{     /* determine current line number */

      return data->count;

}

void glp_sdf_close_file(glp_data *data)

{     /* close plain data file */

      xfclose(data->fp);

      xfree(data->fname);

      xfree(data);

      return;

}

/* eof */