Subversion Repositories openrisc_me

/* Machine-independent I/O routines for gcov.
 
   Copyright (c) 2000  Red Hat, Inc. All rights reserved.
 
   This copyrighted material is made available to anyone wishing to use, modify,
   copy, or redistribute it subject to the terms and conditions of the BSD 
   License.   This program is distributed in the hope that it will be useful, 
   but WITHOUT ANY WARRANTY expressed or implied, including the implied 
   warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  A copy of
   this license is available at http://www.opensource.org/licenses. Any Red Hat
   trademarks that are incorporated in the source code or documentation are not
   subject to the BSD License and may only be used or replicated with the 
   express permission of Red Hat, Inc.
*/
 
 
#ifndef GCC_GCOV_IO_H
#define GCC_GCOV_IO_H
#include <stdio.h>
#include <sys/types.h>
 
static int __fetch_long	(long *, char *, size_t);
static int __store_long (long, char *, size_t);
static int __read_long  (long *, FILE *, size_t);
static int __write_long (long, FILE *, size_t);
 
/* These routines only work for signed values. */
 
/* Store a portable representation of VALUE in DEST using BYTES*8-1 bits.
   Return a non-zero value if VALUE requires more than BYTES*8-1 bits
   to store. */
 
static int
__store_long (value, dest, bytes)
     long value;
     char *dest;
     size_t bytes;
{
  int upper_bit = (value < 0 ? 128 : 0);
  size_t i;
 
  if (value < 0)
    {
      long oldvalue = value;
      value = -value;
      if (oldvalue != -value)
	return 1;
    }
 
  for(i = 0 ; i < (sizeof (value) < bytes ? sizeof (value) : bytes) ; i++) {
    dest[i] = value & (i == (bytes - 1) ? 127 : 255);
    value = value / 256;
  }
 
  if (value && value != -1)
    return 1;
 
  for(; i < bytes ; i++) 
    dest[i] = 0;
  dest[bytes - 1] |= upper_bit;
  return 0;
}
 
/* Retrieve a quantity containing BYTES*8-1 bits from SOURCE and store
   the result in DEST. Returns a non-zero value if the value in SOURCE
   will not fit in DEST. */
 
static int
__fetch_long (dest, source, bytes)
     long *dest;
     char *source;
     size_t bytes;
{
  long value = 0;
  int i;
 
  for (i = bytes - 1; (size_t) i > (sizeof (*dest) - 1); i--)
    if (source[i] & ((size_t) i == (bytes - 1) ? 127 : 255 ))
      return 1;
 
  for (; i >= 0; i--)
    value = value * 256 + (source[i] & ((size_t)i == (bytes - 1) ? 127 : 255));
 
  if ((source[bytes - 1] & 128) && (value > 0))
    value = - value;
 
  *dest = value;
  return 0;
}
 
/* Write a BYTES*8-bit quantity to FILE, portably. Returns a non-zero
   value if the write fails, or if VALUE can't be stored in BYTES*8
   bits.
 
   Note that VALUE may not actually be large enough to hold BYTES*8
   bits, but BYTES characters will be written anyway.
 
   BYTES may be a maximum of 10. */
 
static int
__write_long (value, file, bytes)
     long value;
     FILE *file;
     size_t bytes;
{
  char c[10];
 
  if (bytes > 10 || __store_long (value, c, bytes))
    return 1;
  else
    return fwrite(c, 1, bytes, file) != bytes;
}
 
/* Read a quantity containing BYTES bytes from FILE, portably. Return
   a non-zero value if the read fails or if the value will not fit
   in DEST.
 
   Note that DEST may not be large enough to hold all of the requested
   data, but the function will read BYTES characters anyway.
 
   BYTES may be a maximum of 10. */
 
static int
__read_long (dest, file, bytes)
     long *dest;
     FILE *file;
     size_t bytes;
{
  char c[10];
 
  if (bytes > 10 || fread(c, 1, bytes, file) != bytes)
    return 1;
  else
    return __fetch_long (dest, c, bytes);
}
 
#endif /* ! GCC_GCOV_IO_H */