NAME

       gfs_pio_readdelim - read one record

SYNOPSIS

       #include <gfarm/gfarm.h>

       char  *gfs_pio_readdelim  (GFS_File  f, char **bufp, size_t *sizep, size_t *lenp, char *delimiter, size_t
       delimlen);

DESCRIPTION

       gfs_pio_readdelim() works like gfs_pio_readline(), except a delimiter of  input  records  is  not  always
       newline,  and  can be specified.  This function reads one record from the file specified by the parameter
       gf, by using the parameter delimiter as the delimiter  of  the  input  records.   You  can  include  '\0'
       character  in  the   delimiter,  So,  you  have  to  specify the length of the delimiter by the parameter
       delimlen.  If parameter delimiter is NULL, this function reads entire file as one record.  Otherwise, and
       if the parameter delimlen is 0, this function treats two or more consecutive empty lines  (/\n\n+/  in  a
       regular  expression)  as the input delimiter. This feature is derived from INPUT_RECORD_SEPARATOR in perl
       language.

       Parameter  bufp  specifies  an  address  of  a  pointer   variable   initialzed   by   NULL   at   first.
       gfs_pio_readdelim()  allocates a buffer for I/O dynamically, and stores the address of the buffer to this
       variable pointed by bufp.  Parameter sizep specifies an address of a size_t variable  initialized  by  0.
       This size_t variable is used to record the size of the buffer.  Or, you can specify a buffer allocated by
       malloc(3)  in  the variable pointed by the parameter bufp.  In this case, you have to specify the size of
       the allocated buffer by the parameter sizep.  If the length of the record exceeds the size of the buffer,
       the buffer will be automatically realloc(3)ed, and the variable pointed by bufp and sizep will be updated
       respectively.  Note that you are responsible to free(3) this buffer.

       This function returns the length of the record to a variable pointed by the parameter lenp.  This  length
       includes the length of the record delimiter.

       This  function  doesn't  remove  the delimiter at the end of records.  Also, despite that you can use the
       value returned by the variable pointed by lenp, this function always appends \0' character at the end  of
       records.

       If the file reaches its end, the length of the result record becomes 0.

       gfs_pio_readdelim(f, bufp, sizep, lenp, "\n", 1) is equivalent to gfs_pio_readline() function.

RETURN VALUES

       NULL   The function terminated successfully.

       GFARM_ERR_NO_MEMORY
              Insufficient memory was available.

              Note that you need to free(3) the buffer pointed by the parameter bufp

       Others An error except the above occurred.  The reason is shown by its pointed strings.

EXAMPLES

   EXAMPLE OF GFS_PIO_READDELIM FUNCTION
       #include <stdio.h>
       #include <stdlib.h>
       #include <string.h>
       #include <gfarm/gfarm.h>

       int
       main(int argc, char **argv)
       {
            char *e;
            GFS_File gf;
            size_t bufsize = 0, delimlen = 1, len;
            char *buffer = NULL, *delim = "\n";

            e = gfarm_initialize(&argc, &argv);
            if (e != NULL) {
                 fprintf(stderr, "gfarm_initialize: %s\n", e);
                 return (EXIT_FAILURE);
            }
            while ((c = getopt(argc, argv, "d:D")) != -1) {
                 switch (c) {
                 case 'd':
                      delim = optarg;
                      delimlen = strlen(optarg);
                      break;
                 case 'D':
                      delim = NULL;
                      delimlen = 0;
                      break;
                 case '?':
                 default:
                      fprintf(stderr, "invalid option: %c\n", c);
                      return (EXIT_FAILURE);
                 }
            }
            if (optind >= argc) {
                 fprintf(stderr, "missing gfarm filename\n");
                 return (EXIT_FAILURE);
            }
            e = gfs_pio_open(argv[optind], GFARM_FILE_RDONLY, &gf);
            if (e != NULL) {
                 fprintf(stderr, "%s: %s\n", argv[optind], e);
                 return (EXIT_FAILURE);
            }
            e = gfs_pio_set_view_global(gf, 0);
            if (e != NULL) {
                 fprintf(stderr, "%s: gfs_pio_set_view_global: %s\n",
                     argv[optind], e);
                 return (EXIT_FAILURE);
            }

            while ((e = gfs_pio_readdelim(gf, &buffer, &bufsize, &len,
                delim, delimlen)) == NULL && len > 0) {
                 printf("<%6d/%6d >%s", len, bufsize, buffer);
            }
            if (buffer != NULL)
                 free(buffer);
            if (e != NULL) {
                 fprintf(stderr, "ERROR: %s\n", e);
                 return (EXIT_FAILURE);
            }
            e = gfs_pio_close(gf);
            if (e != NULL) {
                 fprintf(stderr, "gfs_pio_close: %s\n", e);
                 return (EXIT_FAILURE);
            }
            e = gfarm_terminate();
            if (e != NULL) {
                 fprintf(stderr, "gfarm_initialize: %s\n", e);
                 return (EXIT_FAILURE);
            }
            return (EXIT_SUCCESS);
       }

SEE ALSO

       gfs_pio_open(3), gfs_pio_getline(3), gfs_pio_gets(3), gfs_pio_readline(3)

Gfarm                                              13 May 2004                              GFS_PIO_READDELIM(3)