[Python-checkins] r81036 - python/trunk/Objects/longobject.c (original) (raw)

Sun May 9 22:30:29 CEST 2010

       "cannot convert float infinity to integer");
                   "cannot convert float infinity to integer");
   return NULL;
       "cannot convert float NaN to integer");
                   "cannot convert float NaN to integer");
   return NULL;
           "can't convert negative value to unsigned long");
                           "can't convert negative value "
                           "to unsigned long");
           return (unsigned long) -1;
       }
       return val;
              "can't convert negative value to unsigned long");
                   "can't convert negative value to unsigned long");
   return (unsigned long) -1;
           "long int too large to convert");
                       "long int too large to convert");
       return (unsigned long) -1;
   }
           v->ob_digit[idigit] = (digit)(accum &
                                         PyLong_MASK);
           v->ob_digit[idigit] = (digit)(accum & PyLong_MASK);
           ++idigit;
           accum >>= PyLong_SHIFT;
           accumbits -= PyLong_SHIFT;
           "can't convert negative long to unsigned");
                       "can't convert negative long to unsigned");
       return -1;
   }
   do_twos_comp = 1;
       digit s = do_twos_comp ? thisdigit ^ PyLong_MASK :
                   thisdigit;
       digit s = do_twos_comp ? thisdigit ^ PyLong_MASK : thisdigit;
       while (s != 0) {
           s >>= 1;
           accumbits++;
 return 0;
               (unsigned char *)&bytes,
               SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1);
                            SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1);
               (unsigned char *)&bytes,
               SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0);
                            SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0);
               (PyLongObject *)vv, (unsigned char *)&bytes,
               SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);
                         SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);
               (PyLongObject *)vv, (unsigned char *)&bytes,
               SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);
                         SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);
       Py_DECREF(scratch);
       return NULL;
   })
           Py_DECREF(scratch);
           return NULL;
       })
       } while (i < size_a-1 ? accumbits >= basebits :
                   accum > 0);
       } while (i < size_a-1 ? accumbits >= basebits : accum > 0);
   }
                                    pin, size, powbase);
                                   pin, size, powbase);
       pin = scratch->ob_digit; /* no need to use a again */
       if (pin[size - 1] == 0)
           --size;
       SIGCHECK({
           Py_DECREF(scratch);
           Py_DECREF(str);
           return NULL;
       })
               Py_DECREF(scratch);
               Py_DECREF(str);
               return NULL;
           })

       /* Break rem into digits. */
       assert(ntostore > 0);
                      base**i <= PyLong_BASE
 >>> log(10)/log(2**15)*76573
 16958.000000654003
       log_base_PyLong_BASE[base] = log((double)base) /
                               log((double)PyLong_BASE);
       log_base_PyLong_BASE[base] = (log((double)base) /
                                     log((double)PyLong_BASE));
       for (;;) {
           twodigits next = convmax * base;
           if (next > PyLong_BASE)
               _PyLong_DigitValue[Py_CHARMASK(*str)]);
                           _PyLong_DigitValue[Py_CHARMASK(*str)]);
           assert(c < PyLong_BASE);
       }
       Py_DECREF(a);
       Py_DECREF(w);
       Py_DECREF(v);
       *prem = NULL;
       return NULL;
   })
           Py_DECREF(a);
           Py_DECREF(w);
           Py_DECREF(v);
           *prem = NULL;
           return NULL;
       })

   /* estimate quotient digit q; may overestimate by 1 (rare) */
   vtop = vk[size_w];
                                       z, PyLong_SHIFT);
                                               z, PyLong_SHIFT);
   }

   /* add w back if q was too large (this branch taken rarely) */
    goto overflow;
   goto overflow;
      x_size <= (Py_ssize_t)(sizeof(x_digits)/sizeof(digit)));
     size_a = size_b;
     size_b = size_temp; }
       size_a = size_b;
       size_b = size_temp; }
     size_a = size_b;
     size_b = size_temp; }
       size_a = size_b;
       size_b = size_temp; }
         SIGCHECK({
           Py_DECREF(z);
           return NULL;
       })
               Py_DECREF(z);
               return NULL;
           })

       carry = *pz + f * f;
       *pz++ = (digit)(carry & PyLong_MASK);
         SIGCHECK({
           Py_DECREF(z);
           return NULL;
       })
               Py_DECREF(z);
               return NULL;
           })

       while (pb < pbend) {
           carry += *pz + *pb++ * f;
      Py_ssize_t size,
      PyLongObject **high,
      PyLongObject **low)
 return long_normalize(ret);
                   "intermediate overflow during division");
                       "intermediate overflow during division");
       goto error;
   }
   x = _PyLong_New(a_size + shift_digits + 1);
           "cannot be negative when 3rd argument specified");
                       "cannot be negative when 3rd argument specified");
       goto Error;
   }
   else {
           z->ob_digit[i] |=
             (a->ob_digit[j+1] << hishift) & himask;
           z->ob_digit[i] |= (a->ob_digit[j+1] << hishift) & himask;
   }
   z = long_normalize(z);
    PyLongObject *b)
        PyLongObject *b)
                   PyErr_Clear();
                   if (PyLong_CheckExact(v)) {
                           Py_INCREF(v);
                           return v;
                   }
                   else
                           return _PyLong_Copy((PyLongObject *)v);
       PyErr_Clear();
       if (PyLong_CheckExact(v)) {
           Py_INCREF(v);
           return v;
       }
       else
           return _PyLong_Copy((PyLongObject *)v);
   }
   else
       return NULL;
            "invalid literal for long() with base %d: %s",
            base, PyString_AS_STRING(srepr));
                    "invalid literal for long() with base %d: %s",
                    base, PyString_AS_STRING(srepr));
       Py_DECREF(srepr);
       return NULL;
   }
       "long() can't convert non-string with explicit base");
                   "long() can't convert non-string with explicit base");
   return NULL;
       long_classic_div, /*nb_divide*/
       long_mod,                   /*nb_remainder*/
       long_divmod,                /*nb_divmod*/
       long_pow,                   /*nb_power*/
       long_lshift,                /*nb_lshift*/
       long_and,                   /*nb_and*/
       long_xor,                   /*nb_xor*/
       long_or,                    /*nb_or*/
       long_coerce,                /*nb_coerce*/
       long_int,                   /*nb_int*/
       long_long,                  /*nb_long*/
       long_float,                 /*nb_float*/
       long_oct,                   /*nb_oct*/
       long_hex,                   /*nb_hex*/
   Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS,         /* tp_flags */
   Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */
                "represent a digit"},

[Python-checkins] r81036 - python/trunk/Objects/longobject.c (original) (raw)

Modified: python/trunk/Objects/longobject.c

--- python/trunk/Objects/longobject.c (original) +++ python/trunk/Objects/longobject.c Sun May 9 22:30:29 2010 @@ -1,5 +1,3 @@