Man Linux: Main Page and Category List


       gfs_pio_readdelim - read one record


       #include <gfarm/gfarm.h>

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


       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

       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.


       NULL   The function terminated successfully.

              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.


       #include <stdio.h>
       #include <stdlib.h>
       #include <string.h>
       #include <gfarm/gfarm.h>

       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);
                 case ’D’:
                      delim = NULL;
                      delimlen = 0;
                 case ’?’:
                      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)
            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);


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