Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / bl / api / pfe / src / Pfe_HexDec.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: Pfe_HexDec.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/

#include "longintrepr.h"

PyObject* long_format( PyObject* aa, int base, int addL )/*{{{*/
{
#define ABS(x) ((x) < 0 ? -(x) : (x))

       register PyLongObject *a = (PyLongObject *)aa;
       PyStringObject *str;
       int i;
       const int size_a = ABS(a->ob_size);
       char *p;
       int bits;
       char sign = '\0';

       if (a == NULL || !PyLong_Check(a)) {
               PyErr_BadInternalCall();
               return NULL;
       }
       assert(base >= 2 && base <= 36);

       /* Compute a rough upper bound for the length of the string */
       i = base;
       bits = 0;
       while (i > 1) {
               ++bits;
               i >>= 1;
       }
       i = 5 + (addL ? 1 : 0) + (size_a*SHIFT + bits-1) / bits;
       str = (PyStringObject *) PyString_FromStringAndSize((char *)0, i);
       if (str == NULL)
               return NULL;
       p = PyString_AS_STRING(str) + i;
       *p = '\0';
       if (addL)
               *--p = 'L';
       if (a->ob_size < 0)
               sign = '-';

       if (a->ob_size == 0) {
               *--p = '0';
       }
       else if ((base & (base - 1)) == 0) {
               /* JRH: special case for power-of-2 bases */
               twodigits accum = 0;
               int accumbits = 0;      /* # of bits in accum */
               int basebits = 1;       /* # of bits in base-1 */
               i = base;
               while ((i >>= 1) > 1)
                       ++basebits;

               for (i = 0; i < size_a; ++i) {
                       accum |= (twodigits)a->ob_digit[i] << accumbits;
                       accumbits += SHIFT;
                       assert(accumbits >= basebits);
                       do {
                               char cdigit = (char)(accum & (base - 1));
                               cdigit += (cdigit < 10) ? '0' : 'a'-10;
                               assert(p > PyString_AS_STRING(str));
                               *--p = cdigit;
                               accumbits -= basebits;
                               accum >>= basebits;
                       } while (i < size_a-1 ? accumbits >= basebits :
                                               accum > 0);
               }
       }

       if (base == 8) {
               if (size_a != 0)
                       *--p = '0';
       }
       else if (base == 16) {
               *--p = 'x';
               *--p = '0';
       }
       else if (base != 10) {
               *--p = '#';
               *--p = '0' + base%10;
               if (base > 10)
                       *--p = '0' + base/10;
       }
       if (sign)
               *--p = sign;
       if (p != PyString_AS_STRING(str)) {
               char *q = PyString_AS_STRING(str);
               assert(p > q);
               do {
               } while ((*q++ = *p++) != '\0');
               q--;
               _PyString_Resize((PyObject **)&str,
                                (int) (q - PyString_AS_STRING(str)));
       }
       return (PyObject *)str;
}
/*}}}*/
PyObject* long_hex_repr( PyObject* v )/*{{{*/
{
 return long_format(v,16,1);
}
/*}}}*/
PyObject* long_hex_str( PyObject* v )/*{{{*/
{
 return long_format(v,16,0);
}
/*}}}*/

int_hex_print( PyIntObject* v, FILE* fp, int flags )/*{{{*/
{
 fprintf(fp,"0x%lx",v->ob_ival);
 return 0;
}
/*}}}*/
PyObject* int_hex_repr( PyIntObject* v )/*{{{*/
{
 char buf[64];
 PyOS_snprintf(buf, sizeof(buf), "0x%lx", v->ob_ival);
 return PyString_FromString(buf);
}
/*}}}*/

extern PyTypeObject PyInt_Type;
extern PyTypeObject PyLong_Type;

static printfunc int_dec_print = 0;
static reprfunc  long_dec_repr;
static reprfunc  long_dec_str;
static reprfunc  int_dec_repr;
static reprfunc  int_dec_str;

void hexmode()/*{{{*/
{
 if (int_dec_print == 0)
 {
   long_dec_repr = PyLong_Type.tp_repr;
   long_dec_str  = PyLong_Type.tp_str;
   int_dec_repr  = PyInt_Type.tp_repr;
   int_dec_str   = PyInt_Type.tp_str;
   int_dec_print = PyInt_Type.tp_print;
 }

 PyLong_Type.tp_repr = (reprfunc)long_hex_repr;
 PyLong_Type.tp_str  = (reprfunc)long_hex_str;
 PyInt_Type.tp_repr  = (reprfunc)int_hex_repr;
 PyInt_Type.tp_str   = (reprfunc)int_hex_repr;
 PyInt_Type.tp_print = (printfunc)int_hex_print;
}
/*}}}*/
void decmode()/*{{{*/
{
 PyLong_Type.tp_repr = (reprfunc)long_dec_repr;
 PyLong_Type.tp_str  = (reprfunc)long_dec_str;
 PyInt_Type.tp_repr  = (reprfunc)int_dec_repr;
 PyInt_Type.tp_str   = (reprfunc)int_dec_repr;
 PyInt_Type.tp_print = (printfunc)int_dec_print;
}
/*}}}*/