Return to flonum-copy.c CVS log

Up to [Apple XNU] / GNUtools / cctools / as

Annotation of GNUtools/cctools/as/flonum-copy.c, revision 1.1

1.1     ! root        1: /* flonum_copy.c - copy a flonum
        !             2:    Copyright (C) 1987 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GAS, the GNU Assembler.
        !             5: 
        !             6: GAS is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 1, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GAS is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GAS; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: #include <string.h>
        !            21: #include "flonum.h"
        !            22: 
        !            23: void
        !            24: flonum_copy(
        !            25: FLONUM_TYPE *in,
        !            26: FLONUM_TYPE *out)
        !            27: {
        !            28:   int                  in_length;      /* 0 origin */
        !            29:   int                  out_length;     /* 0 origin */
        !            30: 
        !            31:   out -> sign = in -> sign;
        !            32:   in_length = in  -> leader - in -> low;
        !            33:   if (in_length < 0)
        !            34:     {
        !            35:       out -> leader = out -> low - 1; /* 0.0 case */
        !            36:     }
        !            37:   else
        !            38:     {
        !            39:       out_length = out -> high - out -> low;
        !            40:       /*
        !            41:        * Assume no GAPS in packing of littlenums.
        !            42:        * I.e. sizeof(array) == sizeof(element) * number_of_elements.
        !            43:        */
        !            44:       if (in_length <= out_length)
        !            45:        {
        !            46:          {
        !            47:            /*
        !            48:             * For defensive programming, zero any high-order littlenums we don't need.
        !            49:             * This is destroying evidence and wasting time, so why bother???
        !            50:             */
        !            51:            if (in_length < out_length)
        !            52:              {
        !            53:                memset((char *)(out->low + in_length + 1), '\0',
        !            54:                       out_length - in_length);
        !            55:              }
        !            56:          }
        !            57:          memcpy((char *)(out->low), (char *)(in->low),
        !            58:                 (int)((in_length + 1) * sizeof(LITTLENUM_TYPE)));
        !            59:          out -> exponent = in -> exponent;
        !            60:          out -> leader   = in -> leader - in -> low + out -> low;
        !            61:        }
        !            62:       else
        !            63:        {
        !            64:          int   shorten;                /* 1-origin. Number of littlenums we drop. */
        !            65: 
        !            66:          shorten = in_length - out_length;
        !            67:          /* Assume out_length >= 0 ! */
        !            68:          memcpy((char *)(out->low), (char *)(in->low + shorten),
        !            69:                 (int)((out_length + 1) * sizeof(LITTLENUM_TYPE)));
        !            70:          out -> leader = out -> high;
        !            71:          out -> exponent = in -> exponent + shorten;
        !            72:        }
        !            73:     }                          /* if any significant bits */
        !            74: }
        !            75: 
        !            76: /* end: flonum_copy.c */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.