From 48165ec2262b73c5b81a6caabab66d883d013a83 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 5 Jun 2000 07:29:25 +0000 Subject: Latest round of fmgr updates. All functions with bool,char, or int2 inputs have been converted to newstyle. This should go a long way towards fixing our portability problems with platforms where char and short parameters are passed differently from int-width parameters. Still more to do for the Alpha port however. --- src/backend/utils/adt/int.c | 761 ++++++++++++++++++++++++++------------------ 1 file changed, 444 insertions(+), 317 deletions(-) (limited to 'src/backend/utils/adt/int.c') diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c index 242e9c54011..6e236a01c74 100644 --- a/src/backend/utils/adt/int.c +++ b/src/backend/utils/adt/int.c @@ -1,14 +1,14 @@ /*------------------------------------------------------------------------- * * int.c - * Functions for the built-in integer types. + * Functions for the built-in integer types (except int8). * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.36 2000/04/12 17:15:50 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.37 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -25,13 +25,12 @@ * * 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 + #include "postgres.h" + #ifdef HAVE_LIMITS_H #include #endif @@ -52,42 +51,39 @@ /* * int2in - converts "num" to short */ -int32 -int2in(char *num) +Datum +int2in(PG_FUNCTION_ARGS) { - return (int32) pg_atoi(num, sizeof(int16), '\0'); + char *num = PG_GETARG_CSTRING(0); + + PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0')); } /* * int2out - converts short to "num" */ -char * -int2out(int16 sh) +Datum +int2out(PG_FUNCTION_ARGS) { - char *result; + int16 arg1 = PG_GETARG_INT16(0); + char *result = (char *) palloc(7); /* sign, 5 digits, '\0' */ - result = (char *) palloc(7);/* assumes sign, 5 digits, '\0' */ - itoa((int) sh, result); - return result; + itoa((int) arg1, result); + PG_RETURN_CSTRING(result); } /* * int2vectorin - converts "num num ..." to internal form * - * Note: - * Fills any nonexistent digits with NULLs. + * Note: Fills any missing slots with zeroes. */ -int16 * -int2vectorin(char *intString) +Datum +int2vectorin(PG_FUNCTION_ARGS) { - int16 *result; + char *intString = PG_GETARG_CSTRING(0); + int16 *result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS])); int slot; - if (intString == NULL) - return NULL; - - result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS])); - for (slot = 0; *intString && slot < INDEX_MAX_KEYS; slot++) { if (sscanf(intString, "%hd", &result[slot]) != 1) @@ -104,28 +100,21 @@ int2vectorin(char *intString) while (slot < INDEX_MAX_KEYS) result[slot++] = 0; - return result; + PG_RETURN_POINTER(result); } /* * int2vectorout - converts internal form to "num num ..." */ -char * -int2vectorout(int16 *int2Array) +Datum +int2vectorout(PG_FUNCTION_ARGS) { + int16 *int2Array = (int16 *) PG_GETARG_POINTER(0); int num, maxnum; char *rp; char *result; - if (int2Array == NULL) - { - result = (char *) palloc(2); - result[0] = '-'; - result[1] = '\0'; - return result; - } - /* find last non-zero value in vector */ for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--) if (int2Array[maxnum] != 0) @@ -142,71 +131,72 @@ int2vectorout(int16 *int2Array) ; } *rp = '\0'; - return result; + PG_RETURN_CSTRING(result); } /* * We don't have a complete set of int2vector support routines, * but we need int2vectoreq for catcache indexing. */ -bool -int2vectoreq(int16 *arg1, int16 *arg2) +Datum +int2vectoreq(PG_FUNCTION_ARGS) { - return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0); + int16 *arg1 = (int16 *) PG_GETARG_POINTER(0); + int16 *arg2 = (int16 *) PG_GETARG_POINTER(1); + + PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0); } +/* + * Type int44 has no real-world use, but the regression tests use it. + * It's a four-element vector of int4's. + */ /* * int44in - converts "num num ..." to internal form * - * Note: - * Fills any nonexistent digits with NULLs. + * Note: Fills any missing positions with zeroes. */ -int32 * -int44in(char *input_string) +Datum +int44in(PG_FUNCTION_ARGS) { - int32 *foo = (int32 *) palloc(4 * sizeof(int32)); - int i = 0; + char *input_string = PG_GETARG_CSTRING(0); + int32 *result = (int32 *) palloc(4 * sizeof(int32)); + int i; i = sscanf(input_string, "%d, %d, %d, %d", - &foo[0], - &foo[1], - &foo[2], - &foo[3]); + &result[0], + &result[1], + &result[2], + &result[3]); while (i < 4) - foo[i++] = 0; + result[i++] = 0; - return foo; + PG_RETURN_POINTER(result); } /* * int44out - converts internal form to "num num ..." */ -char * -int44out(int32 *an_array) +Datum +int44out(PG_FUNCTION_ARGS) { - int temp = 4; - char *output_string = NULL; + int32 *an_array = (int32 *) PG_GETARG_POINTER(0); + char *result = (char *) palloc(16 * 4); /* Allow 14 digits + sign */ int i; + char *walk; - if (temp > 0) + walk = result; + for (i = 0; i < 4; i++) { - 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'; + itoa(an_array[i], walk); + while (*++walk != '\0') + ; + *walk++ = ' '; } - return output_string; + *--walk = '\0'; + PG_RETURN_CSTRING(result); } @@ -217,23 +207,25 @@ int44out(int32 *an_array) /* * int4in - converts "num" to int4 */ -int32 -int4in(char *num) +Datum +int4in(PG_FUNCTION_ARGS) { - return pg_atoi(num, sizeof(int32), '\0'); + char *num = PG_GETARG_CSTRING(0); + + PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0')); } /* * int4out - converts int4 to "num" */ -char * -int4out(int32 l) +Datum +int4out(PG_FUNCTION_ARGS) { - char *result; + int32 arg1 = PG_GETARG_INT32(0); + char *result = (char *) palloc(12); /* sign, 10 digits, '\0' */ - result = (char *) palloc(12); /* assumes sign, 10 digits, '\0' */ - ltoa(l, result); - return result; + ltoa(arg1, result); + PG_RETURN_CSTRING(result); } @@ -243,116 +235,94 @@ int4out(int32 l) * =================== */ -int32 -i2toi4(int16 arg1) +Datum +i2toi4(PG_FUNCTION_ARGS) { - return (int32) arg1; + int16 arg1 = PG_GETARG_INT16(0); + + PG_RETURN_INT32((int32) arg1); } -int16 -i4toi2(int32 arg1) +Datum +i4toi2(PG_FUNCTION_ARGS) { + int32 arg1 = PG_GETARG_INT32(0); + if (arg1 < SHRT_MIN) elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1); if (arg1 > SHRT_MAX) elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1); - return (int16) arg1; + PG_RETURN_INT16((int16) arg1); } -text * -int2_text(int16 arg1) +Datum +int2_text(PG_FUNCTION_ARGS) { - text *result; - - int len; - char *str; - - str = int2out(arg1); - len = (strlen(str) + VARHDRSZ); - - result = palloc(len); + int16 arg1 = PG_GETARG_INT16(0); + text *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */ - VARSIZE(result) = len; - memmove(VARDATA(result), str, (len - VARHDRSZ)); - - pfree(str); - - return result; -} /* int2_text() */ + itoa((int) arg1, VARDATA(result)); + VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; + PG_RETURN_TEXT_P(result); +} -int16 -text_int2(text *string) +Datum +text_int2(PG_FUNCTION_ARGS) { - int16 result; - + text *string = PG_GETARG_TEXT_P(0); + Datum result; int len; char *str; - if (!string) - return 0; - - len = (VARSIZE(string) - VARHDRSZ); + len = VARSIZE(string) - VARHDRSZ; str = palloc(len + 1); - memmove(str, VARDATA(string), len); + memcpy(str, VARDATA(string), len); *(str + len) = '\0'; - result = int2in(str); + result = DirectFunctionCall1(int2in, CStringGetDatum(str)); pfree(str); return result; -} /* text_int2() */ +} -text * -int4_text(int32 arg1) +Datum +int4_text(PG_FUNCTION_ARGS) { - text *result; - - int len; - char *str; - - str = int4out(arg1); - len = (strlen(str) + VARHDRSZ); - - result = palloc(len); - - VARSIZE(result) = len; - memmove(VARDATA(result), str, (len - VARHDRSZ)); + int32 arg1 = PG_GETARG_INT32(0); + text *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */ - pfree(str); - - return result; -} /* int4_text() */ + ltoa(arg1, VARDATA(result)); + VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; + PG_RETURN_TEXT_P(result); +} -int32 -text_int4(text *string) +Datum +text_int4(PG_FUNCTION_ARGS) { - int32 result; - + text *string = PG_GETARG_TEXT_P(0); + Datum result; int len; char *str; - if (!string) - return 0; - - len = (VARSIZE(string) - VARHDRSZ); + len = VARSIZE(string) - VARHDRSZ; str = palloc(len + 1); - memmove(str, VARDATA(string), len); + memcpy(str, VARDATA(string), len); *(str + len) = '\0'; - result = int4in(str); + result = DirectFunctionCall1(int4in, CStringGetDatum(str)); pfree(str); return result; -} /* text_int4() */ +} /* - * ========================= - * BOOLEAN OPERATOR ROUTINES - * ========================= + * ============================ + * COMPARISON OPERATOR ROUTINES + * ============================ */ /* @@ -363,148 +333,221 @@ text_int4(text *string) * intgt - returns 1 iff arg1 > arg2 * intge - returns 1 iff arg1 >= arg2 */ -bool -int4eq(int32 arg1, int32 arg2) + +Datum +int4eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int4ne(int32 arg1, int32 arg2) +Datum +int4ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int4lt(int32 arg1, int32 arg2) +Datum +int4lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int4le(int32 arg1, int32 arg2) +Datum +int4le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int4gt(int32 arg1, int32 arg2) +Datum +int4gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int4ge(int32 arg1, int32 arg2) +Datum +int4ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int2eq(int16 arg1, int16 arg2) +Datum +int2eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int2ne(int16 arg1, int16 arg2) +Datum +int2ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int2lt(int16 arg1, int16 arg2) +Datum +int2lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int2le(int16 arg1, int16 arg2) +Datum +int2le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int2gt(int16 arg1, int16 arg2) +Datum +int2gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int2ge(int16 arg1, int16 arg2) +Datum +int2ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int24eq(int32 arg1, int32 arg2) +Datum +int24eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int24ne(int32 arg1, int32 arg2) +Datum +int24ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int24lt(int32 arg1, int32 arg2) +Datum +int24lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int24le(int32 arg1, int32 arg2) +Datum +int24le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int24gt(int32 arg1, int32 arg2) +Datum +int24gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int24ge(int32 arg1, int32 arg2) +Datum +int24ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int42eq(int32 arg1, int32 arg2) +Datum +int42eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int42ne(int32 arg1, int32 arg2) +Datum +int42ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int42lt(int32 arg1, int32 arg2) +Datum +int42lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int42le(int32 arg1, int32 arg2) +Datum +int42le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int42gt(int32 arg1, int32 arg2) +Datum +int42gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int42ge(int32 arg1, int32 arg2) +Datum +int42ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 >= arg2); } /* @@ -513,159 +556,226 @@ int42ge(int32 arg1, int32 arg2) * int[24]mul - returns arg1 * arg2 * int[24]div - returns arg1 / arg2 */ -int32 -int4um(int32 arg) + +Datum +int4um(PG_FUNCTION_ARGS) { - return -arg; + int32 arg = PG_GETARG_INT32(0); + + PG_RETURN_INT32(-arg); } -int32 -int4pl(int32 arg1, int32 arg2) +Datum +int4pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int4mi(int32 arg1, int32 arg2) +Datum +int4mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int4mul(int32 arg1, int32 arg2) +Datum +int4mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int4div(int32 arg1, int32 arg2) +Datum +int4div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 / arg2); } -int32 -int4inc(int32 arg) +Datum +int4inc(PG_FUNCTION_ARGS) { - return arg + (int32) 1; + int32 arg = PG_GETARG_INT32(0); + + PG_RETURN_INT32(arg + 1); } -int16 -int2um(int16 arg) +Datum +int2um(PG_FUNCTION_ARGS) { - return -arg; + int16 arg = PG_GETARG_INT16(0); + + PG_RETURN_INT16(-arg); } -int16 -int2pl(int16 arg1, int16 arg2) +Datum +int2pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 + arg2); } -int16 -int2mi(int16 arg1, int16 arg2) +Datum +int2mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 - arg2); } -int16 -int2mul(int16 arg1, int16 arg2) +Datum +int2mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 * arg2); } -int16 -int2div(int16 arg1, int16 arg2) +Datum +int2div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 / arg2); } -int16 -int2inc(int16 arg) +Datum +int2inc(PG_FUNCTION_ARGS) { - return arg + (int16) 1; + int16 arg = PG_GETARG_INT16(0); + + PG_RETURN_INT16(arg + 1); } -int32 -int24pl(int32 arg1, int32 arg2) +Datum +int24pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int24mi(int32 arg1, int32 arg2) +Datum +int24mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int24mul(int32 arg1, int32 arg2) +Datum +int24mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int24div(int32 arg1, int32 arg2) +Datum +int24div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 / arg2); } -int32 -int42pl(int32 arg1, int32 arg2) +Datum +int42pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int42mi(int32 arg1, int32 arg2) +Datum +int42mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int42mul(int32 arg1, int32 arg2) +Datum +int42mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int42div(int32 arg1, int32 arg2) +Datum +int42div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 / arg2); } -/* - * int[24]mod - returns arg1 mod arg2 - */ -int32 -int4mod(int32 arg1, int32 arg2) +Datum +int4mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 % arg2); } -int32 -int2mod(int16 arg1, int16 arg2) +Datum +int2mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 % arg2); } -int32 -int24mod(int32 arg1, int32 arg2) +Datum +int24mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 % arg2); } -int32 -int42mod(int32 arg1, int32 arg2) +Datum +int42mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 % arg2); } /* int[24]fac() * Factorial */ -int32 -int4fac(int32 arg1) +Datum +int4fac(PG_FUNCTION_ARGS) { + int32 arg1 = PG_GETARG_INT32(0); int32 result; if (arg1 < 1) @@ -673,12 +783,13 @@ int4fac(int32 arg1) else for (result = 1; arg1 > 0; --arg1) result *= arg1; - return result; + PG_RETURN_INT32(result); } -int32 -int2fac(int16 arg1) +Datum +int2fac(PG_FUNCTION_ARGS) { + int16 arg1 = PG_GETARG_INT16(0); int32 result; if (arg1 < 1) @@ -686,44 +797,60 @@ int2fac(int16 arg1) else for (result = 1; arg1 > 0; --arg1) result *= arg1; - return result; + PG_RETURN_INT32(result); } /* int[24]abs() * Absolute value */ -int32 -int4abs(int32 arg1) +Datum +int4abs(PG_FUNCTION_ARGS) { - return ((arg1 < 0) ? -arg1 : arg1); + int32 arg1 = PG_GETARG_INT32(0); + + PG_RETURN_INT32((arg1 < 0) ? -arg1 : arg1); } -int16 -int2abs(int16 arg1) +Datum +int2abs(PG_FUNCTION_ARGS) { - return ((arg1 < 0) ? -arg1 : arg1); + int16 arg1 = PG_GETARG_INT16(0); + + PG_RETURN_INT16((arg1 < 0) ? -arg1 : arg1); } -int16 -int2larger(int16 arg1, int16 arg2) +Datum +int2larger(PG_FUNCTION_ARGS) { - return (arg1 > arg2) ? arg1 : arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2); } -int16 -int2smaller(int16 arg1, int16 arg2) +Datum +int2smaller(PG_FUNCTION_ARGS) { - return (arg1 < arg2) ? arg1 : arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2); } -int32 -int4larger(int32 arg1, int32 arg2) +Datum +int4larger(PG_FUNCTION_ARGS) { - return (arg1 > arg2) ? arg1 : arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2); } -int32 -int4smaller(int32 arg1, int32 arg2) +Datum +int4smaller(PG_FUNCTION_ARGS) { - return (arg1 < arg2) ? arg1 : arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2); } -- cgit v1.2.3