1998-07-08 15:57:05 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* int8.c
|
1998-07-08 15:57:05 +02:00
|
|
|
* Internal 64-bit integer operations
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <float.h>
|
|
|
|
|
|
|
|
#include "postgres.h"
|
1999-08-21 05:06:58 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_LIMITS_H
|
|
|
|
#include <limits.h>
|
|
|
|
#endif
|
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
#include "utils/int8.h"
|
|
|
|
|
|
|
|
#define MAXINT8LEN 25
|
|
|
|
|
1999-08-21 05:06:58 +02:00
|
|
|
#ifndef INT_MAX
|
|
|
|
#define INT_MAX (0x7FFFFFFFL)
|
|
|
|
#endif
|
|
|
|
#ifndef INT_MIN
|
|
|
|
#define INT_MIN (-INT_MAX-1)
|
|
|
|
#endif
|
|
|
|
#ifndef SHRT_MAX
|
|
|
|
#define SHRT_MAX (0x7FFF)
|
|
|
|
#endif
|
|
|
|
#ifndef SHRT_MIN
|
|
|
|
#define SHRT_MIN (-SHRT_MAX-1)
|
|
|
|
#endif
|
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
**
|
|
|
|
** Routines for 64-bit integers.
|
|
|
|
**
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
|
|
* Formatting and conversion routines.
|
|
|
|
*---------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* int8in()
|
|
|
|
*/
|
|
|
|
int64 *
|
|
|
|
int8in(char *str)
|
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
1999-02-03 01:18:53 +01:00
|
|
|
char *ptr = str;
|
|
|
|
int64 tmp = 0;
|
|
|
|
int sign = 1;
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
if (!PointerIsValid(str))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Bad (null) int8 external representation");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
/*
|
|
|
|
* Do our own scan, rather than relying on sscanf which might be
|
1999-02-03 01:18:53 +01:00
|
|
|
* broken for long long. NOTE: this will not detect int64 overflow...
|
|
|
|
* but sscanf doesn't either...
|
|
|
|
*/
|
1999-05-25 18:15:34 +02:00
|
|
|
while (*ptr && isspace(*ptr)) /* skip leading spaces */
|
1999-02-03 01:18:53 +01:00
|
|
|
ptr++;
|
1999-05-25 18:15:34 +02:00
|
|
|
if (*ptr == '-') /* handle sign */
|
1999-02-03 01:18:53 +01:00
|
|
|
sign = -1, ptr++;
|
|
|
|
else if (*ptr == '+')
|
|
|
|
ptr++;
|
1999-05-25 18:15:34 +02:00
|
|
|
if (!isdigit(*ptr)) /* require at least one digit */
|
1999-02-03 01:18:53 +01:00
|
|
|
elog(ERROR, "Bad int8 external representation '%s'", str);
|
1999-05-25 18:15:34 +02:00
|
|
|
while (*ptr && isdigit(*ptr)) /* process digits */
|
1999-02-03 01:18:53 +01:00
|
|
|
tmp = tmp * 10 + (*ptr++ - '0');
|
1999-05-25 18:15:34 +02:00
|
|
|
if (*ptr) /* trailing junk? */
|
1998-07-08 15:57:05 +02:00
|
|
|
elog(ERROR, "Bad int8 external representation '%s'", str);
|
|
|
|
|
1999-02-03 01:18:53 +01:00
|
|
|
*result = (sign < 0) ? -tmp : tmp;
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8in() */
|
|
|
|
|
|
|
|
|
|
|
|
/* int8out()
|
|
|
|
*/
|
|
|
|
char *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8out(int64 *val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
int len;
|
|
|
|
char buf[MAXINT8LEN + 1];
|
|
|
|
|
|
|
|
if (!PointerIsValid(val))
|
1998-09-01 05:29:17 +02:00
|
|
|
return NULL;
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
if ((len = snprintf(buf, MAXINT8LEN, INT64_FORMAT, *val)) < 0)
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Unable to format int8");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
result = palloc(len + 1);
|
|
|
|
|
|
|
|
strcpy(result, buf);
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8out() */
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
|
|
* Relational operators for int8s.
|
|
|
|
*---------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* int8relop()
|
|
|
|
* Is val1 relop val2?
|
|
|
|
*/
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8eq(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 == *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8eq() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8ne(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 != *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8ne() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8lt(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 < *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8lt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8gt(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 > *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8gt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8le(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 <= *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8le() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int8ge(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1 || !val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 >= *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8ge() */
|
|
|
|
|
|
|
|
|
|
|
|
/* int84relop()
|
|
|
|
* Is 64-bit val1 relop 32-bit val2?
|
|
|
|
*/
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84eq(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 == val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84eq() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84ne(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 != val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84ne() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84lt(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 < val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84lt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84gt(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 > val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84gt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84le(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 <= val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84le() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int84ge(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val1)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return *val1 >= val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84ge() */
|
|
|
|
|
|
|
|
|
|
|
|
/* int48relop()
|
|
|
|
* Is 32-bit val1 relop 64-bit val2?
|
|
|
|
*/
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48eq(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 == *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48eq() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48ne(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 != *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48ne() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48lt(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 < *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48lt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48gt(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 > *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48gt() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48le(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 <= *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48le() */
|
|
|
|
|
|
|
|
bool
|
1999-05-26 00:43:53 +02:00
|
|
|
int48ge(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!val2)
|
|
|
|
return 0;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return val1 >= *val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48ge() */
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
|
|
* Arithmetic operators on 64-bit integers.
|
|
|
|
*---------------------------------------------------------*/
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8um(int64 *val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
1998-09-01 06:40:42 +02:00
|
|
|
int64 temp = 0;
|
1998-07-08 15:57:05 +02:00
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val))
|
|
|
|
return NULL;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
result = int8mi(&temp, val);
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8um() */
|
|
|
|
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8pl(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 + *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8pl() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8mi(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 - *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8mi() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8mul(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 * *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8mul() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8div(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 / *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8div() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8larger(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
*result = ((*val1 > *val2) ? *val1 : *val2);
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8larger() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8smaller(int64 *val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
1998-09-01 06:40:42 +02:00
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
|
|
|
|
return NULL;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
*result = ((*val1 < *val2) ? *val1 : *val2);
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int8smaller() */
|
|
|
|
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int84pl(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val1))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 + (int64) val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84pl() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int84mi(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val1))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 - (int64) val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84mi() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int84mul(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val1))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 * (int64) val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84mul() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int84div(int64 *val1, int32 val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val1))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = *val1 / (int64) val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84div() */
|
|
|
|
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int48pl(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val2))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = (int64) val1 + *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48pl() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int48mi(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val2))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = (int64) val1 - *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48mi() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int48mul(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val2))
|
|
|
|
return NULL;
|
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
*result = (int64) val1 **val2;
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48mul() */
|
|
|
|
|
|
|
|
int64 *
|
1999-05-26 00:43:53 +02:00
|
|
|
int48div(int32 val1, int64 *val2)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
if (!PointerIsValid(val2))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*result = (int64) val1 / *val2;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48div() */
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
|
|
* Conversion operators.
|
|
|
|
*---------------------------------------------------------*/
|
|
|
|
|
|
|
|
int64 *
|
|
|
|
int48(int32 val)
|
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
*result = val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int48() */
|
|
|
|
|
|
|
|
int32
|
1999-05-26 00:43:53 +02:00
|
|
|
int84(int64 *val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int32 result;
|
|
|
|
|
|
|
|
if (!PointerIsValid(val))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Invalid (null) int64, can't convert int8 to int4");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
if ((*val < INT_MIN) || (*val > INT_MAX))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "int8 conversion to int4 is out of range");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
result = *val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int84() */
|
|
|
|
|
1999-02-13 05:22:34 +01:00
|
|
|
#if NOT_USED
|
1998-07-08 15:57:05 +02:00
|
|
|
int64 *
|
2000-01-10 17:13:23 +01:00
|
|
|
int2vector (int16 val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int64 *result;
|
|
|
|
|
|
|
|
result = palloc(sizeof(int64));
|
|
|
|
|
|
|
|
*result = val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
2000-01-10 17:13:23 +01:00
|
|
|
} /* int2vector() */
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
int16
|
1999-05-26 00:43:53 +02:00
|
|
|
int82(int64 *val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
int16 result;
|
|
|
|
|
|
|
|
if (!PointerIsValid(val))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Invalid (null) int8, can't convert to int2");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
1999-08-21 05:06:58 +02:00
|
|
|
if ((*val < SHRT_MIN) || (*val > SHRT_MAX))
|
|
|
|
elog(ERROR, "int8 conversion to int2 is out of range");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
result = *val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* int82() */
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
float64
|
1999-05-26 00:43:53 +02:00
|
|
|
i8tod(int64 *val)
|
1998-07-08 15:57:05 +02:00
|
|
|
{
|
|
|
|
float64 result = palloc(sizeof(float64data));
|
|
|
|
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!PointerIsValid(val))
|
|
|
|
elog(ERROR, "Invalid (null) int8, can't convert to float8");
|
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
*result = *val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* i8tod() */
|
|
|
|
|
|
|
|
/* dtoi8()
|
|
|
|
* Convert double float to 8-byte integer.
|
|
|
|
* Do a range check before the conversion.
|
|
|
|
* Note that the comparison probably isn't quite right
|
1998-09-01 06:40:42 +02:00
|
|
|
* since we only have ~52 bits of precision in a double float
|
|
|
|
* and so subtracting one from a large number gives the large
|
|
|
|
* number exactly. However, for some reason the comparison below
|
|
|
|
* does the right thing on my i686/linux-rh4.2 box.
|
1998-07-08 15:57:05 +02:00
|
|
|
* - thomas 1998-06-16
|
|
|
|
*/
|
|
|
|
int64 *
|
|
|
|
dtoi8(float64 val)
|
|
|
|
{
|
|
|
|
int64 *result = palloc(sizeof(int64));
|
|
|
|
|
1999-08-21 05:06:58 +02:00
|
|
|
if (!PointerIsValid(val))
|
|
|
|
elog(ERROR, "Invalid (null) float8, can't convert to int8");
|
|
|
|
|
1998-07-08 15:57:05 +02:00
|
|
|
if ((*val < (-pow(2, 63) + 1)) || (*val > (pow(2, 63) - 1)))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Floating point conversion to int64 is out of range");
|
1998-07-08 15:57:05 +02:00
|
|
|
|
|
|
|
*result = *val;
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1998-07-08 15:57:05 +02:00
|
|
|
} /* dtoi8() */
|
1999-02-13 05:22:34 +01:00
|
|
|
|
|
|
|
/* text_int8()
|
|
|
|
*/
|
|
|
|
int64 *
|
|
|
|
text_int8(text *str)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
if (!PointerIsValid(str))
|
1999-08-21 05:06:58 +02:00
|
|
|
elog(ERROR, "Bad (null) int8 external representation");
|
1999-02-13 05:22:34 +01:00
|
|
|
|
|
|
|
len = (VARSIZE(str) - VARHDRSZ);
|
1999-05-25 18:15:34 +02:00
|
|
|
s = palloc(len + 1);
|
1999-02-13 05:22:34 +01:00
|
|
|
memmove(s, VARDATA(str), len);
|
1999-05-25 18:15:34 +02:00
|
|
|
*(s + len) = '\0';
|
1999-02-13 05:22:34 +01:00
|
|
|
|
|
|
|
return int8in(s);
|
|
|
|
} /* text_int8() */
|
|
|
|
|
|
|
|
|
|
|
|
/* int8_text()
|
|
|
|
*/
|
|
|
|
text *
|
1999-05-26 00:43:53 +02:00
|
|
|
int8_text(int64 *val)
|
1999-02-13 05:22:34 +01:00
|
|
|
{
|
|
|
|
text *result;
|
|
|
|
|
|
|
|
int len;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
if (!PointerIsValid(val))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
s = int8out(val);
|
|
|
|
len = strlen(s);
|
|
|
|
|
|
|
|
result = palloc(VARHDRSZ + len);
|
|
|
|
|
|
|
|
VARSIZE(result) = len + VARHDRSZ;
|
|
|
|
memmove(VARDATA(result), s, len);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
} /* int8out() */
|