/* FINDFP.C
 * 
 * Portions Copyright (c) 1990-2008 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 */

/* No user fns here.  Pesch 15apr92. */

/*
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include <stdio_r.h>
#include <stdlib_r.h>
#include <errno.h>
#include <string.h>
#include "LOCAL.H"

/* Initialise a FILE structure to a starting state */
#ifdef __GCCXML__
static void
_std (FILE *ptr, int flags, int file, struct _reent *data)
#else
static void
std (FILE *ptr, int flags, int file, struct _reent *data)
#endif
{
  ptr->_p = 0;
  ptr->_r = 0;
  ptr->_w = 0;
  ptr->_flags = (short)flags;
  ptr->_file = (short)file;
  ptr->_bf._base = 0;
  ptr->_lbfsize = 0;
  ptr->_cookie = ptr;
  ptr->_read = __sread;
  ptr->_write = __swrite;
  ptr->_seek = __sseek;
  ptr->_close = __sclose;
  ptr->_data = data;
}

struct _glue *
__sfmoreglue (struct _reent *d, register int n)
{
  struct _glue *g;
  FILE *p;

  g = (struct _glue *) _malloc_r (d, sizeof (*g) + n * sizeof (FILE));
  if (g == NULL)
    return NULL;
  p = (FILE *) (g + 1);
  g->_next = NULL;
  g->_niobs = n;
  g->_iobs = p;
  memset (p, 0, n * sizeof (FILE));
  return g;
}

/*
 * Find a free FILE for fopen et al.
 */

FILE *
__sfp (struct _reent *d)
{
  FILE *fp;
  int n;
  struct _glue *g;

  if (!d->__sdidinit)
    __sinit (d);
  for (g = &d->__sglue;; g = g->_next)
    {
      for (fp = g->_iobs, n = g->_niobs; --n >= 0; fp++)
	if (fp->_flags == 0)
	  goto found;
      if (g->_next == NULL &&
	  (g->_next = __sfmoreglue (d, NDYNAMIC)) == NULL)
	break;
    }
  d->_errno = ENOMEM;
  return NULL;

found:
  fp->_flags = 1;		/* reserve this slot; caller sets real flags */
  fp->_p = NULL;		/* no current pointer */
  fp->_w = 0;			/* nothing to read or write */
  fp->_r = 0;
  fp->_bf._base = NULL;		/* no buffer */
  fp->_bf._size = 0;
  fp->_lbfsize = 0;		/* not line buffered */
  fp->_file = -1;		/* no file */
  /* fp->_cookie = <any>; */	/* caller sets cookie, _read/_write etc */
  fp->_ub._base = NULL;		/* no ungetc buffer */
  fp->_ub._size = 0;
  fp->_lb._base = NULL;		/* no line buffer */
  fp->_lb._size = 0;
  fp->_data = d;
  return fp;
}

/*
 * exit() calls _cleanup() through *__cleanup, set whenever we
 * open or buffer a file.  This chicanery is done so that programs
 * that do not use stdio need not link it all in.
 *
 * The name `_cleanup' is, alas, fairly well known outside stdio.
 */
/**
A reentrant version of _cleanup().
*/
EXPORT_C void
_cleanup_r (struct _reent *ptr)
{
  (void) _fwalk(ptr, fclose);
}

#ifndef _REENT_ONLY

/**
Performs cleanup
*/
EXPORT_C void
_cleanup (void)
{
  _cleanup_r (_REENT);
}
#endif

/*
 * __sinit() is called whenever stdio's internal variables must be set up.
 */

void
__sinit (struct _reent *s)
{
  /* make sure we clean up on exit */
  s->__cleanup = _cleanup_r;	/* conservative */
  s->__sdidinit = 1;

#ifdef __GCCXML__
  _std (_stdin_r(s),  __SRD, 0, s);
  _std (_stdout_r(s), __SWR, 1, s);
  _std (_stderr_r(s), __SWR | __SNBF, 2, s);
#else
  std (_stdin_r(s),  __SRD, 0, s);
  std (_stdout_r(s), __SWR, 1, s);
  std (_stderr_r(s), __SWR | __SNBF, 2, s);
#endif

  /* initialise the head of the glue chain to cover stdim/stdout/stderr */
  s->__sglue._next = NULL;
  s->__sglue._niobs = 3;
  s->__sglue._iobs = &s->_sf[0];
}

/* Function interface to stdin/stdout/stderr 
 *
 * These functions should return a value which is fixed for any given
 * reentrancy context, but it doesn't have to be fixed at compile time,
 * and we don't need to have initialised stdio either.
 */

/**
Function interface to the "constants" stdin.
These functions guarantee to return a fixed value, so that it 
will be possible to use expressions such as if (fp != stdout) fclose(fp);
with complete confidence. Unfortunately it will rule out initialising global
variables with stdin/stdout/stderr, as in the common idiom:

static FILE *log = stderr;

This isn't currently possible with EPOC32. 
*/
EXPORT_C FILE *__stdin (void)
{
	return _stdin_r(_REENT);
}

/**
Function interface to the "constants" stdout
See __stdin
*/
EXPORT_C FILE *__stdout (void)
{
	return _stdout_r(_REENT);
}

/**
Function interface to the "constants" stderr
See __stdin
*/
EXPORT_C FILE *__stderr (void)
{
	return _stderr_r(_REENT);
}