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)