GFS_PIO_READDELIM(3)													      GFS_PIO_READDELIM(3)

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 '' 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  func-
       tion  treats  two  or  more  consecutive empty lines (/

+/ 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 vari-
       able 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 ' 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, "
", 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 = "
";

	    e = gfarm_initialize(&argc, &argv);
	    if (e != NULL) {
		 fprintf(stderr, "gfarm_initialize: %s
", 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
", c);
		      return (EXIT_FAILURE);
		 }
	    }
	    if (optind >= argc) {
		 fprintf(stderr, "missing gfarm filename
");
		 return (EXIT_FAILURE);
	    }
	    e = gfs_pio_open(argv[optind], GFARM_FILE_RDONLY, &gf);
	    if (e != NULL) {
		 fprintf(stderr, "%s: %s
", 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
",
		     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
", e);
		 return (EXIT_FAILURE);
	    }
	    e = gfs_pio_close(gf);
	    if (e != NULL) {
		 fprintf(stderr, "gfs_pio_close: %s
", e);
		 return (EXIT_FAILURE);
	    }
	    e = gfarm_terminate();
	    if (e != NULL) {
		 fprintf(stderr, "gfarm_initialize: %s
", 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)