head	1.18;
access;
symbols
	release_4_2:1.18
	aix_ok:1.17
	Version_2_1:1.6
	C_Demo_1:1.4;
locks; strict;
comment	@ * @;


1.18
date	94.01.30.04.17.52;	author aoki;	state Exp;
branches;
next	1.17;

1.17
date	93.08.24.07.54.06;	author aoki;	state Exp;
branches;
next	1.16;

1.16
date	93.06.24.03.58.07;	author aoki;	state Exp;
branches;
next	1.15;

1.15
date	93.01.16.03.14.59;	author aoki;	state Exp;
branches;
next	1.14;

1.14
date	93.01.05.02.31.00;	author aoki;	state Exp;
branches;
next	1.13;

1.13
date	92.07.28.19.11.44;	author mao;	state Exp;
branches;
next	1.12;

1.12
date	92.03.04.22.48.45;	author mer;	state Exp;
branches;
next	1.11;

1.11
date	92.01.13.02.21.26;	author mao;	state Exp;
branches;
next	1.10;

1.10
date	91.12.03.23.35.12;	author glass;	state Exp;
branches;
next	1.9;

1.9
date	91.11.09.01.51.20;	author mer;	state Exp;
branches;
next	1.8;

1.8
date	91.11.05.05.37.24;	author mer;	state Exp;
branches;
next	1.7;

1.7
date	91.08.15.18.07.05;	author caetta;	state Exp;
branches;
next	1.6;

1.6
date	90.09.25.16.49.37;	author kemnitz;	state Exp;
branches;
next	1.5;

1.5
date	90.06.05.23.27.38;	author kemnitz;	state Exp;
branches;
next	1.4;

1.4
date	89.09.05.17.26.20;	author mao;	state C_Demo_1;
branches;
next	1.3;

1.3
date	89.03.02.19.54.49;	author muir;	state Stab;
branches;
next	1.2;

1.2
date	89.01.19.23.03.41;	author aoki;	state Exp;
branches;
next	1.1;

1.1
date	89.01.17.05.58.36;	author cimarron;	state Exp;
branches;
next	;


desc
@@


1.18
log
@now uses pg_atoi
@
text
@/*
 * int.c --
 * 	Functions for the built-in integer types.
 *
 *	I/O routines:
 *	 int2in, int2out, int28in, int28out, int4in, int4out
 *	Conversion routines:
 *	 itoi
 *	Boolean operators:
 *	 inteq, intne, intlt, intle, intgt, intge
 *	Arithmetic operators:
 *	 intpl, intmi, int4mul, intdiv
 *
 *	Arithmetic operators:
 *	 intmod, int4fac
 *
 * XXX makes massive and possibly unwarranted type promotion assumptions.
 * fix me when we figure out what we want to do about ANSIfication...
 */

#include "tmp/postgres.h"
#include "fmgr.h"
#include "utils/builtins.h"
#include "utils/log.h"

RcsId("$Header: /faerie/aoki/postgres/src/backend/utils/adt/RCS/int.c,v 1.17 1993/08/24 07:54:06 aoki Exp aoki $");

	    /* ========== USER I/O ROUTINES ========== */


/*
 *	int2in		- converts "num" to short
 */
int32
int2in(num)
	char	*num;
{
	return((int32) pg_atoi(num, sizeof(int16), '\0'));
}

/*
 *	int2out		- converts short to "num"
 */
char *
int2out(sh)
	int16	sh;
{
	char		*result;

	result = (char *)palloc(7);	/* assumes sign, 5 digits, '\0' */
	itoa((int) sh, result);
	return(result);
}

/*
 *	int28in		- converts "num num ..." to internal form
 *
 *	Note:
 *		Fills any nonexistent digits with NULLs.
 */
int16 *
int28in(shs)
	char	*shs;
{
	register int16	(*result)[];
	int		nums;

	if (shs == NULL)
		return(NULL);
	result = (int16 (*)[]) palloc(sizeof(int16 [8]));
	if ((nums = sscanf(shs, "%hd%hd%hd%hd%hd%hd%hd%hd",
			   *result,
			   *result + 1,
			   *result + 2,
			   *result + 3,
			   *result + 4,
			   *result + 5,
			   *result + 6,
			   *result + 7)) != 8) {
		do
			(*result)[nums++] = 0;
		while (nums < 8);
	}
	return((int16 *) result);
}

/*
 *	int28out	- converts internal form to "num num ..."
 */
char *
int28out(shs)
	int16	(*shs)[];
{
	register int	num;
	register int16	*sp;
	register char	*rp;
	char 		*result;

	if (shs == NULL) {
		result = (char *)palloc(2);
		result[0] = '-';
		result[1] = '\0';
		return(result);
	}
	rp = result = (char *)palloc(8 * 7); /* assumes sign, 5 digits, ' ' */
	sp = *shs;
	for (num = 8; num != 0; num--) {
		itoa(*sp++, rp);
		while (*++rp != '\0')
			;
		*rp++ = ' ';
	}
	*--rp = '\0';
	return(result);
}

/*
 *	int28in		- converts "num num ..." to internal form
 *
 *	Note:
 *		Fills any nonexistent digits with NULLs.
 */
int32 *
int44in(input_string)
	char	*input_string;

{
    int32 *foo = (int32 *)palloc(4*sizeof(int32));
    register int i = 0;

    i = sscanf(input_string,
	       "%d, %d, %d, %d",
	       &foo[0],
	       &foo[1],
	       &foo[2],
	       &foo[3]);
    while (i < 4)
	foo[i++] = 0;

    return(foo);
}

/*
 *	int28out	- converts internal form to "num num ..."
 */
char *
int44out(an_array)
	int32	an_array[];
{
    int temp = 4;
    char *output_string = NULL;
    int i;

    if ( temp > 0 ) {
	char *walk;
	output_string = (char *)palloc(16*temp); /* assume 15 digits + sign */
	walk = output_string;
	for ( i = 0 ; i < temp ; i++ ) {
	    itoa(an_array[i],walk);
	    while (*++walk != '\0')
	      ;
	    *walk++ = ' ';
	}
	*--walk = '\0';
    }
    return(output_string);
}


	     /* ========== PUBLIC ROUTINES ========== */


/*
 *	int4in		- converts "num" to int4
 */
int32
int4in(num)
	char	*num;
{
	return(pg_atoi(num, sizeof(int32), '\0'));
}

/*
 *	int4out		- converts int4 to "num"
 */
char *
int4out(l)
	int32	l;
{
	char		*result;

	result = (char *)palloc(12);	/* assumes sign, 10 digits, '\0' */
	ltoa(l, result);
	return(result);
}


/*
 *	===================
 *	CONVERSION ROUTINES
 *	===================
 */

int32
i2toi4(arg1)
	int16	arg1;
{
	return((int32) arg1);
}

int16
i4toi2(arg1)
	int32	arg1;
{
	if (arg1< -0x8000)
		elog(NOTICE, "i4toi2: \"%d\" causes int2 underflow", arg1);
	if (arg1 > 0x7FFF)
		elog(NOTICE, "i4toi2: \"%d\" causes int2 overflow", arg1);
							 
	return((int16) arg1);
}


/*
 *	=========================
 *	BOOLEAN OPERATOR ROUTINES
 *	=========================
 */

/*
 *	inteq		- returns 1 iff arg1 == arg2
 *	intne		- returns 1 iff arg1 != arg2
 *	intlt		- returns 1 iff arg1 < arg2
 *	intle		- returns 1 iff arg1 <= arg2
 *	intgt		- returns 1 iff arg1 > arg2
 *	intge		- returns 1 iff arg1 >= arg2
 */
int32 int4eq(arg1, arg2)	int32	arg1, arg2; { return(arg1 == arg2); }
int32 int4ne(arg1, arg2) 	int32	arg1, arg2; { return(arg1 != arg2); }
int32 int4lt(arg1, arg2) 	int32	arg1, arg2; { return(arg1 < arg2); }
int32 int4le(arg1, arg2) 	int32	arg1, arg2; { return(arg1 <= arg2); }
int32 int4gt(arg1, arg2)	int32	arg1, arg2; { return(arg1 > arg2); } 
int32 int4ge(arg1, arg2)	int32	arg1, arg2; { return(arg1 >= arg2); }

int32 int2eq(arg1, arg2)	int16	arg1, arg2; { return(arg1 == arg2); }
int32 int2ne(arg1, arg2)	int16	arg1, arg2; { return(arg1 != arg2); }
int32 int2lt(arg1, arg2)	int16	arg1, arg2; { return(arg1 < arg2); }
int32 int2le(arg1, arg2)	int16	arg1, arg2; { return(arg1 <= arg2); }
int32 int2gt(arg1, arg2)	int16	arg1, arg2; { return(arg1 > arg2); } 
int32 int2ge(arg1, arg2)	int16	arg1, arg2; { return(arg1 >= arg2); }

int32 int24eq(arg1, arg2)	int32	arg1, arg2; { return(arg1 == arg2); }
int32 int24ne(arg1, arg2) 	int32	arg1, arg2; { return(arg1 != arg2); }
int32 int24lt(arg1, arg2) 	int32	arg1, arg2; { return(arg1 < arg2); }
int32 int24le(arg1, arg2) 	int32	arg1, arg2; { return(arg1 <= arg2); }
int32 int24gt(arg1, arg2)	int32	arg1, arg2; { return(arg1 > arg2); } 
int32 int24ge(arg1, arg2)	int32	arg1, arg2; { return(arg1 >= arg2); }

int32 int42eq(arg1, arg2)	int32	arg1, arg2; { return(arg1 == arg2); }
int32 int42ne(arg1, arg2) 	int32	arg1, arg2; { return(arg1 != arg2); }
int32 int42lt(arg1, arg2) 	int32	arg1, arg2; { return(arg1 < arg2); }
int32 int42le(arg1, arg2) 	int32	arg1, arg2; { return(arg1 <= arg2); }
int32 int42gt(arg1, arg2)	int32	arg1, arg2; { return(arg1 > arg2); } 
int32 int42ge(arg1, arg2)	int32	arg1, arg2; { return(arg1 >= arg2); }

int32 keyfirsteq(arg1, arg2)	int16	*arg1,arg2; { return(*arg1 == arg2); }

/*
 *	int[24]pl	- returns arg1 + arg2
 *	int[24]mi	- returns arg1 - arg2
 *	int[24]mul	- returns arg1 * arg2
 *	int[24]div	- returns arg1 / arg2
 */
int32 int4um(arg)		int32	arg; { return(-arg); }
int32 int4pl(arg1, arg2) 	int32	arg1, arg2; { return(arg1 + arg2); }
int32 int4mi(arg1, arg2)	int32	arg1, arg2; { return(arg1 - arg2); }
int32 int4mul(arg1, arg2)	int32	arg1, arg2; { return(arg1 * arg2); }
int32 int4div(arg1, arg2)	int32	arg1, arg2; { return(arg1 / arg2); }
int32 int4inc(arg)		int32   arg;        { return(arg + (int32)1); }

int16 int2um(arg)		int16	arg; { return(-arg); }
int16 int2pl(arg1, arg2)	int16	arg1, arg2; { return(arg1 + arg2); }
int16 int2mi(arg1, arg2)	int16	arg1, arg2; { return(arg1 - arg2); }
int16 int2mul(arg1, arg2)	int16	arg1, arg2; { return(arg1 * arg2); }
int16 int2div(arg1, arg2)	int16	arg1, arg2; { return(arg1 / arg2); }
int16 int2inc(arg)		int16   arg;	    { return(arg + (int16)1); }

int32 int24pl(arg1, arg2) 	int32	arg1, arg2; { return(arg1 + arg2); }
int32 int24mi(arg1, arg2)	int32	arg1, arg2; { return(arg1 - arg2); }
int32 int24mul(arg1, arg2)	int32	arg1, arg2; { return(arg1 * arg2); }
int32 int24div(arg1, arg2)	int32	arg1, arg2; { return(arg1 / arg2); }

int32 int42pl(arg1, arg2) 	int32	arg1, arg2; { return(arg1 + arg2); }
int32 int42mi(arg1, arg2)	int32	arg1, arg2; { return(arg1 - arg2); }
int32 int42mul(arg1, arg2)	int32	arg1, arg2; { return(arg1 * arg2); }
int32 int42div(arg1, arg2)	int32	arg1, arg2; { return(arg1 / arg2); }

/*
 *	int[24]mod	- returns arg1 mod arg2
 */
int32 int4mod(arg1, arg2)	int32	arg1, arg2; { return(arg1 % arg2); }
int32 int2mod(arg1, arg2)	int16	arg1, arg2; { return(arg1 % arg2); }
int32 int24mod(arg1, arg2)	int32	arg1, arg2; { return(arg1 % arg2); }
int32 int42mod(arg1, arg2)	int32	arg1, arg2; { return(arg1 % arg2); }

/*
 *	int[24]fac	- returns arg1!
 */
int32
int4fac(arg1)
	int32 	arg1;
{
	int32	result;

	if (arg1 < 1)
		result = 0;
	else 
		for (result = 1; arg1 > 0; --arg1)
			result *= arg1;
	return(result);
}

int32
int2fac(arg1)
	int16 	arg1;
{
	int16	result;

	if (arg1 < 1)
		result = 0;
	else 
		for (result = 1; arg1 > 0; --arg1)
			result *= arg1;
	return(result);
}

int16
int2larger(arg1, arg2)
	int16	arg1;
	int16	arg2;
{
	return ((arg1 > arg2) ? arg1 : arg2);
}

int16
int2smaller(arg1, arg2)
	int16	arg1;
	int16	arg2;
{
	return ((arg1 > arg2) ? arg2 : arg1);
}

int32
int4larger(arg1, arg2)
	int32	arg1;
	int32	arg2;
{
	return ((arg1 > arg2) ? arg1 : arg2);
}

int32
int4smaller(arg1, arg2)
	int32	arg1;
	int32	arg2;
{
	return ((arg1 > arg2) ? arg2 : arg1);
}
@


1.17
log
@removed %ld from call on int32's
@
text
@d26 1
a26 1
RcsId("$Header: /home2/aoki/postgres/src/backend/utils/adt/RCS/int.c,v 1.16 1993/06/24 03:58:07 aoki Exp aoki $");
d38 1
a38 1
	return((int32) atoi(num));
d180 1
a180 1
	return((int32) atol(num));
d193 1
a193 1
	ltoa((long) l, result);
d204 18
a221 2
int32	i2toi4(arg1)	int16	arg1;	{ return((int32) arg1); }
int16	i4toi2(arg1)	int32	arg1;	{ return((int16) arg1); }
@


1.16
log
@added "utils/builtins.h"
(this remaps ltoa->pg_ltoa on hpux)
removed some crocked extern decl's
@
text
@d26 1
a26 1
RcsId("$Header: /usr/local/devel/postgres/src/backend/utils/adt/RCS/int.c,v 1.15 1993/01/16 03:14:59 aoki Exp $");
d132 1
a132 1
	       "%ld, %ld, %ld, %ld",
@


1.15
log
@removed references to utils/fmgr.h and parser/parse.h
@
text
@d23 1
d26 1
a26 1
RcsId("$Header: /home2/aoki/postgres/src/backend/utils/adt/RCS/int.c,v 1.14 1993/01/05 02:31:00 aoki Exp aoki $");
a27 1

a37 2
	extern int	atoi();

a48 1
	extern int	itoa();
a97 1
	extern int	itoa();
a151 1
    extern int itoa();
a179 2
	extern long	atol();

a190 1
	extern int	ltoa();
@


1.14
log
@fixed F_ regproc name for script-built fmgr
@
text
@d22 1
a22 1
#include "utils/fmgr.h"
d25 1
a25 1
RcsId("$Header: /home2/aoki/postgres/src/backend/utils/adt/RCS/int.c,v 1.13 1992/07/28 19:11:44 mao Exp aoki $");
@


1.13
log
@add uminus for int2,4
@
text
@d16 3
d25 1
a25 1
RcsId("$Header: /private/mao/postgres/src/utils/adt/RCS/int.c,v 1.12 1992/03/04 22:48:45 mer Exp mao $");
d212 2
a213 9
/*
 *	itoi - "convert" arg1 to another integer type
 */
int32
itoi(arg1)
	int32	arg1;
{
	return(arg1);
}
a219 3
 *
 *	These operations are used (and work correctly) for nearly
 *	every integer type, e.g., int2, int32, bool, char, OID, ...
d244 14
d280 10
d295 2
@


1.12
log
@int44in() routine was reading beyond the end of the string
@
text
@d22 1
a22 1
RcsId("$Header: /users/mer/pg/src/utils/adt/RCS/int.c,v 1.11 1992/01/13 02:21:26 mao Exp mer $");
d259 1
d266 6
a271 5
int32 int2pl(arg1, arg2)	int16	arg1, arg2; { return(arg1 + arg2); }
int32 int2mi(arg1, arg2)	int16	arg1, arg2; { return(arg1 - arg2); }
int32 int2mul(arg1, arg2)	int16	arg1, arg2; { return(arg1 * arg2); }
int32 int2div(arg1, arg2)	int16	arg1, arg2; { return(arg1 / arg2); }
int32 int2inc(arg)		int16   arg;	    { return(arg + (int16)1); }
@


1.11
log
@flatten include file graph
@
text
@d20 1
d22 1
a22 1
RcsId("$Header: RCS/int.c,v 1.10 91/12/03 23:35:12 glass Exp Locker: mao $");
d132 9
a140 8
    char *temp = input_string;
    
    while ( sscanf(temp,"%ld", &foo[i]) == 1 
	   && i < 4) {
	i = i+1;
	while (*temp != ' ' && *temp != '\t') temp++;
	while (*temp == ' ' || *temp == '\t') temp++;
    }
@


1.10
log
@fixed warning on sparc
@
text
@a13 3
 * 	Routines for (non-builtin) integer operations.
 *		(included if FMGR_MATH is defined in h/fmgr.h)
 *
d21 1
a21 1
RcsId("$Header: utils/adt/RCS/int.c,v 1.9 91/11/09 01:51:20 mer Exp Locker: glass $");
a268 1
#ifdef FMGR_MATH
a336 11


#endif FMGR_MATH




	     /* ========== PRIVATE ROUTINES ========== */


			     /* (none) */
@


1.9
log
@function prototyping
@
text
@d24 1
a24 1
RcsId("$Header: /users/mer/postgres/src/utils/adt/RCS/int.c,v 1.8 1991/11/05 05:37:24 mer Exp $");
d131 1
a131 1
    int *foo = (int *)palloc(4*sizeof(int));
@


1.8
log
@add functions for aggregate definitions
@
text
@d24 1
a24 1
RcsId("$Header: /users/mer/postgres/src/utils/adt/RCS/int.c,v 1.7 1991/08/15 18:07:05 caetta Exp mer $");
d52 1
a52 1
	result = palloc(7);		/* assumes sign, 5 digits, '\0' */
d103 1
a103 1
		result = palloc(2);
d108 1
a108 1
	rp = result = palloc(8 * 7);	/* assumes sign, 5 digits, ' ' */
d198 1
a198 1
	result = palloc(12);		/* assumes sign, 10 digits, '\0' */
@


1.7
log
@for increment functions for aggs..
@
text
@d24 1
a24 1
RcsId("$Header: RCS/int.c,v 1.6 90/09/25 16:49:37 kemnitz Exp Locker: caetta $");
d309 33
@


1.6
log
@Updating from revision 1.5 to revision 1.7
@
text
@d24 1
a24 1
RcsId("$Header: RCS/int.c,v 1.7 90/09/11 14:40:20 kemnitz Exp $");
d264 1
d270 1
@


1.5
log
@Added int44in and int44out
@
text
@d21 2
a22 3
#include "c.h"
#include "postgres.h"
#include "fmgr.h"
d24 1
a24 1
RcsId("$Header: RCS/int.c,v 1.4 89/09/05 17:26:20 mao C_Demo_1 Locker: kemnitz $");
d47 1
a47 1
	int32	sh;
@


1.4
log
@Working version of C-only demo
@
text
@d25 1
a25 1
RcsId("$Header: /usr6/postgres/mao/postgres/src/utils/adt/RCS/int.c,v 1.3 89/03/02 19:54:49 muir Stab $");
d119 52
@


1.3
log
@added keyfirsteq -hirohama
@
text
@d25 1
a25 1
RcsId("$Header: /usr6/postgres/muir/postgres/src/utils/adt/RCS/int.c,v 1.2 89/01/19 23:03:41 aoki Exp $");
@


1.2
log
@new int[24] functions
@
text
@d25 1
a25 1
RcsId("$Header: int.c,v 1.1 89/01/17 05:58:36 aoki Locked $");
d201 2
d258 2
@


1.1
log
@Initial revision
@
text
@a0 1

a1 26
 * 
 * POSTGRES Data Base Management System
 * 
 * Copyright (c) 1988 Regents of the University of California
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for educational, research, and non-profit purposes and
 * without fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation, and that
 * the name of the University of California not be used in advertising
 * or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Permission to incorporate this
 * software into commercial products can be obtained from the Campus
 * Software Office, 295 Evans Hall, University of California, Berkeley,
 * Ca., 94720 provided only that the the requestor give the University
 * of California a free licence to any derived software for educational
 * and research purposes.  The University of California makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 * 
 */



/*
d25 1
a25 1
RcsId("$Header: int.c,v 1.1 88/11/11 16:35:45 postgres Exp $");
d187 6
a192 4
int32
inteq(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 == arg2); }
d194 6
a199 4
int32
intne(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 != arg2); }
a200 20
int32
intlt(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 < arg2); }

int32
intle(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 <= arg2); }

int32
intgt(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 > arg2); }

int32
intge(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 >= arg2); }

d202 4
a205 4
 *	intpl	- returns arg1 + arg2
 *	intmi	- returns arg1 - arg2
 *	int4mul	- returns arg1 * arg2
 *	intdiv	- returns arg1 / arg2
d207 4
a210 4
int32
intpl(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 + arg2); }
d212 4
a215 4
int32
intmi(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 - arg2); }
a216 10
int32
int4mul(arg1, arg2)
	int32 	arg1, arg2;
{ return(arg1 * arg2); }

int32
intdiv(arg1, arg2)
	int32	arg1, arg2;
{ return(arg1 / arg2); }

d219 1
a219 1
 *	intmod	- returns arg1 mod arg2
d221 2
a222 6
int32
intmod(arg1, arg2)
	int32	arg1, arg2;
{
	return(arg1 % arg2);
}
d225 1
a225 1
 *	int4fac	- returns arg1!
d240 15
a261 1

@