diff options
| author | Bruce Momjian | 2001-10-25 05:50:21 +0000 |
|---|---|---|
| committer | Bruce Momjian | 2001-10-25 05:50:21 +0000 |
| commit | b81844b1738c584d92330a5ccd0fbd8b603d2886 (patch) | |
| tree | 4fae0d4cd26048177fc5cd1a2dd91abc99ba0f99 | |
| parent | 59da2105d8e6d95345b3b942a2e2aba8cead4838 (diff) | |
pgindent run on all C files. Java run to follow. initdb/regression
tests pass.
818 files changed, 21811 insertions, 20618 deletions
diff --git a/contrib/array/array_iterator.h b/contrib/array/array_iterator.h index 68da385c9a..7889fdc0b2 100644 --- a/contrib/array/array_iterator.h +++ b/contrib/array/array_iterator.h @@ -34,7 +34,6 @@ int32 array_all_int4le(ArrayType *array, int4 value); int32 array_oideq(ArrayType *array, Oid value); int32 array_all_oidne(ArrayType *array, Oid value); - #endif /* diff --git a/contrib/btree_gist/btree_gist.c b/contrib/btree_gist/btree_gist.c index 999d199ff2..4235c0a5d9 100644 --- a/contrib/btree_gist/btree_gist.c +++ b/contrib/btree_gist/btree_gist.c @@ -8,43 +8,46 @@ #include "utils/geo_decls.h" #include "utils/elog.h" -typedef int (*CMPFUNC)(const void *a, const void *b); -typedef void (*BINARY_UNION)(Datum*, char*); +typedef int (*CMPFUNC) (const void *a, const void *b); +typedef void (*BINARY_UNION) (Datum *, char *); -typedef struct intkey { - int4 lower; - int4 upper; -} INT4KEY; +typedef struct intkey +{ + int4 lower; + int4 upper; +} INT4KEY; -typedef struct tskey { - Timestamp lower; - Timestamp upper; -} TSKEY; +typedef struct tskey +{ + Timestamp lower; + Timestamp upper; +} TSKEY; /* used for sorting */ -typedef struct rix { - int index; - char *r; -} RIX; +typedef struct rix +{ + int index; + char *r; +} RIX; /* ** int4key in/out */ PG_FUNCTION_INFO_V1(int4key_in); PG_FUNCTION_INFO_V1(int4key_out); -Datum int4key_in(PG_FUNCTION_ARGS); -Datum int4key_out(PG_FUNCTION_ARGS); +Datum int4key_in(PG_FUNCTION_ARGS); +Datum int4key_out(PG_FUNCTION_ARGS); /* ** tskey in/out */ PG_FUNCTION_INFO_V1(tskey_in); PG_FUNCTION_INFO_V1(tskey_out); -Datum tskey_in(PG_FUNCTION_ARGS); -Datum tskey_out(PG_FUNCTION_ARGS); +Datum tskey_in(PG_FUNCTION_ARGS); +Datum tskey_out(PG_FUNCTION_ARGS); /* -** int4 ops +** int4 ops */ PG_FUNCTION_INFO_V1(gint4_compress); PG_FUNCTION_INFO_V1(gint4_union); @@ -53,15 +56,15 @@ PG_FUNCTION_INFO_V1(gint4_consistent); PG_FUNCTION_INFO_V1(gint4_penalty); PG_FUNCTION_INFO_V1(gint4_same); -Datum gint4_compress(PG_FUNCTION_ARGS); -Datum gint4_union(PG_FUNCTION_ARGS); -Datum gint4_picksplit(PG_FUNCTION_ARGS); -Datum gint4_consistent(PG_FUNCTION_ARGS); -Datum gint4_penalty(PG_FUNCTION_ARGS); -Datum gint4_same(PG_FUNCTION_ARGS); +Datum gint4_compress(PG_FUNCTION_ARGS); +Datum gint4_union(PG_FUNCTION_ARGS); +Datum gint4_picksplit(PG_FUNCTION_ARGS); +Datum gint4_consistent(PG_FUNCTION_ARGS); +Datum gint4_penalty(PG_FUNCTION_ARGS); +Datum gint4_same(PG_FUNCTION_ARGS); static void gint4_binary_union(Datum *r1, char *r2); -static int int4key_cmp(const void *a, const void *b); +static int int4key_cmp(const void *a, const void *b); /* ** timestamp ops @@ -73,51 +76,51 @@ PG_FUNCTION_INFO_V1(gts_consistent); PG_FUNCTION_INFO_V1(gts_penalty); PG_FUNCTION_INFO_V1(gts_same); -Datum gts_compress(PG_FUNCTION_ARGS); -Datum gts_union(PG_FUNCTION_ARGS); -Datum gts_picksplit(PG_FUNCTION_ARGS); -Datum gts_consistent(PG_FUNCTION_ARGS); -Datum gts_penalty(PG_FUNCTION_ARGS); -Datum gts_same(PG_FUNCTION_ARGS); +Datum gts_compress(PG_FUNCTION_ARGS); +Datum gts_union(PG_FUNCTION_ARGS); +Datum gts_picksplit(PG_FUNCTION_ARGS); +Datum gts_consistent(PG_FUNCTION_ARGS); +Datum gts_penalty(PG_FUNCTION_ARGS); +Datum gts_same(PG_FUNCTION_ARGS); static void gts_binary_union(Datum *r1, char *r2); -static int tskey_cmp(const void *a, const void *b); +static int tskey_cmp(const void *a, const void *b); /* define for comparison */ #define TSGE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \ - timestamp_ge, \ - PointerGetDatum( ts1 ), \ - PointerGetDatum( ts2 ) \ + timestamp_ge, \ + PointerGetDatum( ts1 ), \ + PointerGetDatum( ts2 ) \ ))) #define TSGT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \ - timestamp_gt, \ - PointerGetDatum( ts1 ), \ - PointerGetDatum( ts2 ) \ + timestamp_gt, \ + PointerGetDatum( ts1 ), \ + PointerGetDatum( ts2 ) \ ))) #define TSEQ( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \ - timestamp_eq, \ - PointerGetDatum( ts1 ), \ - PointerGetDatum( ts2 ) \ + timestamp_eq, \ + PointerGetDatum( ts1 ), \ + PointerGetDatum( ts2 ) \ ))) #define TSLT( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \ - timestamp_lt, \ - PointerGetDatum( ts1 ), \ - PointerGetDatum( ts2 ) \ + timestamp_lt, \ + PointerGetDatum( ts1 ), \ + PointerGetDatum( ts2 ) \ ))) #define TSLE( ts1, ts2 ) (DatumGetBool(DirectFunctionCall2( \ - timestamp_le, \ - PointerGetDatum( ts1 ), \ - PointerGetDatum( ts2 ) \ + timestamp_le, \ + PointerGetDatum( ts1 ), \ + PointerGetDatum( ts2 ) \ ))) /* ** Common btree-function (for all ops) */ -static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, - BINARY_UNION bu, CMPFUNC cmp); +static GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, + BINARY_UNION bu, CMPFUNC cmp); PG_FUNCTION_INFO_V1(btree_decompress); -Datum btree_decompress(PG_FUNCTION_ARGS); +Datum btree_decompress(PG_FUNCTION_ARGS); /************************************************** * int4 ops @@ -126,334 +129,364 @@ Datum btree_decompress(PG_FUNCTION_ARGS); Datum gint4_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); - GISTENTRY *retval; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + INT4KEY *r = palloc(sizeof(INT4KEY)); - if ( entry->leafkey) { - INT4KEY *r = palloc(sizeof(INT4KEY)); retval = palloc(sizeof(GISTENTRY)); r->lower = r->upper = (entry->key); - + gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, - entry->offset, sizeof(INT4KEY),FALSE); + entry->offset, sizeof(INT4KEY), FALSE); - } else { - retval = entry; } - PG_RETURN_POINTER( retval ); + else + retval = entry; + PG_RETURN_POINTER(retval); } -Datum +Datum gint4_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); - int4 query = PG_GETARG_INT32(1); - INT4KEY *kkk= (INT4KEY *)DatumGetPointer(entry->key); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval; - - switch(strategy) { - case BTLessEqualStrategyNumber: - retval = ( query >= kkk->lower ); - break; - case BTLessStrategyNumber: - if (GIST_LEAF(entry)) - retval = ( query > kkk->lower ); - else - retval = ( query >= kkk->lower ); - break; - case BTEqualStrategyNumber: - /* in leaf page kkk->lower always = kkk->upper */ - if (GIST_LEAF(entry)) - retval = ( query == kkk->lower ); - else - retval = ( kkk->lower <= query && query <= kkk->upper ); - break; - case BTGreaterStrategyNumber: - if (GIST_LEAF(entry)) - retval = ( query < kkk->upper ); - else - retval = ( query <= kkk->upper ); - break; - case BTGreaterEqualStrategyNumber: - retval = ( query <= kkk->upper ); - break; - default: - retval = FALSE; - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + int4 query = PG_GETARG_INT32(1); + INT4KEY *kkk = (INT4KEY *) DatumGetPointer(entry->key); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval; + + switch (strategy) + { + case BTLessEqualStrategyNumber: + retval = (query >= kkk->lower); + break; + case BTLessStrategyNumber: + if (GIST_LEAF(entry)) + retval = (query > kkk->lower); + else + retval = (query >= kkk->lower); + break; + case BTEqualStrategyNumber: + /* in leaf page kkk->lower always = kkk->upper */ + if (GIST_LEAF(entry)) + retval = (query == kkk->lower); + else + retval = (kkk->lower <= query && query <= kkk->upper); + break; + case BTGreaterStrategyNumber: + if (GIST_LEAF(entry)) + retval = (query < kkk->upper); + else + retval = (query <= kkk->upper); + break; + case BTGreaterEqualStrategyNumber: + retval = (query <= kkk->upper); + break; + default: + retval = FALSE; + } + PG_RETURN_BOOL(retval); } Datum gint4_union(PG_FUNCTION_ARGS) { - bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); - int i, numranges; - INT4KEY *cur, *out=palloc(sizeof(INT4KEY)); - - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - *(int*) PG_GETARG_POINTER(1) = sizeof(INT4KEY); - - cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) ); - out->lower = cur->lower; - out->upper = cur->upper; - - for (i = 1; i < numranges; i++) { - cur = (INT4KEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) ); - if ( out->lower > cur->lower ) out->lower = cur->lower; - if ( out->upper < cur->upper ) out->upper = cur->upper; - } + bytea *entryvec = (bytea *) PG_GETARG_POINTER(0); + int i, + numranges; + INT4KEY *cur, + *out = palloc(sizeof(INT4KEY)); + + numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY); + *(int *) PG_GETARG_POINTER(1) = sizeof(INT4KEY); + + cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key)); + out->lower = cur->lower; + out->upper = cur->upper; + + for (i = 1; i < numranges; i++) + { + cur = (INT4KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key)); + if (out->lower > cur->lower) + out->lower = cur->lower; + if (out->upper < cur->upper) + out->upper = cur->upper; + } - PG_RETURN_POINTER( out ); + PG_RETURN_POINTER(out); } Datum gint4_penalty(PG_FUNCTION_ARGS) { - INT4KEY *origentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); - INT4KEY *newentry = (INT4KEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key ); - float *result = (float*) PG_GETARG_POINTER(2); - - *result = Max( newentry->upper - origentry->upper, 0 ) + - Max( origentry->lower - newentry->lower, 0 ); - - PG_RETURN_POINTER( result ); + INT4KEY *origentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + INT4KEY *newentry = (INT4KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + + *result = Max(newentry->upper - origentry->upper, 0) + + Max(origentry->lower - newentry->lower, 0); + + PG_RETURN_POINTER(result); } Datum gint4_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER( btree_picksplit( - (bytea*)PG_GETARG_POINTER(0), - (GIST_SPLITVEC*)PG_GETARG_POINTER(1), - gint4_binary_union, - int4key_cmp - ) ); + PG_RETURN_POINTER(btree_picksplit( + (bytea *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + gint4_binary_union, + int4key_cmp + )); } Datum gint4_same(PG_FUNCTION_ARGS) { - INT4KEY *b1 = (INT4KEY*) PG_GETARG_POINTER(0); - INT4KEY *b2 = (INT4KEY*) PG_GETARG_POINTER(1); - bool *result = (bool*) PG_GETARG_POINTER(2); + INT4KEY *b1 = (INT4KEY *) PG_GETARG_POINTER(0); + INT4KEY *b2 = (INT4KEY *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); - *result = ( b1->lower == b2->lower && b1->upper == b2->upper ) ? TRUE : FALSE; - PG_RETURN_POINTER(result); + *result = (b1->lower == b2->lower && b1->upper == b2->upper) ? TRUE : FALSE; + PG_RETURN_POINTER(result); } -static void +static void gint4_binary_union(Datum *r1, char *r2) { - INT4KEY *b1; - INT4KEY *b2 = (INT4KEY*) r2; - if ( ! DatumGetPointer( *r1 ) ) { - *r1 = PointerGetDatum( palloc( sizeof(INT4KEY) ) ); - b1 = (INT4KEY*)DatumGetPointer( *r1 ); - b1->upper = b2->upper; - b1->lower = b2->lower; - } else { - b1 = (INT4KEY*)DatumGetPointer( *r1 ); - - b1->lower = ( b1->lower > b2->lower ) ? - b2->lower : b1->lower; - b1->upper = ( b1->upper > b2->upper ) ? - b1->upper : b2->upper; - } + INT4KEY *b1; + INT4KEY *b2 = (INT4KEY *) r2; + + if (!DatumGetPointer(*r1)) + { + *r1 = PointerGetDatum(palloc(sizeof(INT4KEY))); + b1 = (INT4KEY *) DatumGetPointer(*r1); + b1->upper = b2->upper; + b1->lower = b2->lower; + } + else + { + b1 = (INT4KEY *) DatumGetPointer(*r1); + + b1->lower = (b1->lower > b2->lower) ? + b2->lower : b1->lower; + b1->upper = (b1->upper > b2->upper) ? + b1->upper : b2->upper; + } } -static int -int4key_cmp(const void *a, const void *b) { - return ( ((INT4KEY*)(((RIX*)a)->r))->lower - ((INT4KEY*)(((RIX*)b)->r))->lower ); +static int +int4key_cmp(const void *a, const void *b) +{ + return (((INT4KEY *) (((RIX *) a)->r))->lower - ((INT4KEY *) (((RIX *) b)->r))->lower); } /************************************************** * timestamp ops - **************************************************/ + **************************************************/ Datum gts_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); - GISTENTRY *retval; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; + + if (entry->leafkey) + { + TSKEY *r = (TSKEY *) palloc(sizeof(TSKEY)); - if ( entry->leafkey) { - TSKEY *r = (TSKEY *)palloc( sizeof(TSKEY) ); retval = palloc(sizeof(GISTENTRY)); - if ( entry->key ) { - r->lower = r->upper = *(Timestamp*)(entry->key); + if (entry->key) + { + r->lower = r->upper = *(Timestamp *) (entry->key); gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, entry->offset, sizeof(TSKEY), FALSE); - } else { + } + else + { gistentryinit(*retval, PointerGetDatum(NULL), entry->rel, entry->page, entry->offset, 0, FALSE); - } - } else { - retval = entry; + } } - PG_RETURN_POINTER( retval ); + else + retval = entry; + PG_RETURN_POINTER(retval); } -Datum +Datum gts_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); - Timestamp *query = (Timestamp *)PG_GETARG_POINTER(1); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool retval; - TSKEY *key; - /* - ** if entry is not leaf, use gbox_internal_consistent, - ** else use gbox_leaf_consistent - */ - if ( ! entry->key ) - return FALSE; - key = (TSKEY*) DatumGetPointer(entry->key); - - switch(strategy) { - case BTLessEqualStrategyNumber: - retval = TSGE( query, &(key->lower) ); - break; - case BTLessStrategyNumber: - if (GIST_LEAF(entry)) - retval = TSGT( query, &(key->lower) ); - else - retval = TSGE( query, &(key->lower) ); - break; - case BTEqualStrategyNumber: - /* in leaf page key->lower always = key->upper */ - if (GIST_LEAF(entry)) - retval = TSEQ( query, &(key->lower)); - else - retval = ( TSLE( &(key->lower), query ) && TSLE( query, &(key->upper) ) ); - break; - case BTGreaterStrategyNumber: - if (GIST_LEAF(entry)) - retval = TSLT( query, &(key->upper) ); - else - retval = TSLE( query, &(key->upper) ); - break; - case BTGreaterEqualStrategyNumber: - retval = TSLE( query, &(key->upper) ); - break; - default: - retval = FALSE; - } - PG_RETURN_BOOL(retval); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Timestamp *query = (Timestamp *) PG_GETARG_POINTER(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool retval; + TSKEY *key; + + /* + * * if entry is not leaf, use gbox_internal_consistent, * else use + * gbox_leaf_consistent + */ + if (!entry->key) + return FALSE; + key = (TSKEY *) DatumGetPointer(entry->key); + + switch (strategy) + { + case BTLessEqualStrategyNumber: + retval = TSGE(query, &(key->lower)); + break; + case BTLessStrategyNumber: + if (GIST_LEAF(entry)) + retval = TSGT(query, &(key->lower)); + else + retval = TSGE(query, &(key->lower)); + break; + case BTEqualStrategyNumber: + /* in leaf page key->lower always = key->upper */ + if (GIST_LEAF(entry)) + retval = TSEQ(query, &(key->lower)); + else + retval = (TSLE(&(key->lower), query) && TSLE(query, &(key->upper))); + break; + case BTGreaterStrategyNumber: + if (GIST_LEAF(entry)) + retval = TSLT(query, &(key->upper)); + else + retval = TSLE(query, &(key->upper)); + break; + case BTGreaterEqualStrategyNumber: + retval = TSLE(query, &(key->upper)); + break; + default: + retval = FALSE; + } + PG_RETURN_BOOL(retval); } Datum gts_union(PG_FUNCTION_ARGS) { - bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); - int i, numranges; - TSKEY *cur, *out=palloc(sizeof(TSKEY)); - - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - *(int*) PG_GETARG_POINTER(1) = sizeof(TSKEY); - - cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[0].key) ); - out->lower = cur->lower; - out->upper = cur->upper; - - for (i = 1; i < numranges; i++) { - cur = (TSKEY *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) ); - if ( TSGT( &out->lower, &cur->lower ) ) out->lower = cur->lower; - if ( TSLT( &out->upper, &cur->upper ) ) out->upper = cur->upper; - } + bytea *entryvec = (bytea *) PG_GETARG_POINTER(0); + int i, + numranges; + TSKEY *cur, + *out = palloc(sizeof(TSKEY)); + + numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY); + *(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY); + + cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key)); + out->lower = cur->lower; + out->upper = cur->upper; + + for (i = 1; i < numranges; i++) + { + cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key)); + if (TSGT(&out->lower, &cur->lower)) + out->lower = cur->lower; + if (TSLT(&out->upper, &cur->upper)) + out->upper = cur->upper; + } - PG_RETURN_POINTER( out ); + PG_RETURN_POINTER(out); } Datum gts_penalty(PG_FUNCTION_ARGS) { - TSKEY *origentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(0))->key ); - TSKEY *newentry = (TSKEY*) DatumGetPointer( ((GISTENTRY*) PG_GETARG_POINTER(1))->key ); - float *result = (float*) PG_GETARG_POINTER(2); - Interval *intr; + TSKEY *origentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + TSKEY *newentry = (TSKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key); + float *result = (float *) PG_GETARG_POINTER(2); + Interval *intr; - intr = DatumGetIntervalP( DirectFunctionCall2( - timestamp_mi, - TimestampGetDatum( newentry->upper ), - TimestampGetDatum( origentry->upper )) ); + intr = DatumGetIntervalP(DirectFunctionCall2( + timestamp_mi, + TimestampGetDatum(newentry->upper), + TimestampGetDatum(origentry->upper))); /* see interval_larger */ - *result = Max( intr->time+intr->month * (30.0 * 86400),0 ); - pfree( intr ); - - intr = DatumGetIntervalP( DirectFunctionCall2( - timestamp_mi, - TimestampGetDatum( origentry->lower ), - TimestampGetDatum( newentry->lower )) ); + *result = Max(intr->time + intr->month * (30.0 * 86400), 0); + pfree(intr); + + intr = DatumGetIntervalP(DirectFunctionCall2( + timestamp_mi, + TimestampGetDatum(origentry->lower), + TimestampGetDatum(newentry->lower))); /* see interval_larger */ - *result += Max( intr->time+intr->month * (30.0 * 86400),0 ); - pfree( intr ); - - PG_RETURN_POINTER( result ); + *result += Max(intr->time + intr->month * (30.0 * 86400), 0); + pfree(intr); + + PG_RETURN_POINTER(result); } Datum gts_picksplit(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER( btree_picksplit( - (bytea*)PG_GETARG_POINTER(0), - (GIST_SPLITVEC*)PG_GETARG_POINTER(1), - gts_binary_union, - tskey_cmp - ) ); + PG_RETURN_POINTER(btree_picksplit( + (bytea *) PG_GETARG_POINTER(0), + (GIST_SPLITVEC *) PG_GETARG_POINTER(1), + gts_binary_union, + tskey_cmp + )); } Datum gts_same(PG_FUNCTION_ARGS) { - TSKEY *b1 = (TSKEY*) PG_GETARG_POINTER(0); - TSKEY *b2 = (TSKEY*) PG_GETARG_POINTER(1); - - bool *result = (bool*) PG_GETARG_POINTER(2); - if ( b1 && b2 ) - *result = ( TSEQ( &(b1->lower), &(b2->lower) ) && TSEQ( &(b1->upper), &(b2->upper) ) ) ? TRUE : FALSE; - else - *result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; - PG_RETURN_POINTER(result); + TSKEY *b1 = (TSKEY *) PG_GETARG_POINTER(0); + TSKEY *b2 = (TSKEY *) PG_GETARG_POINTER(1); + + bool *result = (bool *) PG_GETARG_POINTER(2); + + if (b1 && b2) + *result = (TSEQ(&(b1->lower), &(b2->lower)) && TSEQ(&(b1->upper), &(b2->upper))) ? TRUE : FALSE; + else + *result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE; + PG_RETURN_POINTER(result); } -static void +static void gts_binary_union(Datum *r1, char *r2) { - TSKEY *b1; - TSKEY *b2 = (TSKEY*) r2; - - if ( ! DatumGetPointer( *r1 ) ) { - *r1 = PointerGetDatum( palloc( sizeof(TSKEY) ) ); - b1 = (TSKEY*)DatumGetPointer( *r1 ); - b1->upper = b2->upper; - b1->lower = b2->lower; - } else { - b1 = (TSKEY*)DatumGetPointer( *r1 ); - - b1->lower = ( TSGT( &b1->lower, &b2->lower) ) ? - b2->lower : b1->lower; - b1->upper = ( TSGT( &b1->upper, &b2->upper) ) ? - b1->upper : b2->upper; - } + TSKEY *b1; + TSKEY *b2 = (TSKEY *) r2; + + if (!DatumGetPointer(*r1)) + { + *r1 = PointerGetDatum(palloc(sizeof(TSKEY))); + b1 = (TSKEY *) DatumGetPointer(*r1); + b1->upper = b2->upper; + b1->lower = b2->lower; + } + else + { + b1 = (TSKEY *) DatumGetPointer(*r1); + + b1->lower = (TSGT(&b1->lower, &b2->lower)) ? + b2->lower : b1->lower; + b1->upper = (TSGT(&b1->upper, &b2->upper)) ? + b1->upper : b2->upper; + } } -static int -tskey_cmp(const void *a, const void *b) { - return DatumGetInt32( - DirectFunctionCall2( - timestamp_cmp, - TimestampGetDatum( ((TSKEY*)(((RIX*)a)->r))->lower ), - TimestampGetDatum( ((TSKEY*)(((RIX*)b)->r))->lower ) - ) - ); +static int +tskey_cmp(const void *a, const void *b) +{ + return DatumGetInt32( + DirectFunctionCall2( + timestamp_cmp, + TimestampGetDatum(((TSKEY *) (((RIX *) a)->r))->lower), + TimestampGetDatum(((TSKEY *) (((RIX *) b)->r))->lower) + ) + ); } /************************************************** @@ -466,43 +499,48 @@ tskey_cmp(const void *a, const void *b) { static GIST_SPLITVEC * btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp) { - OffsetNumber i; - RIX *array; - OffsetNumber maxoff; - int nbytes; - - maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1; - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - v->spl_left = (OffsetNumber *) palloc(nbytes); - v->spl_right = (OffsetNumber *) palloc(nbytes); - v->spl_nleft = 0; - v->spl_nright = 0; - v->spl_ldatum = PointerGetDatum( 0 ); - v->spl_rdatum = PointerGetDatum( 0 ); - array = (RIX*)palloc( sizeof(RIX) * (maxoff+1) ); - - /* copy the data into RIXes, and sort the RIXes */ - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - array[i].index = i; - array[i].r=(char *)DatumGetPointer( (((GISTENTRY *)(VARDATA(entryvec)))[i].key) ); - } - qsort((void*)&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, - sizeof(RIX), cmp); - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - if (i <= (maxoff - FirstOffsetNumber + 1)/2) { - v->spl_left[ v->spl_nleft ] = array[i].index; - v->spl_nleft++; - (*bu)( &v->spl_ldatum, array[i].r ); - } else { - v->spl_right[ v->spl_nright ] = array[i].index; - v->spl_nright++; - (*bu)( &v->spl_rdatum, array[i].r ); - } - } - pfree(array); - - return( v ); + OffsetNumber i; + RIX *array; + OffsetNumber maxoff; + int nbytes; + + maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1; + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + v->spl_left = (OffsetNumber *) palloc(nbytes); + v->spl_right = (OffsetNumber *) palloc(nbytes); + v->spl_nleft = 0; + v->spl_nright = 0; + v->spl_ldatum = PointerGetDatum(0); + v->spl_rdatum = PointerGetDatum(0); + array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1)); + + /* copy the data into RIXes, and sort the RIXes */ + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + array[i].index = i; + array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key)); + } + qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, + sizeof(RIX), cmp); + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + v->spl_left[v->spl_nleft] = array[i].index; + v->spl_nleft++; + (*bu) (&v->spl_ldatum, array[i].r); + } + else + { + v->spl_right[v->spl_nright] = array[i].index; + v->spl_nright++; + (*bu) (&v->spl_rdatum, array[i].r); + } + } + pfree(array); + + return (v); } /* @@ -512,38 +550,44 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp) Datum btree_decompress(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER(PG_GETARG_POINTER(0)); + PG_RETURN_POINTER(PG_GETARG_POINTER(0)); } /************************************************** * In/Out for keys, not really needed **************************************************/ -Datum -int4key_in(PG_FUNCTION_ARGS) { - INT4KEY *key = palloc(sizeof(INT4KEY)); +Datum +int4key_in(PG_FUNCTION_ARGS) +{ + INT4KEY *key = palloc(sizeof(INT4KEY)); - if ( sscanf( PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2 ) + if (sscanf(PG_GETARG_POINTER(0), "%d|%d", &(key->lower), &(key->upper)) != 2) elog(ERROR, "Error in input format"); - - PG_RETURN_POINTER( key ); + + PG_RETURN_POINTER(key); } -Datum int4key_out(PG_FUNCTION_ARGS) { - INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0); - char *str=palloc(sizeof(char)*22); - sprintf(str,"%d|%d", key->lower, key->upper); - PG_RETURN_POINTER( str ); +Datum +int4key_out(PG_FUNCTION_ARGS) +{ + INT4KEY *key = (INT4KEY *) PG_GETARG_POINTER(0); + char *str = palloc(sizeof(char) * 22); + + sprintf(str, "%d|%d", key->lower, key->upper); + PG_RETURN_POINTER(str); } Datum -tskey_in(PG_FUNCTION_ARGS) { +tskey_in(PG_FUNCTION_ARGS) +{ elog(ERROR, "Not implemented"); - PG_RETURN_POINTER( NULL ); + PG_RETURN_POINTER(NULL); } Datum -tskey_out(PG_FUNCTION_ARGS) { +tskey_out(PG_FUNCTION_ARGS) +{ elog(ERROR, "Not implemented"); - PG_RETURN_POINTER( NULL ); + PG_RETURN_POINTER(NULL); } diff --git a/contrib/chkpass/chkpass.c b/contrib/chkpass/chkpass.c index 2c5974162b..c7c3197c92 100644 --- a/contrib/chkpass/chkpass.c +++ b/contrib/chkpass/chkpass.c @@ -4,7 +4,7 @@ * http://www.druid.net/darcy/ * - * $Id: chkpass.c,v 1.4 2001/05/30 02:11:46 darcy Exp $ + * $Id: chkpass.c,v 1.5 2001/10/25 05:49:19 momjian Exp $ * best viewed with tabs set to 4 */ @@ -31,7 +31,7 @@ typedef struct chkpass { - char password[16]; + char password[16]; } chkpass; /* @@ -62,12 +62,12 @@ PG_FUNCTION_INFO_V1(chkpass_in) Datum chkpass_in(PG_FUNCTION_ARGS) { - char *str = PG_GETARG_CSTRING(0); - chkpass *result; + char *str = PG_GETARG_CSTRING(0); + chkpass *result; char mysalt[4]; - static bool random_initialized = false; + static bool random_initialized = false; static char salt_chars[] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; /* special case to let us enter encrypted passwords */ if (*str == ':') @@ -81,7 +81,7 @@ chkpass_in(PG_FUNCTION_ARGS) if (verify_pass(str) != 0) { elog(ERROR, "chkpass_in: purported CHKPASS \"%s\" is a weak password", - str); + str); PG_RETURN_POINTER(NULL); } @@ -159,17 +159,18 @@ Datum chkpass_eq(PG_FUNCTION_ARGS) { chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0); - text *a2 = (text *) PG_GETARG_TEXT_P(1); - char str[10]; - int sz = 8; + text *a2 = (text *) PG_GETARG_TEXT_P(1); + char str[10]; + int sz = 8; if (!a1 || !a2) PG_RETURN_BOOL(0); - if (a2->vl_len < 12) sz = a2->vl_len - 4; + if (a2->vl_len < 12) + sz = a2->vl_len - 4; strncpy(str, a2->vl_dat, sz); str[sz] = 0; - PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) == 0); + PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) == 0); } PG_FUNCTION_INFO_V1(chkpass_ne) @@ -177,14 +178,15 @@ Datum chkpass_ne(PG_FUNCTION_ARGS) { chkpass *a1 = (chkpass *) PG_GETARG_POINTER(0); - text *a2 = (text *) PG_GETARG_TEXT_P(1); - char str[10]; - int sz = 8; + text *a2 = (text *) PG_GETARG_TEXT_P(1); + char str[10]; + int sz = 8; - if (!a1 || !a2) PG_RETURN_BOOL(0); - if (a2->vl_len < 12) sz = a2->vl_len - 4; + if (!a1 || !a2) + PG_RETURN_BOOL(0); + if (a2->vl_len < 12) + sz = a2->vl_len - 4; strncpy(str, a2->vl_dat, sz); str[sz] = 0; - PG_RETURN_BOOL (strcmp(a1->password, crypt(str, a1->password)) != 0); + PG_RETURN_BOOL(strcmp(a1->password, crypt(str, a1->password)) != 0); } - diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c index 72f6e5a069..c97e86d3b4 100644 --- a/contrib/cube/cube.c +++ b/contrib/cube/cube.c @@ -166,7 +166,6 @@ g_cube_consistent(GISTENTRY *entry, NDBOX * query, StrategyNumber strategy) { - /* * if entry is not leaf, use g_cube_internal_consistent, else use * g_cube_leaf_consistent @@ -206,7 +205,7 @@ g_cube_union(bytea *entryvec, int *sizep) for (i = 1; i < numranges; i++) { out = g_cube_binary_union(tmp, (NDBOX *) - DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key), + DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key), sizep); if (i > 1) pfree(tmp); @@ -220,13 +219,13 @@ g_cube_union(bytea *entryvec, int *sizep) ** GiST Compress and Decompress methods for boxes ** do not do anything. */ -GISTENTRY * +GISTENTRY * g_cube_compress(GISTENTRY *entry) { return (entry); } -GISTENTRY * +GISTENTRY * g_cube_decompress(GISTENTRY *entry) { return (entry); @@ -365,7 +364,6 @@ g_cube_picksplit(bytea *entryvec, maxoff = OffsetNumberNext(maxoff); for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - /* * If we've already decided where to place this item, just put it * on the right list. Otherwise, we need to figure out which page @@ -1001,7 +999,6 @@ cube_contains(NDBOX * box_a, NDBOX * box_b) if (a->dim < b->dim) { - /* * the further comparisons will make sense if the excess * dimensions of (b) were zeroes diff --git a/contrib/dbase/dbf.c b/contrib/dbase/dbf.c index 9ed0c475d1..053e9adffb 100644 --- a/contrib/dbase/dbf.c +++ b/contrib/dbase/dbf.c @@ -21,159 +21,171 @@ /* open a dbf-file, get it's field-info and store this information */ -dbhead *dbf_open(u_char *file, int flags) { - int file_no; - dbhead *dbh; - f_descr *fields; - dbf_header *head; - dbf_field *fieldc; +dbhead * +dbf_open(u_char *file, int flags) +{ + int file_no; + dbhead *dbh; + f_descr *fields; + dbf_header *head; + dbf_field *fieldc; int t; - if ((dbh = (dbhead *)malloc(sizeof(dbhead))) == NULL) { - return (dbhead *)DBF_ERROR; - } + if ((dbh = (dbhead *) malloc(sizeof(dbhead))) == NULL) + return (dbhead *) DBF_ERROR; - if ((head = (dbf_header *)malloc(sizeof(dbf_header))) == NULL) { + if ((head = (dbf_header *) malloc(sizeof(dbf_header))) == NULL) + { free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } - if ((fieldc = (dbf_field *)malloc(sizeof(dbf_field))) == NULL) { + if ((fieldc = (dbf_field *) malloc(sizeof(dbf_field))) == NULL) + { free(head); free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } - if ((file_no = open(file, flags)) == -1) { + if ((file_no = open(file, flags)) == -1) + { free(fieldc); free(head); free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } /* read in the disk-header */ - if (read(file_no, head, sizeof(dbf_header)) == -1) { + if (read(file_no, head, sizeof(dbf_header)) == -1) + { close(file_no); free(fieldc); free(head); free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } - if (!(head->dbh_dbt & DBH_NORMAL)) { - close(file_no); - free(fieldc); - free(head); - free(dbh); - return (dbhead *)DBF_ERROR; + if (!(head->dbh_dbt & DBH_NORMAL)) + { + close(file_no); + free(fieldc); + free(head); + free(dbh); + return (dbhead *) DBF_ERROR; } dbh->db_fd = file_no; - if (head->dbh_dbt & DBH_MEMO) { + if (head->dbh_dbt & DBH_MEMO) dbh->db_memo = 1; - } else { + else dbh->db_memo = 0; - } dbh->db_year = head->dbh_year; dbh->db_month = head->dbh_month; dbh->db_day = head->dbh_day; - dbh->db_hlen = get_short((u_char *)&head->dbh_hlen); - dbh->db_records = get_long((u_char *)&head->dbh_records); + dbh->db_hlen = get_short((u_char *) &head->dbh_hlen); + dbh->db_records = get_long((u_char *) &head->dbh_records); dbh->db_currec = 0; - dbh->db_rlen = get_short((u_char *)&head->dbh_rlen); + dbh->db_rlen = get_short((u_char *) &head->dbh_rlen); dbh->db_nfields = (dbh->db_hlen - sizeof(dbf_header)) / sizeof(dbf_field); - /* dbh->db_hlen - sizeof(dbf_header) isn't the - correct size, cos dbh->hlen is in fact - a little more cos of the 0x0D (and - possibly another byte, 0x4E, I have - seen this somewhere). Because of rounding - everything turns out right :) */ - - if ((fields = (f_descr *)calloc(dbh->db_nfields, sizeof(f_descr))) - == NULL) { - close(file_no); - free(fieldc); - free(head); - free(dbh); - return (dbhead *)DBF_ERROR; + /* + * dbh->db_hlen - sizeof(dbf_header) isn't the correct size, cos + * dbh->hlen is in fact a little more cos of the 0x0D (and possibly + * another byte, 0x4E, I have seen this somewhere). Because of + * rounding everything turns out right :) + */ + + if ((fields = (f_descr *) calloc(dbh->db_nfields, sizeof(f_descr))) + == NULL) + { + close(file_no); + free(fieldc); + free(head); + free(dbh); + return (dbhead *) DBF_ERROR; } - for (t = 0; t < dbh->db_nfields; t++) { + for (t = 0; t < dbh->db_nfields; t++) + { /* Maybe I have calculated the number of fields incorrectly. This can happen when programs reserve lots of space at the end of the header for future - expansion. This will catch this situation */ - if (fields[t].db_name[0] == 0x0D) { + expansion. This will catch this situation */ + if (fields[t].db_name[0] == 0x0D) + { dbh->db_nfields = t; break; } read(file_no, fieldc, sizeof(dbf_field)); strncpy(fields[t].db_name, fieldc->dbf_name, DBF_NAMELEN); - fields[t].db_type = fieldc->dbf_type; + fields[t].db_type = fieldc->dbf_type; fields[t].db_flen = fieldc->dbf_flen; - fields[t].db_dec = fieldc->dbf_dec; + fields[t].db_dec = fieldc->dbf_dec; } dbh->db_offset = dbh->db_hlen; dbh->db_fields = fields; - if ((dbh->db_buff = (u_char *)malloc(dbh->db_rlen)) == NULL) { - return (dbhead *)DBF_ERROR; - } + if ((dbh->db_buff = (u_char *) malloc(dbh->db_rlen)) == NULL) + return (dbhead *) DBF_ERROR; - free(fieldc); - free(head); + free(fieldc); + free(head); return dbh; } -int dbf_write_head(dbhead *dbh) { +int +dbf_write_head(dbhead * dbh) +{ dbf_header head; - time_t now; - struct tm *dbf_time; + time_t now; + struct tm *dbf_time; - if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) { + if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) return DBF_ERROR; - } /* fill up the diskheader */ /* Set dataarea of head to '\0' */ - memset(&head,'\0',sizeof(dbf_header)); + memset(&head, '\0', sizeof(dbf_header)); head.dbh_dbt = DBH_NORMAL; - if (dbh->db_memo) head.dbh_dbt = DBH_MEMO; + if (dbh->db_memo) + head.dbh_dbt = DBH_MEMO; - now = time((time_t *)NULL); + now = time((time_t *) NULL); dbf_time = localtime(&now); head.dbh_year = dbf_time->tm_year; - head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */ + head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + + * 1 */ head.dbh_day = dbf_time->tm_mday; put_long(head.dbh_records, dbh->db_records); put_short(head.dbh_hlen, dbh->db_hlen); put_short(head.dbh_rlen, dbh->db_rlen); - + if (write(dbh->db_fd, &head, sizeof(dbf_header)) != sizeof(dbf_header)) return DBF_ERROR; return 0; } -int dbf_put_fields(dbhead *dbh) { +int +dbf_put_fields(dbhead * dbh) +{ dbf_field field; u_long t; u_char end = 0x0D; - if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) { + if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) return DBF_ERROR; - } /* Set dataarea of field to '\0' */ - memset(&field,'\0',sizeof(dbf_field)); + memset(&field, '\0', sizeof(dbf_field)); - for (t = 0; t < dbh->db_nfields; t++) { + for (t = 0; t < dbh->db_nfields; t++) + { strncpy(field.dbf_name, dbh->db_fields[t].db_name, DBF_NAMELEN - 1); field.dbf_type = dbh->db_fields[t].db_type; field.dbf_flen = dbh->db_fields[t].db_flen; @@ -189,16 +201,18 @@ int dbf_put_fields(dbhead *dbh) { return 0; } -int dbf_add_field(dbhead *dbh, u_char *name, u_char type, - u_char length, u_char dec) { -f_descr *ptr; -u_char *foo; -u_long size, field_no; +int +dbf_add_field(dbhead * dbh, u_char *name, u_char type, + u_char length, u_char dec) +{ + f_descr *ptr; + u_char *foo; + u_long size, + field_no; size = (dbh->db_nfields + 1) * sizeof(f_descr); - if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) { + if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) return DBF_ERROR; - } dbh->db_fields = ptr; field_no = dbh->db_nfields; @@ -211,71 +225,81 @@ u_long size, field_no; dbh->db_hlen += sizeof(dbf_field); dbh->db_rlen += length; - if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) { + if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) return DBF_ERROR; - } dbh->db_buff = foo; return 0; } -dbhead *dbf_open_new(u_char *name, int flags) { -dbhead *dbh; +dbhead * +dbf_open_new(u_char *name, int flags) +{ + dbhead *dbh; - if (!(dbh = (dbhead *)malloc(sizeof(dbhead)))) { - return (dbhead *)DBF_ERROR; - } + if (!(dbh = (dbhead *) malloc(sizeof(dbhead)))) + return (dbhead *) DBF_ERROR; - if (flags & O_CREAT) { - if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) { + if (flags & O_CREAT) + { + if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) + { free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } - } else { - if ((dbh->db_fd = open(name, flags)) == -1) { + } + else + { + if ((dbh->db_fd = open(name, flags)) == -1) + { free(dbh); - return (dbhead *)DBF_ERROR; + return (dbhead *) DBF_ERROR; } } - + dbh->db_offset = 0; dbh->db_memo = 0; dbh->db_year = 0; dbh->db_month = 0; - dbh->db_day = 0; + dbh->db_day = 0; dbh->db_hlen = sizeof(dbf_header) + 1; dbh->db_records = 0; dbh->db_currec = 0; dbh->db_rlen = 1; dbh->db_nfields = 0; dbh->db_buff = NULL; - dbh->db_fields = (f_descr *)NULL; + dbh->db_fields = (f_descr *) NULL; return dbh; } - -void dbf_close(dbhead *dbh) { - int t; + +void +dbf_close(dbhead * dbh) +{ + int t; close(dbh->db_fd); - for (t = 0; t < dbh->db_nfields; t++) { + for (t = 0; t < dbh->db_nfields; t++) free(&dbh->db_fields[t]); - } - if (dbh->db_buff != NULL) { + if (dbh->db_buff != NULL) free(dbh->db_buff); - } free(dbh); } - -int dbf_get_record(dbhead *dbh, field *fields, u_long rec) { - u_char *data; - int t, i, offset; - u_char *dbffield, *end; + +int +dbf_get_record(dbhead * dbh, field * fields, u_long rec) +{ + u_char *data; + int t, + i, + offset; + u_char *dbffield, + *end; /* calculate at which offset we have to read. *DON'T* forget the 0x0D which seperates field-descriptions from records! @@ -284,112 +308,133 @@ int dbf_get_record(dbhead *dbh, field *fields, u_long rec) { */ offset = dbh->db_hlen + (rec * dbh->db_rlen); - if (lseek(dbh->db_fd, offset, SEEK_SET) == -1) { + if (lseek(dbh->db_fd, offset, SEEK_SET) == -1) + { lseek(dbh->db_fd, 0, SEEK_SET); dbh->db_offset = 0; return DBF_ERROR; } - dbh->db_offset = offset; - dbh->db_currec = rec; + dbh->db_offset = offset; + dbh->db_currec = rec; data = dbh->db_buff; - read(dbh->db_fd, data, dbh->db_rlen); - - if (data[0] == DBF_DELETED) { - return DBF_DELETED; - } - - dbffield = &data[1]; - for (t = 0; t < dbh->db_nfields; t++) { - strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN); - fields[t].db_type = dbh->db_fields[t].db_type; - fields[t].db_flen = dbh->db_fields[t].db_flen; - fields[t].db_dec = dbh->db_fields[t].db_dec; - - if (fields[t].db_type == 'C') { - end = &dbffield[fields[t].db_flen - 1 ]; - i = fields[t].db_flen; - while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) { - end--; - i--; - } - strncpy(fields[t].db_contents, dbffield, i); - fields[t].db_contents[i] = '\0'; - } else { - end = dbffield; - i = fields[t].db_flen; - while (( i > 0) && ((*end < 0x21) || (*end > 0x7E))) { - end++; - i--; - } - strncpy(fields[t].db_contents, end, i); - fields[t].db_contents[i] = '\0'; - } + read(dbh->db_fd, data, dbh->db_rlen); + + if (data[0] == DBF_DELETED) + return DBF_DELETED; + + dbffield = &data[1]; + for (t = 0; t < dbh->db_nfields; t++) + { + strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN); + fields[t].db_type = dbh->db_fields[t].db_type; + fields[t].db_flen = dbh->db_fields[t].db_flen; + fields[t].db_dec = dbh->db_fields[t].db_dec; + + if (fields[t].db_type == 'C') + { + end = &dbffield[fields[t].db_flen - 1]; + i = fields[t].db_flen; + while ((i > 0) && ((*end < 0x21) || (*end > 0x7E))) + { + end--; + i--; + } + strncpy(fields[t].db_contents, dbffield, i); + fields[t].db_contents[i] = '\0'; + } + else + { + end = dbffield; + i = fields[t].db_flen; + while ((i > 0) && ((*end < 0x21) || (*end > 0x7E))) + { + end++; + i--; + } + strncpy(fields[t].db_contents, end, i); + fields[t].db_contents[i] = '\0'; + } - dbffield += fields[t].db_flen; + dbffield += fields[t].db_flen; } - dbh->db_offset += dbh->db_rlen; + dbh->db_offset += dbh->db_rlen; return DBF_VALID; } -field *dbf_build_record(dbhead *dbh) { - int t; - field *fields; +field * +dbf_build_record(dbhead * dbh) +{ + int t; + field *fields; - if (!(fields = (field *)calloc(dbh->db_nfields, sizeof(field)))) { - return (field *)DBF_ERROR; - } - - for ( t = 0; t < dbh->db_nfields; t++) { + if (!(fields = (field *) calloc(dbh->db_nfields, sizeof(field)))) + return (field *) DBF_ERROR; + + for (t = 0; t < dbh->db_nfields; t++) + { if (!(fields[t].db_contents = - (u_char *)malloc(dbh->db_fields[t].db_flen + 1))) { - for (t = 0; t < dbh->db_nfields; t++) { - if (fields[t].db_contents != 0) { + (u_char *) malloc(dbh->db_fields[t].db_flen + 1))) + { + for (t = 0; t < dbh->db_nfields; t++) + { + if (fields[t].db_contents != 0) + { free(fields[t].db_contents); free(fields); } - return (field *)DBF_ERROR; + return (field *) DBF_ERROR; } } strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN); fields[t].db_type = dbh->db_fields[t].db_type; fields[t].db_flen = dbh->db_fields[t].db_flen; - fields[t].db_dec = dbh->db_fields[t].db_dec; + fields[t].db_dec = dbh->db_fields[t].db_dec; } return fields; } -void dbf_free_record(dbhead *dbh, field *rec) { - int t; +void +dbf_free_record(dbhead * dbh, field * rec) +{ + int t; - for ( t = 0; t < dbh->db_nfields; t++) { + for (t = 0; t < dbh->db_nfields; t++) free(rec[t].db_contents); - } free(rec); } -int dbf_put_record(dbhead *dbh, field *rec, u_long where) { - u_long offset, new, idx, t, h, length; - u_char *data, end = 0x1a; - double fl; - u_char foo[128], format[32]; - -/* offset: offset in file for this record +int +dbf_put_record(dbhead * dbh, field * rec, u_long where) +{ + u_long offset, + new, + idx, + t, + h, + length; + u_char *data, + end = 0x1a; + double fl; + u_char foo[128], + format[32]; + +/* offset: offset in file for this record new: real offset after lseek idx: index to which place we are inside the 'hardcore'-data for this record t: field-counter data: the hardcore-data that is put on disk h: index into the field-part in the hardcore-data - length: length of the data to copy + length: length of the data to copy fl: a float used to get the right precision with real numbers foo: copy of db_contents when field is not 'C' - format: sprintf format-string to get the right precision with real numbers + format: sprintf format-string to get the right precision with real numbers NOTE: this declaration of 'foo' can cause overflow when the contents-field is longer the 127 chars (which is highly unlikely, cos it is not used @@ -399,16 +444,17 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) { DO A SEEK_END WITH 0!!!!!! USE -1 !!!!!!!!!! */ - if (where > dbh->db_records) { - if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1) { + if (where > dbh->db_records) + { + if ((new = lseek(dbh->db_fd, -1, SEEK_END)) == -1) return DBF_ERROR; - } dbh->db_records++; - } else { + } + else + { offset = dbh->db_hlen + (where * dbh->db_rlen); - if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1) { + if ((new = lseek(dbh->db_fd, offset, SEEK_SET)) == -1) return DBF_ERROR; - } } dbh->db_offset = new; @@ -416,49 +462,54 @@ int dbf_put_record(dbhead *dbh, field *rec, u_long where) { data = dbh->db_buff; /* Set dataarea of data to ' ' (space) */ - memset(data,' ',dbh->db_rlen); + memset(data, ' ', dbh->db_rlen); /* data[0] = DBF_VALID; */ idx = 1; - for (t = 0; t < dbh->db_nfields; t++) { + for (t = 0; t < dbh->db_nfields; t++) + { /* if field is empty, don't do a thing */ - if (rec[t].db_contents[0] != '\0') { + if (rec[t].db_contents[0] != '\0') + { /* Handle text */ - if (rec[t].db_type == 'C') { - if (strlen(rec[t].db_contents) > rec[t].db_flen) { - length = rec[t].db_flen; - } else { - length = strlen(rec[t].db_contents); + if (rec[t].db_type == 'C') + { + if (strlen(rec[t].db_contents) > rec[t].db_flen) + length = rec[t].db_flen; + else + length = strlen(rec[t].db_contents); + strncpy(data + idx, rec[t].db_contents, length); } - strncpy(data+idx, rec[t].db_contents, length); - } else { + else + { /* Handle the rest */ /* Numeric is special, because of real numbers */ - if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0)) { - fl = atof(rec[t].db_contents); - sprintf(format, "%%.%df", rec[t].db_dec); - sprintf(foo, format, fl); - } else { - strcpy(foo, rec[t].db_contents); - } - if (strlen(foo) > rec[t].db_flen) { - length = rec[t].db_flen; - } else { - length = strlen(foo); + if ((rec[t].db_type == 'N') && (rec[t].db_dec != 0)) + { + fl = atof(rec[t].db_contents); + sprintf(format, "%%.%df", rec[t].db_dec); + sprintf(foo, format, fl); + } + else + strcpy(foo, rec[t].db_contents); + if (strlen(foo) > rec[t].db_flen) + length = rec[t].db_flen; + else + length = strlen(foo); + h = rec[t].db_flen - length; + strncpy(data + idx + h, foo, length); } - h = rec[t].db_flen - length; - strncpy(data+idx+h, foo, length); } - } - idx += rec[t].db_flen; + idx += rec[t].db_flen; } if (write(dbh->db_fd, data, dbh->db_rlen) != dbh->db_rlen) return DBF_ERROR; /* There's a 0x1A at the end of a dbf-file */ - if (where == dbh->db_records) { + if (where == dbh->db_records) + { if (write(dbh->db_fd, &end, 1) != 1) return DBF_ERROR; } diff --git a/contrib/dbase/dbf.h b/contrib/dbase/dbf.h index a6e92517ea..b54093bace 100644 --- a/contrib/dbase/dbf.h +++ b/contrib/dbase/dbf.h @@ -26,7 +26,7 @@ /* maximum fieldname-length */ -#define DBF_NAMELEN 11 +#define DBF_NAMELEN 11 /* magic-cookies for the file */ @@ -37,89 +37,93 @@ #define DBF_ERROR -1 #define DBF_VALID 0x20 -#define DBF_DELETED 0x2A +#define DBF_DELETED 0x2A /* diskheader */ -typedef struct { - u_char dbh_dbt; /* indentification field */ - u_char dbh_year; /* last modification-date */ - u_char dbh_month; - u_char dbh_day; - u_char dbh_records[4]; /* number of records */ - u_char dbh_hlen[2]; /* length of this header */ - u_char dbh_rlen[2]; /* length of a record */ - u_char dbh_stub[20]; /* misc stuff we don't need */ -} dbf_header; +typedef struct +{ + u_char dbh_dbt; /* indentification field */ + u_char dbh_year; /* last modification-date */ + u_char dbh_month; + u_char dbh_day; + u_char dbh_records[4]; /* number of records */ + u_char dbh_hlen[2]; /* length of this header */ + u_char dbh_rlen[2]; /* length of a record */ + u_char dbh_stub[20]; /* misc stuff we don't need */ +} dbf_header; /* disk field-description */ -typedef struct { - u_char dbf_name[DBF_NAMELEN]; /* field-name terminated with \0 */ - u_char dbf_type; /* field-type */ - u_char dbf_reserved[4]; /* some reserved stuff */ - u_char dbf_flen; /* field-length */ - u_char dbf_dec; /* number of decimal positions if - type is 'N' */ - u_char dbf_stub[14]; /* stuff we don't need */ -} dbf_field; +typedef struct +{ + u_char dbf_name[DBF_NAMELEN]; /* field-name terminated with \0 */ + u_char dbf_type; /* field-type */ + u_char dbf_reserved[4]; /* some reserved stuff */ + u_char dbf_flen; /* field-length */ + u_char dbf_dec; /* number of decimal positions if type is + * 'N' */ + u_char dbf_stub[14]; /* stuff we don't need */ +} dbf_field; /* memory field-description */ -typedef struct { - u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */ - u_char db_type; /* field-type */ - u_char db_flen; /* field-length */ - u_char db_dec; /* number of decimal positions */ -} f_descr; +typedef struct +{ + u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */ + u_char db_type; /* field-type */ + u_char db_flen; /* field-length */ + u_char db_dec; /* number of decimal positions */ +} f_descr; /* memory dfb-header */ -typedef struct { - int db_fd; /* file-descriptor */ - u_long db_offset; /* current offset in file */ - u_char db_memo; /* memo-file present */ - u_char db_year; /* last update as YYMMDD */ - u_char db_month; - u_char db_day; - u_long db_hlen; /* length of the diskheader, for - calculating the offsets */ - u_long db_records; /* number of records */ - u_long db_currec; /* current record-number starting - at 0 */ - u_short db_rlen; /* length of the record */ - u_char db_nfields; /* number of fields */ - u_char *db_buff; /* record-buffer to save malloc()'s */ - f_descr *db_fields; /* pointer to an array of field- - descriptions */ -} dbhead; +typedef struct +{ + int db_fd; /* file-descriptor */ + u_long db_offset; /* current offset in file */ + u_char db_memo; /* memo-file present */ + u_char db_year; /* last update as YYMMDD */ + u_char db_month; + u_char db_day; + u_long db_hlen; /* length of the diskheader, for + * calculating the offsets */ + u_long db_records; /* number of records */ + u_long db_currec; /* current record-number starting at 0 */ + u_short db_rlen; /* length of the record */ + u_char db_nfields; /* number of fields */ + u_char *db_buff; /* record-buffer to save malloc()'s */ + f_descr *db_fields; /* pointer to an array of field- + * descriptions */ +} dbhead; /* structure that contains everything a user wants from a field, including the contents (in ASCII). Warning! db_flen may be bigger than the actual length of db_name! This is because a field doesn't have to be completely filled */ - -typedef struct { - u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */ - u_char db_type; /* field-type */ - u_char db_flen; /* field-length */ - u_char db_dec; /* number of decimal positions */ - u_char* db_contents; /* contents of the field in ASCII */ -} field; + +typedef struct +{ + u_char db_name[DBF_NAMELEN]; /* field-name terminated with \0 */ + u_char db_type; /* field-type */ + u_char db_flen; /* field-length */ + u_char db_dec; /* number of decimal positions */ + u_char *db_contents; /* contents of the field in ASCII */ +} field; /* prototypes for functions */ -extern dbhead* dbf_open(u_char *file ,int flags); -extern int dbf_write_head(dbhead *dbh); -extern int dbf_put_fields(dbhead *dbh); -extern int dbf_add_field(dbhead *dbh, u_char *name, u_char type, - u_char length, u_char dec); -extern dbhead * dbf_open_new(u_char *name, int flags); -extern void dbf_close(dbhead *dbh); -extern int dbf_get_record(dbhead *dbh, field *fields, u_long rec); -extern field* dbf_build_record(dbhead *dbh); -extern void dbf_free_record(dbhead *dbh, field* fields); -extern int dbf_put_record(dbhead *dbh, field *rec, u_long where); +extern dbhead *dbf_open(u_char *file, int flags); +extern int dbf_write_head(dbhead * dbh); +extern int dbf_put_fields(dbhead * dbh); +extern int dbf_add_field(dbhead * dbh, u_char *name, u_char type, + u_char length, u_char dec); +extern dbhead *dbf_open_new(u_char *name, int flags); +extern void dbf_close(dbhead * dbh); +extern int dbf_get_record(dbhead * dbh, field * fields, u_long rec); +extern field *dbf_build_record(dbhead * dbh); +extern void dbf_free_record(dbhead * dbh, field * fields); +extern int dbf_put_record(dbhead * dbh, field * rec, u_long where); /********************************************************************* @@ -131,5 +135,4 @@ extern long get_long(u_char *cp); extern void put_long(u_char *cp, long lval); extern short get_short(u_char *cp); extern void put_short(u_char *cp, short lval); - -#endif /* _DBF_H */ +#endif /* _DBF_H */ diff --git a/contrib/dbase/dbf2pg.c b/contrib/dbase/dbf2pg.c index 839bb7211f..e2393de542 100644 --- a/contrib/dbase/dbf2pg.c +++ b/contrib/dbase/dbf2pg.c @@ -22,146 +22,178 @@ #include "libpq-fe.h" #include "dbf.h" -int verbose = 0, upper = 0, lower = 0, create = 0, fieldlow = 0; -int del = 0; -unsigned int begin = 0, end = 0; +int verbose = 0, + upper = 0, + lower = 0, + create = 0, + fieldlow = 0; +int del = 0; +unsigned int begin = 0, + end = 0; unsigned int t_block = 0; #ifdef HAVE_ICONV_H -char *charset_from=NULL; -char *charset_to="ISO-8859-1"; -iconv_t iconv_d; -char convert_charset_buff[8192]; +char *charset_from = NULL; +char *charset_to = "ISO-8859-1"; +iconv_t iconv_d; +char convert_charset_buff[8192]; #endif -char *host = NULL; -char *dbase = "test"; -char *table = "test"; -char *username = NULL; -char *password = NULL; -char *subarg = NULL; -char escape_buff[8192]; +char *host = NULL; +char *dbase = "test"; +char *table = "test"; +char *username = NULL; +char *password = NULL; +char *subarg = NULL; +char escape_buff[8192]; -void do_substitute(char *subarg, dbhead *dbh); +void do_substitute(char *subarg, dbhead * dbh); inline void strtoupper(char *string); inline void strtolower(char *string); -void do_create(PGconn *, char*, dbhead*); -void do_inserts(PGconn *, char*, dbhead*); -int check_table(PGconn *, char*); +void do_create(PGconn *, char *, dbhead *); +void do_inserts(PGconn *, char *, dbhead *); +int check_table(PGconn *, char *); + +char *Escape(char *); -char *Escape(char*); #ifdef HAVE_ICONV_H -char *convert_charset(char *string); +char *convert_charset(char *string); #endif -void usage(void); +void usage(void); unsigned int isinteger(char *); -char *simple_prompt(const char *prompt, int maxlen, bool echo); +char *simple_prompt(const char *prompt, int maxlen, bool echo); -unsigned int isinteger(char *buff) { - char *i=buff; +unsigned int +isinteger(char *buff) +{ + char *i = buff; - while (*i != '\0') { - if (i==buff) + while (*i != '\0') + { + if (i == buff) if ((*i == '-') || - (*i == '+')) { - i++; continue; + (*i == '+')) + { + i++; + continue; } - if (!isdigit((int)*i)) return 0; + if (!isdigit((int) *i)) + return 0; i++; } return 1; } -inline void strtoupper(char *string) { - while(*string != '\0') { +inline void +strtoupper(char *string) +{ + while (*string != '\0') + { *string = toupper(*string); string++; } } -inline void strtolower(char *string) { - while(*string != '\0') { +inline void +strtolower(char *string) +{ + while (*string != '\0') + { *string = tolower(*string); string++; } } /* FIXME: should this check for overflow? */ -char *Escape(char *string) { - char *foo, *bar; - - foo = escape_buff; - - bar = string; - while (*bar != '\0') { - if ((*bar == '\t') || - (*bar == '\n') || - (*bar == '\\')) { - *foo++ = '\\'; - } - *foo++ = *bar++; - } - *foo = '\0'; - - return escape_buff; -} +char * +Escape(char *string) +{ + char *foo, + *bar; -#ifdef HAVE_ICONV_H -char *convert_charset(char *string) { - size_t in_size, out_size, nconv; - char *in_ptr,*out_ptr; + foo = escape_buff; - in_size=strlen(string)+1; - out_size=sizeof(convert_charset_buff); - in_ptr=string; - out_ptr=convert_charset_buff; + bar = string; + while (*bar != '\0') + { + if ((*bar == '\t') || + (*bar == '\n') || + (*bar == '\\')) + *foo++ = '\\'; + *foo++ = *bar++; + } + *foo = '\0'; + + return escape_buff; +} - iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset state information */ - while(in_size>0) +#ifdef HAVE_ICONV_H +char * +convert_charset(char *string) +{ + size_t in_size, + out_size, + nconv; + char *in_ptr, + *out_ptr; + + in_size = strlen(string) + 1; + out_size = sizeof(convert_charset_buff); + in_ptr = string; + out_ptr = convert_charset_buff; + + iconv(iconv_d, NULL, &in_size, &out_ptr, &out_size); /* necessary to reset + * state information */ + while (in_size > 0) { nconv = iconv(iconv_d, &in_ptr, &in_size, &out_ptr, &out_size); - if(nconv == (size_t) -1) + if (nconv == (size_t) -1) { printf("WARNING: cannot convert charset of string \"%s\".\n", - string); - strcpy(convert_charset_buff,string); + string); + strcpy(convert_charset_buff, string); return convert_charset_buff; } } - *out_ptr = 0; /* terminate output string */ + *out_ptr = 0; /* terminate output string */ return convert_charset_buff; } #endif -int check_table(PGconn *conn, char *table) { - char *q = "select relname from pg_class where " - "relkind='r' and relname !~* '^pg'"; - PGresult *res; - int i = 0; +int +check_table(PGconn *conn, char *table) +{ + char *q = "select relname from pg_class where " + "relkind='r' and relname !~* '^pg'"; + PGresult *res; + int i = 0; - if (!(res = PQexec(conn, q))) { + if (!(res = PQexec(conn, q))) + { printf("%s\n", PQerrorMessage(conn)); return 0; } - for (i = 0; i < PQntuples(res); i++) { - if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) { + for (i = 0; i < PQntuples(res); i++) + { + if (!strcmp(table, PQgetvalue(res, i, PQfnumber(res, "relname")))) return 1; - } } return 0; } -void usage(void){ +void +usage(void) +{ printf("dbf2pg\n" -"usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n" -" [-B transaction_size] [-F charset_from [-T charset_to]]\n" -" [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n" -" [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n"); + "usage: dbf2pg [-u | -l] [-h hostname] [-W] [-U username]\n" + " [-B transaction_size] [-F charset_from [-T charset_to]]\n" + " [-s oldname=newname[,oldname=newname[...]]] [-d dbase]\n" + " [-t table] [-c | -D] [-f] [-v[v]] dbf-file\n"); } /* patch submitted by Jeffrey Y. Sue <[email protected]> */ @@ -169,66 +201,80 @@ void usage(void){ /* Mainly for avoiding conflicts between fieldnames and SQL-reserved */ /* keywords */ -void do_substitute(char *subarg, dbhead *dbh) +void +do_substitute(char *subarg, dbhead * dbh) { - /* NOTE: subarg is modified in this function */ - int i,bad; - char *p,*oldname,*newname; - if (!subarg) { - return; - } - if (verbose>1) { - printf("Substituting new field names\n"); - } - /* use strstr instead of strtok because of possible empty tokens */ - oldname = subarg; - while (oldname && strlen(oldname) && (p=strstr(oldname,"=")) ) { - *p = '\0'; /* mark end of oldname */ - newname = ++p; /* point past \0 of oldname */ - if (strlen(newname)) { /* if not an empty string */ - p = strstr(newname,","); - if (p) { - *p = '\0'; /* mark end of newname */ - p++; /* point past where the comma was */ - } - } - if (strlen(newname)>=DBF_NAMELEN) { - printf("Truncating new field name %s to %d chars\n", - newname,DBF_NAMELEN-1); - newname[DBF_NAMELEN-1] = '\0'; - } - bad = 1; - for (i=0;i<dbh->db_nfields;i++) { - if (strcmp(dbh->db_fields[i].db_name,oldname)==0) { - bad = 0; - strcpy(dbh->db_fields[i].db_name,newname); - if (verbose>1) { - printf("Substitute old:%s new:%s\n", - oldname,newname); - } - break; - } - } - if (bad) { - printf("Warning: old field name %s not found\n", - oldname); - } - oldname = p; - } -} /* do_substitute */ - -void do_create(PGconn *conn, char *table, dbhead *dbh) { - char *query; - char t[20]; - int i, length; - PGresult *res; - - if (verbose > 1) { - printf("Building CREATE-clause\n"); + /* NOTE: subarg is modified in this function */ + int i, + bad; + char *p, + *oldname, + *newname; + + if (!subarg) + return; + if (verbose > 1) + printf("Substituting new field names\n"); + /* use strstr instead of strtok because of possible empty tokens */ + oldname = subarg; + while (oldname && strlen(oldname) && (p = strstr(oldname, "="))) + { + *p = '\0'; /* mark end of oldname */ + newname = ++p; /* point past \0 of oldname */ + if (strlen(newname)) + { /* if not an empty string */ + p = strstr(newname, ","); + if (p) + { + *p = '\0'; /* mark end of newname */ + p++; /* point past where the comma was */ + } + } + if (strlen(newname) >= DBF_NAMELEN) + { + printf("Truncating new field name %s to %d chars\n", + newname, DBF_NAMELEN - 1); + newname[DBF_NAMELEN - 1] = '\0'; + } + bad = 1; + for (i = 0; i < dbh->db_nfields; i++) + { + if (strcmp(dbh->db_fields[i].db_name, oldname) == 0) + { + bad = 0; + strcpy(dbh->db_fields[i].db_name, newname); + if (verbose > 1) + { + printf("Substitute old:%s new:%s\n", + oldname, newname); + } + break; + } + } + if (bad) + { + printf("Warning: old field name %s not found\n", + oldname); + } + oldname = p; } +} /* do_substitute */ - if (!(query = (char *)malloc( - (dbh->db_nfields * 40) + 29 + strlen(table)))) { +void +do_create(PGconn *conn, char *table, dbhead * dbh) +{ + char *query; + char t[20]; + int i, + length; + PGresult *res; + + if (verbose > 1) + printf("Building CREATE-clause\n"); + + if (!(query = (char *) malloc( + (dbh->db_nfields * 40) + 29 + strlen(table)))) + { fprintf(stderr, "Memory allocation error in function do_create\n"); PQfinish(conn); close(dbh->db_fd); @@ -238,61 +284,65 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) { sprintf(query, "CREATE TABLE %s (", table); length = strlen(query); - for ( i = 0; i < dbh->db_nfields; i++) { - if (!strlen(dbh->db_fields[i].db_name)) { - continue; - /* skip field if length of name == 0 */ - } - if ((strlen(query) != length)) { - strcat(query, ","); - } - - if (fieldlow) - strtolower(dbh->db_fields[i].db_name); - - strcat(query, dbh->db_fields[i].db_name); - switch(dbh->db_fields[i].db_type) { - case 'D': - strcat(query, " date"); - break; - case 'C': - if (dbh->db_fields[i].db_flen > 1) { - strcat(query, " varchar"); - sprintf(t, "(%d)", - dbh->db_fields[i].db_flen); - strcat(query, t); - } else { - strcat(query, " char"); - } - break; - case 'N': - if (dbh->db_fields[i].db_dec != 0) { - strcat(query, " real"); - } else { - strcat(query, " int"); - } - break; - case 'L': - strcat(query, " char"); - break; - } + for (i = 0; i < dbh->db_nfields; i++) + { + if (!strlen(dbh->db_fields[i].db_name)) + { + continue; + /* skip field if length of name == 0 */ + } + if ((strlen(query) != length)) + strcat(query, ","); + + if (fieldlow) + strtolower(dbh->db_fields[i].db_name); + + strcat(query, dbh->db_fields[i].db_name); + switch (dbh->db_fields[i].db_type) + { + case 'D': + strcat(query, " date"); + break; + case 'C': + if (dbh->db_fields[i].db_flen > 1) + { + strcat(query, " varchar"); + sprintf(t, "(%d)", + dbh->db_fields[i].db_flen); + strcat(query, t); + } + else + strcat(query, " char"); + break; + case 'N': + if (dbh->db_fields[i].db_dec != 0) + strcat(query, " real"); + else + strcat(query, " int"); + break; + case 'L': + strcat(query, " char"); + break; + } } strcat(query, ")"); - if (verbose > 1) { + if (verbose > 1) + { printf("Sending create-clause\n"); printf("%s\n", query); } - if ((res = PQexec(conn, query)) == NULL) { + if ((res = PQexec(conn, query)) == NULL) + { fprintf(stderr, "Error creating table!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - close(dbh->db_fd); - free(dbh); - free(query); - PQfinish(conn); - exit(1); + close(dbh->db_fd); + free(dbh); + free(query); + PQfinish(conn); + exit(1); } PQclear(res); @@ -300,148 +350,179 @@ void do_create(PGconn *conn, char *table, dbhead *dbh) { } /* FIXME: can be optimized to not use strcat, but it is worth the effort? */ -void do_inserts(PGconn *conn, char *table, dbhead *dbh) { - PGresult *res; - field *fields; - int i, h, result; - char *query, *foo; +void +do_inserts(PGconn *conn, char *table, dbhead * dbh) +{ + PGresult *res; + field *fields; + int i, + h, + result; + char *query, + *foo; char pgdate[10]; - if (verbose > 1) { + if (verbose > 1) printf("Inserting records\n"); - } - h = 2; /* 2 because of terminating \n\0 */ + h = 2; /* 2 because of terminating \n\0 */ - for ( i = 0 ; i < dbh->db_nfields ; i++ ) { + for (i = 0; i < dbh->db_nfields; i++) + { h += dbh->db_fields[i].db_flen > 2 ? - dbh->db_fields[i].db_flen : - 2; /* account for possible NULL values (\N) */ - h += 1; /* the delimiter */ + dbh->db_fields[i].db_flen : + 2; /* account for possible NULL values (\N) */ + h += 1; /* the delimiter */ } - /* make sure we can build the COPY query, note that we don't need to just - add this value, since the COPY query is a separate query (see below) */ - if (h < 17+strlen(table)) h = 17+strlen(table); + /* + * make sure we can build the COPY query, note that we don't need to + * just add this value, since the COPY query is a separate query (see + * below) + */ + if (h < 17 + strlen(table)) + h = 17 + strlen(table); - if (!(query = (char *)malloc(h))) { + if (!(query = (char *) malloc(h))) + { PQfinish(conn); fprintf(stderr, - "Memory allocation error in function do_inserts (query)\n"); + "Memory allocation error in function do_inserts (query)\n"); close(dbh->db_fd); free(dbh); exit(1); } - if ((fields = dbf_build_record(dbh)) == (field *)DBF_ERROR) { - fprintf(stderr, - "Couldn't allocate memory for record in do_insert\n"); + if ((fields = dbf_build_record(dbh)) == (field *) DBF_ERROR) + { + fprintf(stderr, + "Couldn't allocate memory for record in do_insert\n"); PQfinish(conn); - free(query); - dbf_close(dbh); - exit(1); - } - - if (end == 0) /* "end" is a user option, if not specified, */ - end = dbh->db_records; /* then all records are processed. */ - - if (t_block == 0) /* user not specified transaction block size */ - t_block = end-begin; /* then we set it to be the full data */ - - for (i = begin; i < end; i++) { + free(query); + dbf_close(dbh); + exit(1); + } + + if (end == 0) /* "end" is a user option, if not + * specified, */ + end = dbh->db_records; /* then all records are processed. */ + + if (t_block == 0) /* user not specified transaction block + * size */ + t_block = end - begin; /* then we set it to be the full data */ + + for (i = begin; i < end; i++) + { /* we need to start a new transaction and COPY statement */ - if (((i-begin) % t_block) == 0) { + if (((i - begin) % t_block) == 0) + { if (verbose > 1) fprintf(stderr, "Transaction: START\n"); res = PQexec(conn, "BEGIN"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error starting transaction!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - exit(1); + exit(1); } sprintf(query, "COPY %s FROM stdin", table); res = PQexec(conn, query); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error starting COPY!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); - exit(1); + exit(1); } } /* build line and submit */ - result = dbf_get_record(dbh, fields, i); - if (result == DBF_VALID) { + result = dbf_get_record(dbh, fields, i); + if (result == DBF_VALID) + { query[0] = '\0'; - for (h = 0; h < dbh->db_nfields; h++) { - if (!strlen(fields[h].db_name)) { + for (h = 0; h < dbh->db_nfields; h++) + { + if (!strlen(fields[h].db_name)) continue; - } - if (h!=0) /* not for the first field! */ - strcat(query, "\t"); /* COPY statement field separator */ + if (h != 0) /* not for the first field! */ + strcat(query, "\t"); /* COPY statement field + * separator */ - if (upper) { - strtoupper(fields[h].db_contents); - } - if (lower) { + if (upper) + strtoupper(fields[h].db_contents); + if (lower) strtolower(fields[h].db_contents); - } foo = fields[h].db_contents; #ifdef HAVE_ICONV_H - if(charset_from) + if (charset_from) foo = convert_charset(foo); #endif foo = Escape(foo); /* handle the date first - liuk */ - if(fields[h].db_type=='D') { - if((strlen(foo)==8) && isinteger(foo)) { - sprintf(pgdate,"%c%c%c%c-%c%c-%c%c", - foo[0],foo[1],foo[2],foo[3], - foo[4],foo[5],foo[6],foo[7]); - strcat(query,pgdate); - } else { - /* empty field must be inserted as NULL value in this - way */ - strcat(query,"\\N"); + if (fields[h].db_type == 'D') + { + if ((strlen(foo) == 8) && isinteger(foo)) + { + sprintf(pgdate, "%c%c%c%c-%c%c-%c%c", + foo[0], foo[1], foo[2], foo[3], + foo[4], foo[5], foo[6], foo[7]); + strcat(query, pgdate); + } + else + { + /* + * empty field must be inserted as NULL value in + * this way + */ + strcat(query, "\\N"); } } else if ((fields[h].db_type == 'N') && - (fields[h].db_dec == 0)){ - if (isinteger(foo)) { + (fields[h].db_dec == 0)) + { + if (isinteger(foo)) strcat(query, foo); - } else { + else + { strcat(query, "\\N"); if (verbose) fprintf(stderr, "Illegal numeric value found " - "in record %d, field \"%s\"\n", - i, fields[h].db_name); + "in record %d, field \"%s\"\n", + i, fields[h].db_name); } - } else { + } + else + { strcat(query, foo); /* must be character */ } } strcat(query, "\n"); - if ((verbose > 1) && (( i % 100) == 0)) {/* Only show every 100 */ - printf("Inserting record %d\n", i); /* records. */ + if ((verbose > 1) && ((i % 100) == 0)) + { /* Only show every 100 */ + printf("Inserting record %d\n", i); /* records. */ } PQputline(conn, query); } /* we need to end this copy and transaction */ - if (((i-begin) % t_block) == t_block-1) { + if (((i - begin) % t_block) == t_block - 1) + { if (verbose > 1) fprintf(stderr, "Transaction: END\n"); PQputline(conn, "\\.\n"); - if (PQendcopy(conn) != 0) { + if (PQendcopy(conn) != 0) + { fprintf(stderr, "Something went wrong while copying. Check " - "your tables!\n"); + "your tables!\n"); exit(1); } res = PQexec(conn, "END"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error committing work!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); exit(1); @@ -451,17 +532,20 @@ void do_inserts(PGconn *conn, char *table, dbhead *dbh) { /* last row copied in, end copy and transaction */ /* remember, i is now 1 greater then when we left the loop */ - if (((i-begin) % t_block) != 0) { + if (((i - begin) % t_block) != 0) + { if (verbose > 1) fprintf(stderr, "Transaction: END\n"); PQputline(conn, "\\.\n"); - if (PQendcopy(conn) != 0) { + if (PQendcopy(conn) != 0) + { fprintf(stderr, "Something went wrong while copying. Check " - "your tables!\n"); + "your tables!\n"); } res = PQexec(conn, "END"); - if (res == NULL) { + if (res == NULL) + { fprintf(stderr, "Error committing work!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); exit(1); @@ -492,7 +576,9 @@ simple_prompt(const char *prompt, int maxlen, bool echo) { int length; char *destination; - FILE *termin, *termout; + FILE *termin, + *termout; + #ifdef HAVE_TERMIOS_H struct termios t_orig, t; @@ -505,8 +591,8 @@ simple_prompt(const char *prompt, int maxlen, bool echo) prompt_state = true; /* disable SIGINT */ /* - * Do not try to collapse these into one "w+" mode file. - * Doesn't work on some platforms (eg, HPUX 10.20). + * Do not try to collapse these into one "w+" mode file. Doesn't work + * on some platforms (eg, HPUX 10.20). */ termin = fopen("/dev/tty", "r"); termout = fopen("/dev/tty", "w"); @@ -529,7 +615,7 @@ simple_prompt(const char *prompt, int maxlen, bool echo) tcsetattr(fileno(termin), TCSAFLUSH, &t); } #endif - + if (prompt) { fputs(gettext(prompt), termout); @@ -579,19 +665,23 @@ simple_prompt(const char *prompt, int maxlen, bool echo) } -int main(int argc, char **argv) +int +main(int argc, char **argv) { - PGconn *conn; + PGconn *conn; int i; - extern int optind; - extern char *optarg; - char *query; - dbhead *dbh; + extern int optind; + extern char *optarg; + char *query; + dbhead *dbh; - while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) { - switch (i) { + while ((i = getopt(argc, argv, "DWflucvh:b:e:d:t:s:B:U:F:T:")) != EOF) + { + switch (i) + { case 'D': - if (create) { + if (create) + { usage(); printf("Can't use -c and -D at the same time!\n"); exit(1); @@ -599,32 +689,34 @@ int main(int argc, char **argv) del = 1; break; case 'W': - password=simple_prompt("Password: ",100,0); + password = simple_prompt("Password: ", 100, 0); break; case 'f': - fieldlow=1; + fieldlow = 1; break; case 'v': verbose++; break; case 'c': - if (del) { + if (del) + { usage(); printf("Can't use -c and -D at the same time!\n"); exit(1); } - create=1; + create = 1; break; case 'l': - lower=1; + lower = 1; break; case 'u': - if (lower) { + if (lower) + { usage(); printf("Can't use -u and -l at the same time!\n"); exit(1); } - upper=1; + upper = 1; break; case 'b': begin = atoi(optarg); @@ -633,28 +725,28 @@ int main(int argc, char **argv) end = atoi(optarg); break; case 'h': - host = (char *)strdup(optarg); + host = (char *) strdup(optarg); break; case 'd': - dbase = (char *)strdup(optarg); + dbase = (char *) strdup(optarg); break; case 't': - table = (char *)strdup(optarg); - break; + table = (char *) strdup(optarg); + break; case 's': - subarg = (char *)strdup(optarg); + subarg = (char *) strdup(optarg); break; case 'B': t_block = atoi(optarg); break; case 'U': - username = (char *)strdup(optarg); + username = (char *) strdup(optarg); break; case 'F': - charset_from = (char *)strdup(optarg); + charset_from = (char *) strdup(optarg); break; case 'T': - charset_to = (char *)strdup(optarg); + charset_to = (char *) strdup(optarg); break; case ':': usage(); @@ -663,7 +755,11 @@ int main(int argc, char **argv) break; case '?': usage(); - /* FIXME: Ivan thinks this is bad: printf("unknown argument: %s\n", argv[0]); */ + + /* + * FIXME: Ivan thinks this is bad: printf("unknown + * argument: %s\n", argv[0]); + */ exit(1); break; default: @@ -674,80 +770,83 @@ int main(int argc, char **argv) argc -= optind; argv = &argv[optind]; - if (argc != 1) { + if (argc != 1) + { usage(); - if(username) + if (username) free(username); - if(password) + if (password) free(password); exit(1); } #ifdef HAVE_ICONV_H - if(charset_from) + if (charset_from) { - if(verbose>1) + if (verbose > 1) printf("Setting conversion from charset \"%s\" to \"%s\".\n", - charset_from,charset_to); - iconv_d = iconv_open(charset_to,charset_from); - if(iconv_d == (iconv_t) -1) + charset_from, charset_to); + iconv_d = iconv_open(charset_to, charset_from); + if (iconv_d == (iconv_t) - 1) { printf("Cannot convert from charset \"%s\" to charset \"%s\".\n", - charset_from,charset_to); + charset_from, charset_to); exit(1); } } #endif - if (verbose > 1) { + if (verbose > 1) printf("Opening dbf-file\n"); - } - if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *)-1) { + if ((dbh = dbf_open(argv[0], O_RDONLY)) == (dbhead *) - 1) + { fprintf(stderr, "Couldn't open xbase-file %s\n", argv[0]); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } if (fieldlow) - for ( i = 0 ; i < dbh->db_nfields ; i++ ) - strtolower(dbh->db_fields[i].db_name); + for (i = 0; i < dbh->db_nfields; i++) + strtolower(dbh->db_fields[i].db_name); - if (verbose) { + if (verbose) + { printf("dbf-file: %s, PG-dbase: %s, PG-table: %s\n", argv[0], - dbase, - table); + dbase, + table); printf("Number of records: %ld\n", dbh->db_records); printf("NAME:\t\tLENGTH:\t\tTYPE:\n"); printf("-------------------------------------\n"); - for (i = 0; i < dbh->db_nfields ; i++) { - printf("%-12s\t%7d\t\t%5c\n",dbh->db_fields[i].db_name, - dbh->db_fields[i].db_flen, - dbh->db_fields[i].db_type); + for (i = 0; i < dbh->db_nfields; i++) + { + printf("%-12s\t%7d\t\t%5c\n", dbh->db_fields[i].db_name, + dbh->db_fields[i].db_flen, + dbh->db_fields[i].db_type); } } - if (verbose > 1) { + if (verbose > 1) printf("Making connection to PG-server\n"); - } - conn = PQsetdbLogin(host,NULL,NULL,NULL, dbase, username, password); - if (PQstatus(conn) != CONNECTION_OK) { + conn = PQsetdbLogin(host, NULL, NULL, NULL, dbase, username, password); + if (PQstatus(conn) != CONNECTION_OK) + { fprintf(stderr, "Couldn't get a connection with the "); fprintf(stderr, "designated host!\n"); fprintf(stderr, "Detailed report: %s\n", PQerrorMessage(conn)); close(dbh->db_fd); free(dbh); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } @@ -756,55 +855,60 @@ int main(int argc, char **argv) do_substitute(subarg, dbh); /* create table if specified, else check if target table exists */ - if (!create) { - if (!check_table(conn, table)) { + if (!create) + { + if (!check_table(conn, table)) + { printf("Table does not exist!\n"); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (del) { - if (!(query = (char *)malloc(13 + strlen(table)))) { + if (del) + { + if (!(query = (char *) malloc(13 + strlen(table)))) + { printf("Memory-allocation error in main (delete)!\n"); close(dbh->db_fd); free(dbh); PQfinish(conn); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (verbose > 1) { + if (verbose > 1) printf("Deleting from original table\n"); - } sprintf(query, "DELETE FROM %s", table); PQexec(conn, query); free(query); } - } else { - if (!(query = (char *)malloc(12 + strlen(table)))) { + } + else + { + if (!(query = (char *) malloc(12 + strlen(table)))) + { printf("Memory-allocation error in main (drop)!\n"); close(dbh->db_fd); free(dbh); PQfinish(conn); - if(username) + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(1); } - if (verbose > 1) { + if (verbose > 1) printf("Dropping original table (if one exists)\n"); - } sprintf(query, "DROP TABLE %s", table); PQexec(conn, query); free(query); @@ -819,18 +923,17 @@ int main(int argc, char **argv) PQexec(conn, "SET DATESTYLE TO 'ISO';"); do_inserts(conn, table, dbh); - if (verbose > 1) { + if (verbose > 1) printf("Closing up....\n"); - } - close(dbh->db_fd); - free(dbh); - PQfinish(conn); - if(username) + close(dbh->db_fd); + free(dbh); + PQfinish(conn); + if (username) free(username); - if(password) + if (password) free(password); - if(charset_from) + if (charset_from) iconv_close(iconv_d); exit(0); } diff --git a/contrib/dbase/endian.c b/contrib/dbase/endian.c index 55c53d8980..5bc6a186a0 100644 --- a/contrib/dbase/endian.c +++ b/contrib/dbase/endian.c @@ -5,41 +5,45 @@ /* * routine to change little endian long to host long */ -long get_long(u_char *cp) +long +get_long(u_char *cp) { - long ret; + long ret; - ret = *cp++; - ret += ((*cp++)<<8); - ret += ((*cp++)<<16); - ret += ((*cp++)<<24); + ret = *cp++; + ret += ((*cp++) << 8); + ret += ((*cp++) << 16); + ret += ((*cp++) << 24); - return ret; + return ret; } -void put_long(u_char *cp, long lval) +void +put_long(u_char *cp, long lval) { - cp[0] = lval & 0xff; - cp[1] = (lval >> 8) & 0xff; - cp[2] = (lval >> 16) & 0xff; - cp[3] = (lval >> 24) & 0xff; + cp[0] = lval & 0xff; + cp[1] = (lval >> 8) & 0xff; + cp[2] = (lval >> 16) & 0xff; + cp[3] = (lval >> 24) & 0xff; } /* * routine to change little endian short to host short */ -short get_short(u_char *cp) +short +get_short(u_char *cp) { - short ret; + short ret; - ret = *cp++; - ret += ((*cp++)<<8); + ret = *cp++; + ret += ((*cp++) << 8); - return ret; + return ret; } -void put_short(u_char *cp, short sval) +void +put_short(u_char *cp, short sval) { - cp[0] = sval & 0xff; - cp[1] = (sval >> 8) & 0xff; + cp[0] = sval & 0xff; + cp[1] = (sval >> 8) & 0xff; } diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index e858cfd0ba..4ab1315fa7 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -4,18 +4,18 @@ * Functions returning results from a remote database * * Copyright (c) Joseph Conway <[email protected]>, 2001; - * + * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without a written agreement * is hereby granted, provided that the above copyright notice and this * paragraph and the following two paragraphs appear in all copies. - * + * * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - * + * * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS @@ -30,29 +30,28 @@ PG_FUNCTION_INFO_V1(dblink); Datum dblink(PG_FUNCTION_ARGS) { - PGconn *conn = NULL; - PGresult *res = NULL; - dblink_results *results; - char *optstr; - char *sqlstatement; - char *curstr = "DECLARE mycursor CURSOR FOR "; - char *execstatement; - char *msg; - int ntuples = 0; - ReturnSetInfo *rsi; - - if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) { + PGconn *conn = NULL; + PGresult *res = NULL; + dblink_results *results; + char *optstr; + char *sqlstatement; + char *curstr = "DECLARE mycursor CURSOR FOR "; + char *execstatement; + char *msg; + int ntuples = 0; + ReturnSetInfo *rsi; + + if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) elog(ERROR, "dblink: NULL arguments are not permitted"); - } - if (fcinfo->resultinfo == NULL || ! IsA(fcinfo->resultinfo, ReturnSetInfo)) { + if (fcinfo->resultinfo == NULL || !IsA(fcinfo->resultinfo, ReturnSetInfo)) elog(ERROR, "dblink: function called in context that does not accept a set result"); - } optstr = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0)))); sqlstatement = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1)))); - if (fcinfo->flinfo->fn_extra == NULL) { + if (fcinfo->flinfo->fn_extra == NULL) + { conn = PQconnectdb(optstr); if (PQstatus(conn) == CONNECTION_BAD) @@ -73,13 +72,14 @@ dblink(PG_FUNCTION_ARGS) PQclear(res); execstatement = (char *) palloc(strlen(curstr) + strlen(sqlstatement) + 1); - if (execstatement != NULL) { + if (execstatement != NULL) + { strcpy(execstatement, curstr); strcat(execstatement, sqlstatement); strcat(execstatement, "\0"); - } else { - elog(ERROR, "dblink: insufficient memory" ); } + else + elog(ERROR, "dblink: insufficient memory"); res = PQexec(conn, execstatement); if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK)) @@ -88,23 +88,27 @@ dblink(PG_FUNCTION_ARGS) PQclear(res); PQfinish(conn); elog(ERROR, "dblink: sql error: %s", msg); - } else { + } + else + { /* * got results, start fetching them */ - PQclear(res); + PQclear(res); - res = PQexec(conn, "FETCH ALL in mycursor"); - if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) { + res = PQexec(conn, "FETCH ALL in mycursor"); + if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) + { msg = pstrdup(PQerrorMessage(conn)); PQclear(res); PQfinish(conn); elog(ERROR, "dblink: sql error: %s", msg); - } + } ntuples = PQntuples(res); - if (ntuples > 0) { + if (ntuples > 0) + { results = init_dblink_results(fcinfo->flinfo->fn_mcxt); results->tup_num = 0; @@ -116,44 +120,48 @@ dblink(PG_FUNCTION_ARGS) results = NULL; results = fcinfo->flinfo->fn_extra; - /* close the cursor */ - res = PQexec(conn, "CLOSE mycursor"); - PQclear(res); + /* close the cursor */ + res = PQexec(conn, "CLOSE mycursor"); + PQclear(res); - /* commit the transaction */ - res = PQexec(conn, "COMMIT"); - PQclear(res); + /* commit the transaction */ + res = PQexec(conn, "COMMIT"); + PQclear(res); - /* close the connection to the database and cleanup */ - PQfinish(conn); + /* close the connection to the database and cleanup */ + PQfinish(conn); - rsi = (ReturnSetInfo *)fcinfo->resultinfo; + rsi = (ReturnSetInfo *) fcinfo->resultinfo; rsi->isDone = ExprMultipleResult; PG_RETURN_POINTER(results); - } else { + } + else + { - PQclear(res); + PQclear(res); - /* close the cursor */ - res = PQexec(conn, "CLOSE mycursor"); - PQclear(res); + /* close the cursor */ + res = PQexec(conn, "CLOSE mycursor"); + PQclear(res); - /* commit the transaction */ - res = PQexec(conn, "COMMIT"); - PQclear(res); + /* commit the transaction */ + res = PQexec(conn, "COMMIT"); + PQclear(res); - /* close the connection to the database and cleanup */ - PQfinish(conn); + /* close the connection to the database and cleanup */ + PQfinish(conn); - rsi = (ReturnSetInfo *)fcinfo->resultinfo; - rsi->isDone = ExprEndResult ; + rsi = (ReturnSetInfo *) fcinfo->resultinfo; + rsi->isDone = ExprEndResult; PG_RETURN_NULL(); } } - } else { + } + else + { /* * check for more results */ @@ -162,29 +170,30 @@ dblink(PG_FUNCTION_ARGS) results->tup_num++; ntuples = PQntuples(results->res); - if (results->tup_num < ntuples) { - + if (results->tup_num < ntuples) + { /* * fetch them if available */ - rsi = (ReturnSetInfo *)fcinfo->resultinfo; + rsi = (ReturnSetInfo *) fcinfo->resultinfo; rsi->isDone = ExprMultipleResult; PG_RETURN_POINTER(results); - } else { - + } + else + { /* * or if no more, clean things up */ results = fcinfo->flinfo->fn_extra; - PQclear(results->res); + PQclear(results->res); - rsi = (ReturnSetInfo *)fcinfo->resultinfo; - rsi->isDone = ExprEndResult ; + rsi = (ReturnSetInfo *) fcinfo->resultinfo; + rsi->isDone = ExprEndResult; PG_RETURN_NULL(); } @@ -204,48 +213,48 @@ PG_FUNCTION_INFO_V1(dblink_tok); Datum dblink_tok(PG_FUNCTION_ARGS) { - dblink_results *results; - int fldnum; - text *result_text; - char *result; - int nfields = 0; - int text_len = 0; - - if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) { + dblink_results *results; + int fldnum; + text *result_text; + char *result; + int nfields = 0; + int text_len = 0; + + if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) elog(ERROR, "dblink: NULL arguments are not permitted"); - } results = (dblink_results *) PG_GETARG_POINTER(0); - if (results == NULL) { + if (results == NULL) elog(ERROR, "dblink: function called with invalid result pointer"); - } fldnum = PG_GETARG_INT32(1); - if (fldnum < 0) { + if (fldnum < 0) elog(ERROR, "dblink: field number < 0 not permitted"); - } nfields = PQnfields(results->res); - if (fldnum > (nfields - 1)) { + if (fldnum > (nfields - 1)) elog(ERROR, "dblink: field number %d does not exist", fldnum); - } - if (PQgetisnull(results->res, results->tup_num, fldnum) == 1) { + if (PQgetisnull(results->res, results->tup_num, fldnum) == 1) + { PG_RETURN_NULL(); - } else { + } + else + { text_len = PQgetlength(results->res, results->tup_num, fldnum); result = (char *) palloc(text_len + 1); - if (result != NULL) { + if (result != NULL) + { strcpy(result, PQgetvalue(results->res, results->tup_num, fldnum)); strcat(result, "\0"); - } else { - elog(ERROR, "dblink: insufficient memory" ); } + else + elog(ERROR, "dblink: insufficient memory"); result_text = DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(result))); @@ -267,8 +276,8 @@ dblink_tok(PG_FUNCTION_ARGS) dblink_results * init_dblink_results(MemoryContext fn_mcxt) { - MemoryContext oldcontext; - dblink_results *retval; + MemoryContext oldcontext; + dblink_results *retval; oldcontext = MemoryContextSwitchTo(fn_mcxt); diff --git a/contrib/dblink/dblink.h b/contrib/dblink/dblink.h index 1b2a48e9fb..f4de437e3d 100644 --- a/contrib/dblink/dblink.h +++ b/contrib/dblink/dblink.h @@ -4,18 +4,18 @@ * Functions returning results from a remote database * * Copyright (c) Joseph Conway <[email protected]>, 2001; - * + * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without a written agreement * is hereby granted, provided that the above copyright notice and this * paragraph and the following two paragraphs appear in all copies. - * + * * IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - * + * * THE AUTHOR AND DISTRIBUTORS SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS @@ -52,9 +52,9 @@ typedef struct /* * the actual query results */ - PGresult *res; + PGresult *res; -} dblink_results; +} dblink_results; /* * External declarations @@ -66,5 +66,4 @@ extern Datum dblink_tok(PG_FUNCTION_ARGS); * Internal declarations */ dblink_results *init_dblink_results(MemoryContext fn_mcxt); - #endif /* DBLINK_H */ diff --git a/contrib/fulltextindex/fti.c b/contrib/fulltextindex/fti.c index 8fd568d720..a259e4b08b 100644 --- a/contrib/fulltextindex/fti.c +++ b/contrib/fulltextindex/fti.c @@ -6,52 +6,52 @@ #include "commands/trigger.h" /* - * Trigger function accepts variable number of arguments: + * Trigger function accepts variable number of arguments: * * 1. relation in which to store the substrings * 2. fields to extract substrings from * - * The relation in which to insert *must* have the following layout: + * The relation in which to insert *must* have the following layout: * * string varchar(#) * id oid * - * where # is the largest size of the varchar columns being indexed + * where # is the largest size of the varchar columns being indexed * * Example: * - * -- Create the SQL function based on the compiled shared object - * create function fti() returns opaque as - * '/usr/local/pgsql/lib/contrib/fti.so' language 'C'; + * -- Create the SQL function based on the compiled shared object + * create function fti() returns opaque as + * '/usr/local/pgsql/lib/contrib/fti.so' language 'C'; * - * -- Create the FTI table - * create table product_fti (string varchar(255), id oid); + * -- Create the FTI table + * create table product_fti (string varchar(255), id oid); * - * -- Create an index to assist string matches - * create index product_fti_string_idx on product_fti (string); + * -- Create an index to assist string matches + * create index product_fti_string_idx on product_fti (string); * - * -- Create an index to assist trigger'd deletes - * create index product_fti_id_idx on product_fti (id); + * -- Create an index to assist trigger'd deletes + * create index product_fti_id_idx on product_fti (id); * - * -- Create an index on the product oid column to assist joins - * -- between the fti table and the product table - * create index product_oid_idx on product (oid); + * -- Create an index on the product oid column to assist joins + * -- between the fti table and the product table + * create index product_oid_idx on product (oid); * - * -- Create the trigger to perform incremental changes to the full text index. - * create trigger product_fti_trig after update or insert or delete on product - * for each row execute procedure fti(product_fti, title, artist); - * ^^^^^^^^^^^ - * table where full text index is stored - * ^^^^^^^^^^^^^ - * columns to index in the base table + * -- Create the trigger to perform incremental changes to the full text index. + * create trigger product_fti_trig after update or insert or delete on product + * for each row execute procedure fti(product_fti, title, artist); + * ^^^^^^^^^^^ + * table where full text index is stored + * ^^^^^^^^^^^^^ + * columns to index in the base table * - * After populating 'product', try something like: + * After populating 'product', try something like: * - * SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE + * SELECT DISTINCT(p.*) FROM product p, product_fti f1, product_fti f2 WHERE * f1.string ~ '^slippery' AND f2.string ~ '^wet' AND p.oid=f1.id AND p.oid=f2.id; * - * To check that your indicies are being used correctly, make sure you - * EXPLAIN SELECT ... your test query above. + * To check that your indicies are being used correctly, make sure you + * EXPLAIN SELECT ... your test query above. * * CHANGELOG * --------- @@ -76,14 +76,14 @@ * TODO * ---- * - * prevent generating duplicate words for an oid in the fti table - * save a plan for deletes - * create a function that will make the index *after* we have populated - * the main table (probably first delete all contents to be sure there's - * nothing in it, then re-populate the fti-table) + * prevent generating duplicate words for an oid in the fti table + * save a plan for deletes + * create a function that will make the index *after* we have populated + * the main table (probably first delete all contents to be sure there's + * nothing in it, then re-populate the fti-table) * - * can we do something with operator overloading or a seperate function - * that can build the final query automatigally? + * can we do something with operator overloading or a seperate function + * that can build the final query automatigally? */ #define MAX_FTI_QUERY_LENGTH 8192 @@ -103,16 +103,15 @@ char *StopWords[] = { /* list of words to skip in indexing */ "the", "yes" }; - -#endif /* USE_STOP_WORDS */ +#endif /* USE_STOP_WORDS */ /* stuff for caching query-plans, stolen from contrib/spi/\*.c */ typedef struct { - char *ident; - int nplans; - void **splan; -} EPlan; + char *ident; + int nplans; + void **splan; +} EPlan; static EPlan *InsertPlans = NULL; static EPlan *DeletePlans = NULL; @@ -201,13 +200,11 @@ fti(PG_FUNCTION_ARGS) Oid *argtypes; Datum values[1]; EPlan *plan; - int i; + int i; snprintf(query, MAX_FTI_QUERY_LENGTH, "D%s", indexname); for (i = 1; i < nargs; i++) - { snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]); - } plan = find_plan(query, &DeletePlans, &nDeletePlans); if (plan->nplans <= 0) @@ -238,23 +235,21 @@ fti(PG_FUNCTION_ARGS) if (isinsert) { - char *substring; - char *column; - void *pplan; - Oid *argtypes; + char *substring; + char *column; + void *pplan; + Oid *argtypes; Datum values[2]; int colnum; - struct varlena *data; - EPlan *plan; - int i; - char *buff; - char *string; + struct varlena *data; + EPlan *plan; + int i; + char *buff; + char *string; snprintf(query, MAX_FTI_QUERY_LENGTH, "I%s", indexname); for (i = 1; i < nargs; i++) - { snprintf(query, MAX_FTI_QUERY_LENGTH, "%s$%s", query, args[i]); - } plan = find_plan(query, &InsertPlans, &nInsertPlans); @@ -269,7 +264,7 @@ fti(PG_FUNCTION_ARGS) /* prepare plan to gain speed */ snprintf(query, MAX_FTI_QUERY_LENGTH, "INSERT INTO %s (string, id) VALUES ($1, $2)", - indexname); + indexname); pplan = SPI_prepare(query, 2, argtypes); if (!pplan) elog(ERROR, "Full Text Indexing: SPI_prepare: Returned NULL in insert"); @@ -303,7 +298,7 @@ fti(PG_FUNCTION_ARGS) string++; } - data = (struct varlena *) palloc(sizeof(int32) + strlen(column) + 1); + data = (struct varlena *) palloc(sizeof(int32) + strlen(column) +1); buff = palloc(strlen(column) + 1); /* saves lots of calls in while-loop and in breakup() */ @@ -348,7 +343,6 @@ breakup(char *string, char *substring) while (cur_pos > string) /* don't read before start of 'string' */ { - /* * skip pieces at the end of a string that are not alfa-numeric * (ie. 'string$%^&', last_start first points to '&', and after @@ -409,7 +403,7 @@ is_stopword(char *text) else StopHigh = StopMiddle; } -#endif /* USE_STOP_WORDS */ +#endif /* USE_STOP_WORDS */ return (false); } diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.c b/contrib/fuzzystrmatch/fuzzystrmatch.c index d6ec0f5c30..94b9e9de77 100644 --- a/contrib/fuzzystrmatch/fuzzystrmatch.c +++ b/contrib/fuzzystrmatch/fuzzystrmatch.c @@ -24,13 +24,13 @@ * documentation for any purpose, without fee, and without a written agreement * is hereby granted, provided that the above copyright notice and this * paragraph and the following two paragraphs appear in all copies. - * + * * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - * + * * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS @@ -50,23 +50,22 @@ PG_FUNCTION_INFO_V1(levenshtein); Datum levenshtein(PG_FUNCTION_ARGS) { - char *str_s; - char *str_s0; - char *str_t; - int cols = 0; - int rows = 0; - int *u_cells; - int *l_cells; - int *tmp; - int i; - int j; + char *str_s; + char *str_s0; + char *str_t; + int cols = 0; + int rows = 0; + int *u_cells; + int *l_cells; + int *tmp; + int i; + int j; /* - * Fetch the arguments. - * str_s is referred to as the "source" - * cols = length of source + 1 to allow for the initialization column - * str_t is referred to as the "target", rows = length of target + 1 - * rows = length of target + 1 to allow for the initialization row + * Fetch the arguments. str_s is referred to as the "source" cols = + * length of source + 1 to allow for the initialization column str_t + * is referred to as the "target", rows = length of target + 1 rows = + * length of target + 1 to allow for the initialization row */ str_s = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0)))); str_t = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(1)))); @@ -75,18 +74,19 @@ levenshtein(PG_FUNCTION_ARGS) rows = strlen(str_t) + 1; /* - * Restrict the length of the strings being compared to something reasonable - * because we will have to perform rows * cols calcualtions. If longer strings need to be - * compared, increase MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for - * speed and memory usage). + * Restrict the length of the strings being compared to something + * reasonable because we will have to perform rows * cols + * calcualtions. If longer strings need to be compared, increase + * MAX_LEVENSHTEIN_STRLEN to suit (but within your tolerance for speed + * and memory usage). */ if ((cols > MAX_LEVENSHTEIN_STRLEN + 1) || (rows > MAX_LEVENSHTEIN_STRLEN + 1)) elog(ERROR, "levenshtein: Arguments may not exceed %d characters in length", MAX_LEVENSHTEIN_STRLEN); /* - * If either rows or cols is 0, the answer is the other value. - * This makes sense since it would take that many insertions - * the build a matching string + * If either rows or cols is 0, the answer is the other value. This + * makes sense since it would take that many insertions the build a + * matching string */ if (cols == 0) @@ -96,8 +96,9 @@ levenshtein(PG_FUNCTION_ARGS) PG_RETURN_INT32(cols); /* - * Allocate two vectors of integers. One will be used for the "upper" row, - * the other for the "lower" row. Initialize the "upper" row to 0..cols + * Allocate two vectors of integers. One will be used for the "upper" + * row, the other for the "lower" row. Initialize the "upper" row to + * 0..cols */ u_cells = palloc(sizeof(int) * cols); for (i = 0; i < cols; i++) @@ -106,33 +107,35 @@ levenshtein(PG_FUNCTION_ARGS) l_cells = palloc(sizeof(int) * cols); /* - * Use str_s0 to "rewind" the pointer to str_s in the nested for loop below + * Use str_s0 to "rewind" the pointer to str_s in the nested for loop + * below */ str_s0 = str_s; /* - * Loop throught the rows, starting at row 1. Row 0 is used for the initial - * "upper" row. + * Loop throught the rows, starting at row 1. Row 0 is used for the + * initial "upper" row. */ for (j = 1; j < rows; j++) { /* - * We'll always start with col 1, - * and initialize lower row col 0 to j + * We'll always start with col 1, and initialize lower row col 0 + * to j */ l_cells[0] = j; for (i = 1; i < cols; i++) { - int c = 0; - int c1 = 0; - int c2 = 0; - int c3 = 0; + int c = 0; + int c1 = 0; + int c2 = 0; + int c3 = 0; /* - * The "cost" value is 0 if the character at the current col position - * in the source string, matches the character at the current row position - * in the target string; cost is 1 otherwise. + * The "cost" value is 0 if the character at the current col + * position in the source string, matches the character at the + * current row position in the target string; cost is 1 + * otherwise. */ c = ((CHAREQ(str_s, str_t)) ? 0 : 1); @@ -152,8 +155,7 @@ levenshtein(PG_FUNCTION_ARGS) c3 = u_cells[i - 1] + c; /* - * The lower right cell is set to the minimum - * of c1, c2, c3 + * The lower right cell is set to the minimum of c1, c2, c3 */ l_cells[i] = (c1 < c2 ? c1 : c2) < c3 ? (c1 < c2 ? c1 : c2) : c3; @@ -164,8 +166,8 @@ levenshtein(PG_FUNCTION_ARGS) } /* - * Lower row now becomes the upper row, and the upper row - * gets reused as the new lower row. + * Lower row now becomes the upper row, and the upper row gets + * reused as the new lower row. */ tmp = u_cells; u_cells = l_cells; @@ -183,8 +185,8 @@ levenshtein(PG_FUNCTION_ARGS) } /* - * Because the final value (at position row, col) was swapped from - * the lower row to the upper row, that's where we'll find it. + * Because the final value (at position row, col) was swapped from the + * lower row to the upper row, that's where we'll find it. */ PG_RETURN_INT32(u_cells[cols - 1]); } @@ -199,10 +201,10 @@ Datum metaphone(PG_FUNCTION_ARGS) { int reqlen; - char *str_i; + char *str_i; size_t str_i_len; - char *metaph; - text *result_text; + char *metaph; + text *result_text; int retval; str_i = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0)))); @@ -240,7 +242,7 @@ metaphone(PG_FUNCTION_ARGS) } -/* +/* * Original code by Michael G Schwern starts here. * Code slightly modified for use as PostgreSQL * function (palloc, etc). Original includes @@ -255,26 +257,28 @@ metaphone(PG_FUNCTION_ARGS) /* Look at the current letter in the word */ #define Curr_Letter (toupper(word[w_idx])) /* Go N letters back. */ -#define Look_Back_Letter(n) (w_idx >= n ? toupper(word[w_idx-n]) : '\0') +#define Look_Back_Letter(n) (w_idx >= n ? toupper(word[w_idx-n]) : '\0') /* Previous letter. I dunno, should this return null on failure? */ #define Prev_Letter (Look_Back_Letter(1)) /* Look two letters down. It makes sure you don't walk off the string. */ #define After_Next_Letter (Next_Letter != '\0' ? toupper(word[w_idx+2]) \ - : '\0') + : '\0') #define Look_Ahead_Letter(n) (toupper(Lookahead(word+w_idx, n))) - + /* Allows us to safely look ahead an arbitrary # of letters */ /* I probably could have just used strlen... */ -char Lookahead(char * word, int how_far) { - char letter_ahead = '\0'; /* null by default */ - int idx; - for(idx = 0; word[idx] != '\0' && idx < how_far; idx++); - /* Edge forward in the string... */ - - letter_ahead = word[idx]; /* idx will be either == to how_far or - * at the end of the string - */ +char +Lookahead(char *word, int how_far) +{ + char letter_ahead = '\0'; /* null by default */ + int idx; + + for (idx = 0; word[idx] != '\0' && idx < how_far; idx++); + /* Edge forward in the string... */ + + letter_ahead = word[idx]; /* idx will be either == to how_far or at + * the end of the string */ return letter_ahead; } @@ -282,29 +286,30 @@ char Lookahead(char * word, int how_far) { /* phonize one letter */ #define Phonize(c) do {(*phoned_word)[p_idx++] = c;} while (0) /* Slap a null character on the end of the phoned word */ -#define End_Phoned_Word do {(*phoned_word)[p_idx] = '\0';} while (0) +#define End_Phoned_Word do {(*phoned_word)[p_idx] = '\0';} while (0) /* How long is the phoned word? */ #define Phone_Len (p_idx) /* Note is a letter is a 'break' in the word */ -#define Isbreak(c) (!isalpha(c)) - - -int _metaphone ( - /* IN */ - char * word, - int max_phonemes, - /* OUT */ - char ** phoned_word -) { - int w_idx = 0; /* point in the phonization we're at. */ - int p_idx = 0; /* end of the phoned phrase */ - +#define Isbreak(c) (!isalpha(c)) + + +int +_metaphone( + /* IN */ + char *word, + int max_phonemes, + /* OUT */ + char **phoned_word +) +{ + int w_idx = 0; /* point in the phonization we're at. */ + int p_idx = 0; /* end of the phoned phrase */ + /*-- Parameter checks --*/ /* - * Shouldn't be necessary, but left these here anyway - * jec Aug 3, 2001 + * Shouldn't be necessary, but left these here anyway jec Aug 3, 2001 */ /* Negative phoneme length is meaningless */ @@ -314,13 +319,16 @@ int _metaphone ( /* Empty/null string is meaningless */ if ((word == NULL) || !(strlen(word) > 0)) elog(ERROR, "metaphone: Input string length must be > 0"); - + /*-- Allocate memory for our phoned_phrase --*/ - if (max_phonemes == 0) { /* Assume largest possible */ - *phoned_word = palloc(sizeof(char) * strlen(word) + 1); + if (max_phonemes == 0) + { /* Assume largest possible */ + *phoned_word = palloc(sizeof(char) * strlen(word) +1); if (!*phoned_word) return META_ERROR; - } else { + } + else + { *phoned_word = palloc(sizeof(char) * max_phonemes + 1); if (!*phoned_word) return META_ERROR; @@ -328,62 +336,70 @@ int _metaphone ( /*-- The first phoneme has to be processed specially. --*/ /* Find our first letter */ - for( ; !isalpha(Curr_Letter); w_idx++ ) { + for (; !isalpha(Curr_Letter); w_idx++) + { /* On the off chance we were given nothing but crap... */ - if( Curr_Letter == '\0' ) { + if (Curr_Letter == '\0') + { End_Phoned_Word - return META_SUCCESS; /* For testing */ + return META_SUCCESS; /* For testing */ } - } - - switch (Curr_Letter) { - /* AE becomes E */ + } + + switch (Curr_Letter) + { + /* AE becomes E */ case 'A': - if( Next_Letter == 'E' ) { + if (Next_Letter == 'E') + { Phonize('E'); - w_idx+=2; + w_idx += 2; } /* Remember, preserve vowels at the beginning */ - else { + else + { Phonize('A'); w_idx++; } break; - /* [GKP]N becomes N */ + /* [GKP]N becomes N */ case 'G': case 'K': case 'P': - if( Next_Letter == 'N' ) { + if (Next_Letter == 'N') + { Phonize('N'); - w_idx+=2; + w_idx += 2; } break; - /* WH becomes H, - WR becomes R - W if followed by a vowel */ + + /* + * WH becomes H, WR becomes R W if followed by a vowel + */ case 'W': - if( Next_Letter == 'H' || - Next_Letter == 'R' ) + if (Next_Letter == 'H' || + Next_Letter == 'R') { - Phonize(Next_Letter); - w_idx+=2; + Phonize(Next_Letter); + w_idx += 2; } - else if ( isvowel(Next_Letter) ) { - Phonize('W'); - w_idx+=2; + else if (isvowel(Next_Letter)) + { + Phonize('W'); + w_idx += 2; } /* else ignore */ break; - /* X becomes S */ + /* X becomes S */ case 'X': Phonize('S'); w_idx++; break; - /* Vowels are kept */ - /* We did A already - case 'A': - case 'a': - */ + /* Vowels are kept */ + + /* + * We did A already case 'A': case 'a': + */ case 'E': case 'I': case 'O': @@ -395,220 +411,235 @@ int _metaphone ( /* do nothing */ break; } - - - + + + /* On to the metaphoning */ - for(; Curr_Letter != '\0' && - (max_phonemes == 0 || Phone_Len < max_phonemes); - w_idx++) { - /* How many letters to skip because an eariler encoding handled - * multiple letters */ - unsigned short int skip_letter = 0; - - - /* THOUGHT: It would be nice if, rather than having things like... - * well, SCI. For SCI you encode the S, then have to remember - * to skip the C. So the phonome SCI invades both S and C. It would - * be better, IMHO, to skip the C from the S part of the encoding. - * Hell, I'm trying it. + for (; Curr_Letter != '\0' && + (max_phonemes == 0 || Phone_Len < max_phonemes); + w_idx++) + { + /* + * How many letters to skip because an eariler encoding handled + * multiple letters */ - + unsigned short int skip_letter = 0; + + + /* + * THOUGHT: It would be nice if, rather than having things + * like... well, SCI. For SCI you encode the S, then have to + * remember to skip the C. So the phonome SCI invades both S and + * C. It would be better, IMHO, to skip the C from the S part of + * the encoding. Hell, I'm trying it. + */ + /* Ignore non-alphas */ - if( !isalpha(Curr_Letter) ) + if (!isalpha(Curr_Letter)) continue; - + /* Drop duplicates, except CC */ - if( Curr_Letter == Prev_Letter && - Curr_Letter != 'C' ) + if (Curr_Letter == Prev_Letter && + Curr_Letter != 'C') continue; - - switch (Curr_Letter) { - /* B -> B unless in MB */ + + switch (Curr_Letter) + { + /* B -> B unless in MB */ case 'B': - if( Prev_Letter != 'M' ) + if (Prev_Letter != 'M') Phonize('B'); break; - /* 'sh' if -CIA- or -CH, but not SCH, except SCHW. - * (SCHW is handled in S) - * S if -CI-, -CE- or -CY- - * dropped if -SCI-, SCE-, -SCY- (handed in S) - * else K - */ + + /* + * 'sh' if -CIA- or -CH, but not SCH, except SCHW. (SCHW + * is handled in S) S if -CI-, -CE- or -CY- dropped if + * -SCI-, SCE-, -SCY- (handed in S) else K + */ case 'C': - if( MAKESOFT(Next_Letter) ) { /* C[IEY] */ - if( After_Next_Letter == 'A' && - Next_Letter == 'I' ) { /* CIA */ + if (MAKESOFT(Next_Letter)) + { /* C[IEY] */ + if (After_Next_Letter == 'A' && + Next_Letter == 'I') + { /* CIA */ Phonize(SH); } /* SC[IEY] */ - else if ( Prev_Letter == 'S' ) { - /* Dropped */ - } - else { - Phonize('S'); + else if (Prev_Letter == 'S') + { + /* Dropped */ } + else + Phonize('S'); } - else if ( Next_Letter == 'H' ) { + else if (Next_Letter == 'H') + { #ifndef USE_TRADITIONAL_METAPHONE - if( After_Next_Letter == 'R' || - Prev_Letter == 'S' ) { /* Christ, School */ + if (After_Next_Letter == 'R' || + Prev_Letter == 'S') + { /* Christ, School */ Phonize('K'); } - else { + else Phonize(SH); - } #else Phonize(SH); #endif skip_letter++; } - else { + else Phonize('K'); - } break; - /* J if in -DGE-, -DGI- or -DGY- - * else T - */ + + /* + * J if in -DGE-, -DGI- or -DGY- else T + */ case 'D': - if( Next_Letter == 'G' && - MAKESOFT(After_Next_Letter) ) { + if (Next_Letter == 'G' && + MAKESOFT(After_Next_Letter)) + { Phonize('J'); skip_letter++; } else Phonize('T'); break; - /* F if in -GH and not B--GH, D--GH, -H--GH, -H---GH - * else dropped if -GNED, -GN, - * else dropped if -DGE-, -DGI- or -DGY- (handled in D) - * else J if in -GE-, -GI, -GY and not GG - * else K - */ + + /* + * F if in -GH and not B--GH, D--GH, -H--GH, -H---GH else + * dropped if -GNED, -GN, else dropped if -DGE-, -DGI- or + * -DGY- (handled in D) else J if in -GE-, -GI, -GY and + * not GG else K + */ case 'G': - if( Next_Letter == 'H' ) { - if( !( NOGHTOF(Look_Back_Letter(3)) || - Look_Back_Letter(4) == 'H' ) ) { + if (Next_Letter == 'H') + { + if (!(NOGHTOF(Look_Back_Letter(3)) || + Look_Back_Letter(4) == 'H')) + { Phonize('F'); skip_letter++; } - else { + else + { /* silent */ } } - else if( Next_Letter == 'N' ) { - if( Isbreak(After_Next_Letter) || - ( After_Next_Letter == 'E' && - Look_Ahead_Letter(3) == 'D' ) ) { + else if (Next_Letter == 'N') + { + if (Isbreak(After_Next_Letter) || + (After_Next_Letter == 'E' && + Look_Ahead_Letter(3) == 'D')) + { /* dropped */ } else Phonize('K'); } - else if( MAKESOFT(Next_Letter) && - Prev_Letter != 'G' ) { + else if (MAKESOFT(Next_Letter) && + Prev_Letter != 'G') Phonize('J'); - } - else { + else Phonize('K'); - } break; - /* H if before a vowel and not after C,G,P,S,T */ + /* H if before a vowel and not after C,G,P,S,T */ case 'H': - if( isvowel(Next_Letter) && - !AFFECTH(Prev_Letter) ) + if (isvowel(Next_Letter) && + !AFFECTH(Prev_Letter)) Phonize('H'); break; - /* dropped if after C - * else K - */ + + /* + * dropped if after C else K + */ case 'K': - if( Prev_Letter != 'C' ) + if (Prev_Letter != 'C') Phonize('K'); break; - /* F if before H - * else P - */ + + /* + * F if before H else P + */ case 'P': - if( Next_Letter == 'H' ) { + if (Next_Letter == 'H') Phonize('F'); - } - else { + else Phonize('P'); - } break; - /* K - */ + + /* + * K + */ case 'Q': Phonize('K'); break; - /* 'sh' in -SH-, -SIO- or -SIA- or -SCHW- - * else S - */ + + /* + * 'sh' in -SH-, -SIO- or -SIA- or -SCHW- else S + */ case 'S': - if( Next_Letter == 'I' && - ( After_Next_Letter == 'O' || - After_Next_Letter == 'A' ) ) { + if (Next_Letter == 'I' && + (After_Next_Letter == 'O' || + After_Next_Letter == 'A')) Phonize(SH); - } - else if ( Next_Letter == 'H' ) { + else if (Next_Letter == 'H') + { Phonize(SH); skip_letter++; } #ifndef USE_TRADITIONAL_METAPHONE - else if ( Next_Letter == 'C' && - Look_Ahead_Letter(2) == 'H' && - Look_Ahead_Letter(3) == 'W' ) { + else if (Next_Letter == 'C' && + Look_Ahead_Letter(2) == 'H' && + Look_Ahead_Letter(3) == 'W') + { Phonize(SH); skip_letter += 2; } #endif - else { + else Phonize('S'); - } break; - /* 'sh' in -TIA- or -TIO- - * else 'th' before H - * else T - */ + + /* + * 'sh' in -TIA- or -TIO- else 'th' before H else T + */ case 'T': - if( Next_Letter == 'I' && - ( After_Next_Letter == 'O' || - After_Next_Letter == 'A' ) ) { + if (Next_Letter == 'I' && + (After_Next_Letter == 'O' || + After_Next_Letter == 'A')) Phonize(SH); - } - else if ( Next_Letter == 'H' ) { + else if (Next_Letter == 'H') + { Phonize(TH); skip_letter++; } - else { + else Phonize('T'); - } break; - /* F */ + /* F */ case 'V': Phonize('F'); break; - /* W before a vowel, else dropped */ + /* W before a vowel, else dropped */ case 'W': - if( isvowel(Next_Letter) ) + if (isvowel(Next_Letter)) Phonize('W'); break; - /* KS */ + /* KS */ case 'X': Phonize('K'); Phonize('S'); break; - /* Y if followed by a vowel */ + /* Y if followed by a vowel */ case 'Y': - if( isvowel(Next_Letter) ) + if (isvowel(Next_Letter)) Phonize('Y'); break; - /* S */ + /* S */ case 'Z': Phonize('S'); break; - /* No transformation */ + /* No transformation */ case 'F': case 'J': case 'L': @@ -620,15 +651,15 @@ int _metaphone ( default: /* nothing */ break; - } /* END SWITCH */ - + } /* END SWITCH */ + w_idx += skip_letter; - } /* END FOR */ - + } /* END FOR */ + End_Phoned_Word; - - return(META_SUCCESS); -} /* END metaphone */ + + return (META_SUCCESS); +} /* END metaphone */ /* diff --git a/contrib/fuzzystrmatch/fuzzystrmatch.h b/contrib/fuzzystrmatch/fuzzystrmatch.h index 9a9be1e9a0..9c53981843 100644 --- a/contrib/fuzzystrmatch/fuzzystrmatch.h +++ b/contrib/fuzzystrmatch/fuzzystrmatch.h @@ -24,13 +24,13 @@ * documentation for any purpose, without fee, and without a written agreement * is hereby granted, provided that the above copyright notice and this * paragraph and the following two paragraphs appear in all copies. - * + * * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS * DOCUMENTATION, EVEN IF THE AUTHOR OR DISTRIBUTORS HAVE BEEN ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - * + * * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS @@ -88,7 +88,7 @@ static const char *soundex_table = "01230120022455012623010202"; */ #define MAX_METAPHONE_STRLEN 255 -/* +/* * Original code by Michael G Schwern starts here. * Code slightly modified for use as PostgreSQL * function (combined *.h into here). @@ -96,26 +96,26 @@ static const char *soundex_table = "01230120022455012623010202"; /************************************************************************** metaphone -- Breaks english phrases down into their phonemes. - + Input - word -- An english word to be phonized - max_phonemes -- How many phonemes to calculate. If 0, then it + word -- An english word to be phonized + max_phonemes -- How many phonemes to calculate. If 0, then it will phonize the entire phrase. - phoned_word -- The final phonized word. (We'll allocate the + phoned_word -- The final phonized word. (We'll allocate the memory.) Output error -- A simple error flag, returns TRUE or FALSE - - NOTES: ALL non-alpha characters are ignored, this includes whitespace, + + NOTES: ALL non-alpha characters are ignored, this includes whitespace, although non-alpha characters will break up phonemes. ****************************************************************************/ /************************************************************************** my constants -- constants I like - + Probably redundant. - + ***************************************************************************/ #define META_ERROR FALSE @@ -123,22 +123,23 @@ static const char *soundex_table = "01230120022455012623010202"; #define META_FAILURE FALSE -/* I add modifications to the traditional metaphone algorithm that you +/* I add modifications to the traditional metaphone algorithm that you might find in books. Define this if you want metaphone to behave traditionally */ #undef USE_TRADITIONAL_METAPHONE /* Special encodings */ -#define SH 'X' +#define SH 'X' #define TH '0' -char Lookahead(char * word, int how_far); -int _metaphone ( - /* IN */ - char * word, - int max_phonemes, - /* OUT */ - char ** phoned_word +char Lookahead(char *word, int how_far); +int +_metaphone( + /* IN */ + char *word, + int max_phonemes, + /* OUT */ + char **phoned_word ); /* Metachar.h ... little bits about characters for metaphone */ @@ -146,9 +147,9 @@ int _metaphone ( /*-- Character encoding array & accessing macros --*/ /* Stolen directly out of the book... */ -char _codes[26] = { - 1,16,4,16,9,2,4,16,9,2,0,2,2,2,1,4,0,2,4,4,1,0,0,0,8,0 -/* a b c d e f g h i j k l m n o p q r s t u v w x y z */ +char _codes[26] = { + 1, 16, 4, 16, 9, 2, 4, 16, 9, 2, 0, 2, 2, 2, 1, 4, 0, 2, 4, 4, 1, 0, 0, 0, 8, 0 +/* a b c d e f g h i j k l m n o p q r s t u v w x y z */ }; @@ -157,16 +158,15 @@ char _codes[26] = { #define isvowel(c) (ENCODE(c) & 1) /* AEIOU */ /* These letters are passed through unchanged */ -#define NOCHANGE(c) (ENCODE(c) & 2) /* FJMNR */ +#define NOCHANGE(c) (ENCODE(c) & 2) /* FJMNR */ /* These form dipthongs when preceding H */ -#define AFFECTH(c) (ENCODE(c) & 4) /* CGPST */ +#define AFFECTH(c) (ENCODE(c) & 4) /* CGPST */ /* These make C and G soft */ -#define MAKESOFT(c) (ENCODE(c) & 8) /* EIY */ +#define MAKESOFT(c) (ENCODE(c) & 8) /* EIY */ /* These prevent GH from becoming F */ -#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */ - +#define NOGHTOF(c) (ENCODE(c) & 16) /* BDH */ #endif /* FUZZYSTRMATCH_H */ diff --git a/contrib/lo/lo.c b/contrib/lo/lo.c index 1dcdc35850..431756e9a7 100644 --- a/contrib/lo/lo.c +++ b/contrib/lo/lo.c @@ -1,7 +1,7 @@ /* * PostgreSQL type definitions for managed LargeObjects. * - * $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.8 2001/03/22 03:59:09 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/lo/lo.c,v 1.9 2001/10/25 05:49:19 momjian Exp $ * */ @@ -33,8 +33,8 @@ typedef Oid Blob; */ Blob *lo_in(char *str); /* Create from String */ -char *lo_out(Blob * addr);/* Output oid as String */ -Oid lo_oid(Blob * addr);/* Return oid as an oid */ +char *lo_out(Blob * addr); /* Output oid as String */ +Oid lo_oid(Blob * addr); /* Return oid as an oid */ Blob *lo(Oid oid); /* Return Blob based on oid */ Datum lo_manage(PG_FUNCTION_ARGS); /* Trigger handler */ @@ -64,7 +64,6 @@ lo_in(char *str) } else { - /* * There is no Oid passed, so create a new one */ @@ -140,7 +139,7 @@ lo_manage(PG_FUNCTION_ARGS) TupleDesc tupdesc; /* Tuple Descriptor */ HeapTuple rettuple; /* Tuple to be returned */ bool isdelete; /* are we deleting? */ - HeapTuple newtuple = NULL;/* The new value for tuple */ + HeapTuple newtuple = NULL; /* The new value for tuple */ HeapTuple trigtuple; /* The original value of tuple */ if (!CALLED_AS_TRIGGER(fcinfo)) diff --git a/contrib/mSQL-interface/mpgsql.c b/contrib/mSQL-interface/mpgsql.c index 5b35fe1638..8b59485471 100644 --- a/contrib/mSQL-interface/mpgsql.c +++ b/contrib/mSQL-interface/mpgsql.c @@ -229,7 +229,7 @@ msqlGetSequenceInfo(int a, char *b) { } -m_field * +m_field * msqlFetchField(m_result * mr) { m_field *m = (m_field *) mr->fieldCursor; @@ -242,7 +242,7 @@ msqlFetchField(m_result * mr) return NULL; } -m_result * +m_result * msqlListDBs(int a) { m_result *m; @@ -256,7 +256,7 @@ msqlListDBs(int a) return NULL; } -m_result * +m_result * msqlListTables(int a) { m_result *m; @@ -272,13 +272,13 @@ msqlListTables(int a) return NULL; } -m_result * +m_result * msqlListFields(int a, char *b) { } -m_result * +m_result * msqlListIndex(int a, char *b, char *c) { m_result *m; @@ -294,7 +294,7 @@ msqlListIndex(int a, char *b, char *c) return NULL; } -m_result * +m_result * msqlStoreResult(void) { if (queryres) diff --git a/contrib/miscutil/misc_utils.h b/contrib/miscutil/misc_utils.h index f4577f49de..0fb07012df 100644 --- a/contrib/miscutil/misc_utils.h +++ b/contrib/miscutil/misc_utils.h @@ -6,5 +6,4 @@ int unlisten(char *relname); int max(int x, int y); int min(int x, int y); int active_listeners(text *relname); - #endif diff --git a/contrib/pg_controldata/pg_controldata.c b/contrib/pg_controldata/pg_controldata.c index bf7209cb29..1cbd352caf 100644 --- a/contrib/pg_controldata/pg_controldata.c +++ b/contrib/pg_controldata/pg_controldata.c @@ -6,7 +6,7 @@ * copyright (c) Oliver Elphick <[email protected]>, 2001; * licence: BSD * - * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.4 2001/09/06 10:49:29 petere Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_controldata/Attic/pg_controldata.c,v 1.5 2001/10/25 05:49:19 momjian Exp $ */ #include "postgres.h" @@ -24,7 +24,7 @@ dbState(DBState state) { switch (state) { - case DB_STARTUP: + case DB_STARTUP: return "STARTUP"; case DB_SHUTDOWNED: return "SHUTDOWNED"; diff --git a/contrib/pg_dumplo/lo_export.c b/contrib/pg_dumplo/lo_export.c index ef62549791..adb216fee2 100644 --- a/contrib/pg_dumplo/lo_export.c +++ b/contrib/pg_dumplo/lo_export.c @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.7 2001/03/22 06:16:06 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_export.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -32,14 +32,14 @@ load_lolist(LODumpMaster * pgLO) int i; int n; - /* + /* * Now find any candidate tables who have columns of type oid. * * NOTE: System tables including pg_largeobject will be ignored. * Otherwise we'd end up dumping all LOs, referenced or not. * - * NOTE: the system oid column is ignored, as it has attnum < 1. - * This shouldn't matter for correctness, but it saves time. + * NOTE: the system oid column is ignored, as it has attnum < 1. This + * shouldn't matter for correctness, but it saves time. */ pgLO->res = PQexec(pgLO->conn, "SELECT c.relname, a.attname " @@ -107,8 +107,7 @@ pglo_export(LODumpMaster * pgLO) for (ll = pgLO->lolist; ll->lo_table != NULL; ll++) { - - /* + /* * Query: find the LOs referenced by this column */ sprintf(Qbuff, "SELECT DISTINCT l.loid FROM \"%s\" x, pg_largeobject l WHERE x.\"%s\" = l.loid", diff --git a/contrib/pg_dumplo/lo_import.c b/contrib/pg_dumplo/lo_import.c index a75e905be1..aec2aa0cee 100644 --- a/contrib/pg_dumplo/lo_import.c +++ b/contrib/pg_dumplo/lo_import.c @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.5 2001/03/22 06:16:06 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/lo_import.c,v 1.6 2001/10/25 05:49:19 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -50,7 +50,7 @@ pglo_import(LODumpMaster * pgLO) sprintf(lo_path, "%s/%s", pgLO->space, path); - /* + /* * Import LO */ if ((new_oid = lo_import(pgLO->conn, lo_path)) == 0) @@ -78,7 +78,7 @@ pglo_import(LODumpMaster * pgLO) pgLO->counter++; - /* + /* * UPDATE oid in tab */ sprintf(Qbuff, "UPDATE \"%s\" SET \"%s\"=%u WHERE \"%s\"=%u", diff --git a/contrib/pg_dumplo/main.c b/contrib/pg_dumplo/main.c index 211753b605..45f5dc6312 100644 --- a/contrib/pg_dumplo/main.c +++ b/contrib/pg_dumplo/main.c @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.8 2001/03/22 06:16:06 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/main.c,v 1.9 2001/10/25 05:49:19 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -152,7 +152,7 @@ main(int argc, char **argv) exit(RE_ERROR); } - /* + /* * Check space */ if (!pgLO->space && !pgLO->action == ACTION_SHOW) @@ -170,7 +170,7 @@ main(int argc, char **argv) exit(RE_ERROR); } - /* + /* * Make connection */ pgLO->conn = PQsetdbLogin(pgLO->host, NULL, NULL, NULL, pgLO->db, @@ -186,7 +186,7 @@ main(int argc, char **argv) pgLO->user = PQuser(pgLO->conn); - /* + /* * Init index file */ if (pgLO->action != ACTION_SHOW) @@ -304,7 +304,6 @@ usage() "-q run quietly\n" "-w not dump, but show all LO in DB\n" ); /* puts() */ - #endif puts( diff --git a/contrib/pg_dumplo/pg_dumplo.h b/contrib/pg_dumplo/pg_dumplo.h index 3ab25495cb..1c76cfb624 100644 --- a/contrib/pg_dumplo/pg_dumplo.h +++ b/contrib/pg_dumplo/pg_dumplo.h @@ -1,7 +1,7 @@ /* ------------------------------------------------------------------------- * pg_dumplo * - * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.4 2001/03/22 03:59:10 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_dumplo/Attic/pg_dumplo.h,v 1.5 2001/10/25 05:49:19 momjian Exp $ * * Karel Zak 1999-2000 * ------------------------------------------------------------------------- @@ -64,11 +64,11 @@ typedef struct typedef enum { - ACTION_NONE, - ACTION_SHOW, - ACTION_EXPORT_ATTR, - ACTION_EXPORT_ALL, - ACTION_IMPORT + ACTION_NONE, + ACTION_SHOW, + ACTION_EXPORT_ATTR, + ACTION_EXPORT_ALL, + ACTION_IMPORT } PGLODUMP_ACTIONS; extern char *progname; @@ -78,5 +78,4 @@ extern void index_file(LODumpMaster * pgLO); extern void load_lolist(LODumpMaster * pgLO); extern void pglo_export(LODumpMaster * pgLO); extern void pglo_import(LODumpMaster * pgLO); - #endif /* PG_DUMPLO_H */ diff --git a/contrib/pg_resetxlog/pg_resetxlog.c b/contrib/pg_resetxlog/pg_resetxlog.c index 20db41ccf4..b6981345e2 100644 --- a/contrib/pg_resetxlog/pg_resetxlog.c +++ b/contrib/pg_resetxlog/pg_resetxlog.c @@ -23,7 +23,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.7 2001/10/25 00:55:48 momjian Exp $ + * $Header: /cvsroot/pgsql/contrib/pg_resetxlog/Attic/pg_resetxlog.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -147,7 +147,6 @@ ReadControlFile(void) if ((fd = open(ControlFilePath, O_RDONLY)) < 0) { - /* * If pg_control is not there at all, or we can't read it, the * odds are we've been handed a bad DataDir path, so give up. User @@ -412,7 +411,6 @@ CheckControlVersion0(char *buffer, int len) (char *) malloc(_INTL_MAXLOGRECSZ)); if (record == NULL) { - /* * We have to guess at the checkpoint contents. */ @@ -493,7 +491,7 @@ ReadRecordV0(XLogRecPtr *RecPtr, char *buffer) readFile = XLogFileOpen(readId, readSeg); if (readFile < 0) goto next_record_is_invalid; - readOff = (uint32) (-1);/* force read to occur below */ + readOff = (uint32) (-1); /* force read to occur below */ } targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ; @@ -617,7 +615,6 @@ GuessControlValues(void) { #ifdef USE_LOCALE char *localeptr; - #endif /* diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c index 5fc18fe688..c8aa0c14b7 100644 --- a/contrib/pgbench/pgbench.c +++ b/contrib/pgbench/pgbench.c @@ -1,5 +1,5 @@ /* - * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.11 2001/10/24 08:07:22 ishii Exp $ + * $Header: /cvsroot/pgsql/contrib/pgbench/pgbench.c,v 1.12 2001/10/25 05:49:19 momjian Exp $ * * pgbench: a simple TPC-B like benchmark program for PostgreSQL * written by Tatsuo Ishii @@ -39,7 +39,6 @@ /* for getrlimit */ #include <sys/resource.h> - #endif /* WIN32 */ /******************************************************************** @@ -67,7 +66,8 @@ int tps = 1; int remains; /* number of remained clients */ -int is_connect; /* establish connection for each transactoin */ +int is_connect; /* establish connection for each + * transactoin */ char *pghost = ""; char *pgport = NULL; @@ -107,31 +107,32 @@ getrand(int min, int max) } /* set up a connection to the backend */ -static PGconn *doConnect() +static PGconn * +doConnect() { - PGconn *con; - - con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, - login, pwd); - if (con == NULL) - { - fprintf(stderr, "Connection to database '%s' failed.\n", dbName); - fprintf(stderr, "Memory allocatin problem?\n"); - return(NULL); - } - - if (PQstatus(con) == CONNECTION_BAD) - { - fprintf(stderr, "Connection to database '%s' failed.\n", dbName); - - if (PQerrorMessage(con)) - fprintf(stderr, "%s", PQerrorMessage(con)); - else - fprintf(stderr, "No explanation from the backend\n"); + PGconn *con; + + con = PQsetdbLogin(pghost, pgport, pgoptions, pgtty, dbName, + login, pwd); + if (con == NULL) + { + fprintf(stderr, "Connection to database '%s' failed.\n", dbName); + fprintf(stderr, "Memory allocatin problem?\n"); + return (NULL); + } + + if (PQstatus(con) == CONNECTION_BAD) + { + fprintf(stderr, "Connection to database '%s' failed.\n", dbName); + + if (PQerrorMessage(con)) + fprintf(stderr, "%s", PQerrorMessage(con)); + else + fprintf(stderr, "No explanation from the backend\n"); - return(NULL); - } - return (con); + return (NULL); + } + return (con); } /* throw away response from backend */ @@ -162,7 +163,7 @@ check(CState * state, PGresult *res, int n, int good) st->con = NULL; return (-1); } - return (0); /* OK */ + return (0); /* OK */ } /* process a transaction */ @@ -242,8 +243,8 @@ doOne(CState * state, int n, int debug) if (is_connect) { - PQfinish(st->con); - st->con = NULL; + PQfinish(st->con); + st->con = NULL; } if (++st->cnt >= nxacts) @@ -251,8 +252,8 @@ doOne(CState * state, int n, int debug) remains--; /* I've done */ if (st->con != NULL) { - PQfinish(st->con); - st->con = NULL; + PQfinish(st->con); + st->con = NULL; } return; } @@ -267,15 +268,15 @@ doOne(CState * state, int n, int debug) if (st->con == NULL) { - if ((st->con = doConnect()) == NULL) - { - fprintf(stderr, "Client %d aborted in establishing connection.\n", - n); - remains--; /* I've aborted */ - PQfinish(st->con); - st->con = NULL; - return; - } + if ((st->con = doConnect()) == NULL) + { + fprintf(stderr, "Client %d aborted in establishing connection.\n", + n); + remains--; /* I've aborted */ + PQfinish(st->con); + st->con = NULL; + return; + } } switch (st->state) @@ -358,8 +359,8 @@ doSelectOnly(CState * state, int n, int debug) if (is_connect) { - PQfinish(st->con); - st->con = NULL; + PQfinish(st->con); + st->con = NULL; } if (++st->cnt >= nxacts) @@ -367,8 +368,8 @@ doSelectOnly(CState * state, int n, int debug) remains--; /* I've done */ if (st->con != NULL) { - PQfinish(st->con); - st->con = NULL; + PQfinish(st->con); + st->con = NULL; } return; } @@ -383,15 +384,15 @@ doSelectOnly(CState * state, int n, int debug) if (st->con == NULL) { - if ((st->con = doConnect()) == NULL) - { - fprintf(stderr, "Client %d aborted in establishing connection.\n", - n); - remains--; /* I've aborted */ - PQfinish(st->con); - st->con = NULL; - return; - } + if ((st->con = doConnect()) == NULL) + { + fprintf(stderr, "Client %d aborted in establishing connection.\n", + n); + remains--; /* I've aborted */ + PQfinish(st->con); + st->con = NULL; + return; + } } switch (st->state) @@ -450,7 +451,7 @@ init() int i; if ((con = doConnect()) == NULL) - exit(1); + exit(1); for (i = 0; i < (sizeof(DDLs) / sizeof(char *)); i++) { @@ -532,29 +533,30 @@ init() if (j % 10000 == 0) { /* - * every 10000 tuples, we commit the copy command. - * this should avoid generating too much WAL logs + * every 10000 tuples, we commit the copy command. this should + * avoid generating too much WAL logs */ fprintf(stderr, "%d tuples done.\n", j); if (PQputline(con, "\\.\n")) { - fprintf(stderr, "very last PQputline failed\n"); - exit(1); + fprintf(stderr, "very last PQputline failed\n"); + exit(1); } if (PQendcopy(con)) { - fprintf(stderr, "PQendcopy failed\n"); - exit(1); + fprintf(stderr, "PQendcopy failed\n"); + exit(1); } + /* * do a checkpoint to purge the old WAL logs */ res = PQexec(con, "checkpoint"); if (PQresultStatus(res) != PGRES_COMMAND_OK) { - fprintf(stderr, "%s", PQerrorMessage(con)); - exit(1); + fprintf(stderr, "%s", PQerrorMessage(con)); + exit(1); } } } @@ -634,7 +636,6 @@ main(int argc, char **argv) #ifndef __CYGWIN__ struct rlimit rlim; - #endif PGconn *con; @@ -691,9 +692,9 @@ main(int argc, char **argv) } #endif /* #ifndef __CYGWIN__ */ break; - case 'C': - is_connect = 1; - break; + case 'C': + is_connect = 1; + break; case 's': tps = atoi(optarg); if (tps <= 0) @@ -734,7 +735,7 @@ main(int argc, char **argv) if (is_init_mode) { - init(); + init(); exit(0); } @@ -749,7 +750,7 @@ main(int argc, char **argv) /* opening connection... */ con = doConnect(); if (con == NULL) - exit(1); + exit(1); if (PQstatus(con) == CONNECTION_BAD) { @@ -836,12 +837,12 @@ main(int argc, char **argv) if (is_connect == 0) { - /* make connections to the database */ - for (i = 0; i < nclients; i++) - { - if ((state[i].con = doConnect()) == NULL) - exit(1); - } + /* make connections to the database */ + for (i = 0; i < nclients; i++) + { + if ((state[i].con = doConnect()) == NULL) + exit(1); + } } /* time after connections set up */ diff --git a/contrib/pgcrypto/blf.c b/contrib/pgcrypto/blf.c index 28d44d9de9..aae5b6033a 100644 --- a/contrib/pgcrypto/blf.c +++ b/contrib/pgcrypto/blf.c @@ -11,15 +11,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by Niels Provos. + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. * 4. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. + * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -46,338 +46,354 @@ #undef inline #ifdef __GNUC__ #define inline __inline -#else /* !__GNUC__ */ +#else /* !__GNUC__ */ #define inline -#endif /* !__GNUC__ */ +#endif /* !__GNUC__ */ /* Function for Feistel Networks */ -#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ +#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ + (s)[0x100 + (((x)>>16)&0xFF)]) \ ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \ - + (s)[0x300 + ( (x) &0xFF)]) + + (s)[0x300 + ( (x) &0xFF)]) #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n]) void -Blowfish_encipher(blf_ctx *c, uint32 *x) +Blowfish_encipher(blf_ctx * c, uint32 *x) { - uint32 Xl; - uint32 Xr; - uint32 *s = c->S[0]; - uint32 *p = c->P; + uint32 Xl; + uint32 Xr; + uint32 *s = c->S[0]; + uint32 *p = c->P; Xl = x[0]; Xr = x[1]; Xl ^= p[0]; - BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); - BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); - BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); - BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); - BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); - BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); - BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); - BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); + BLFRND(s, p, Xr, Xl, 1); + BLFRND(s, p, Xl, Xr, 2); + BLFRND(s, p, Xr, Xl, 3); + BLFRND(s, p, Xl, Xr, 4); + BLFRND(s, p, Xr, Xl, 5); + BLFRND(s, p, Xl, Xr, 6); + BLFRND(s, p, Xr, Xl, 7); + BLFRND(s, p, Xl, Xr, 8); + BLFRND(s, p, Xr, Xl, 9); + BLFRND(s, p, Xl, Xr, 10); + BLFRND(s, p, Xr, Xl, 11); + BLFRND(s, p, Xl, Xr, 12); + BLFRND(s, p, Xr, Xl, 13); + BLFRND(s, p, Xl, Xr, 14); + BLFRND(s, p, Xr, Xl, 15); + BLFRND(s, p, Xl, Xr, 16); x[0] = Xr ^ p[17]; x[1] = Xl; } void -Blowfish_decipher(blf_ctx *c, uint32 *x) +Blowfish_decipher(blf_ctx * c, uint32 *x) { - uint32 Xl; - uint32 Xr; - uint32 *s = c->S[0]; - uint32 *p = c->P; + uint32 Xl; + uint32 Xr; + uint32 *s = c->S[0]; + uint32 *p = c->P; Xl = x[0]; Xr = x[1]; Xl ^= p[17]; - BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); - BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); - BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); - BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); - BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); - BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); - BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); - BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); + BLFRND(s, p, Xr, Xl, 16); + BLFRND(s, p, Xl, Xr, 15); + BLFRND(s, p, Xr, Xl, 14); + BLFRND(s, p, Xl, Xr, 13); + BLFRND(s, p, Xr, Xl, 12); + BLFRND(s, p, Xl, Xr, 11); + BLFRND(s, p, Xr, Xl, 10); + BLFRND(s, p, Xl, Xr, 9); + BLFRND(s, p, Xr, Xl, 8); + BLFRND(s, p, Xl, Xr, 7); + BLFRND(s, p, Xr, Xl, 6); + BLFRND(s, p, Xl, Xr, 5); + BLFRND(s, p, Xr, Xl, 4); + BLFRND(s, p, Xl, Xr, 3); + BLFRND(s, p, Xr, Xl, 2); + BLFRND(s, p, Xl, Xr, 1); x[0] = Xr ^ p[0]; x[1] = Xl; } void -Blowfish_initstate(blf_ctx *c) +Blowfish_initstate(blf_ctx * c) { /* P-box and S-box tables initialized with digits of Pi */ const blf_ctx initstate = - { { - { - 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, - 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, - 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, - 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, - 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, - 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, - 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, - 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, - 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, - 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, - 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, - 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, - 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, - 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, - 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, - 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, - 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, - 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, - 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, - 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, - 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, - 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, - 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, - 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, - 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, - 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, - 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, - 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, - 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, - 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, - 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, - 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, - 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, - 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, - 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, - 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, - 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, - 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, - 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, - 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, - 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, - 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, - 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, - 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, - 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, - 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, - 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, - 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, - 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, - 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, - 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, - 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, - 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, - 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, - 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, - 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, - 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, - 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, - 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, - 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, - 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, - 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, - 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, - 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, - { - 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, - 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, - 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, - 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, - 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, - 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, - 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, - 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, - 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, - 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, - 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, - 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, - 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, - 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, - 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, - 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, - 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, - 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, - 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, - 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, - 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, - 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, - 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, - 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, - 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, - 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, - 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, - 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, - 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, - 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, - 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, - 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, - 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, - 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, - 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, - 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, - 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, - 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, - 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, - 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, - 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, - 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, - 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, - 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, - 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, - 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, - 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, - 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, - 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, - 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, - 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, - 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, - 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, - 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, - 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, - 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, - 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, - 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, - 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, - 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, - 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, - 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, - 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, - 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, - { - 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, - 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, - 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, - 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, - 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, - 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, - 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, - 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, - 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, - 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, - 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, - 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, - 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, - 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, - 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, - 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, - 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, - 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, - 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, - 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, - 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, - 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, - 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, - 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, - 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, - 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, - 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, - 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, - 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, - 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, - 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, - 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, - 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, - 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, - 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, - 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, - 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, - 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, - 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, - 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, - 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, - 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, - 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, - 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, - 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, - 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, - 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, - 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, - 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, - 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, - 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, - 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, - 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, - 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, - 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, - 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, - 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, - 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, - 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, - 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, - 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, - 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, - 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, - 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, - { - 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, - 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, - 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, - 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, - 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, - 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, - 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, - 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, - 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, - 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, - 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, - 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, - 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, - 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, - 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, - 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, - 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, - 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, - 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, - 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, - 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, - 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, - 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, - 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, - 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, - 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, - 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, - 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, - 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, - 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, - 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, - 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, - 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, - 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, - 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, - 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, - 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, - 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, - 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, - 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, - 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, - 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, - 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, - 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, - 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, - 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, - 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, - 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, - 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, - 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, - 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, - 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, - 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, - 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, - 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, - 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, - 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, - 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, - 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, - 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, - 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, - 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, - 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, - 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} + {{ + { + 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, + 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, + 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, + 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, + 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, + 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, + 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, + 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, + 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, + 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, + 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, + 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, + 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, + 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, + 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, + 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, + 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, + 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, + 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, + 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, + 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, + 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, + 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, + 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, + 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, + 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, + 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, + 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, + 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, + 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, + 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, + 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, + 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, + 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, + 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, + 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, + 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, + 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, + 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, + 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, + 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, + 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, + 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, + 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, + 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, + 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, + 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, + 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, + 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, + 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, + 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, + 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, + 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, + 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, + 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, + 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, + 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, + 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, + 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, + 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, + 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, + 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, + 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, + 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, + { + 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, + 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, + 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, + 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, + 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, + 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, + 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, + 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, + 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, + 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, + 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, + 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, + 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, + 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, + 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, + 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, + 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, + 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, + 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, + 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, + 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, + 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, + 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, + 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, + 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, + 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, + 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, + 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, + 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, + 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, + 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, + 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, + 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, + 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, + 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, + 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, + 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, + 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, + 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, + 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, + 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, + 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, + 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, + 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, + 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, + 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, + 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, + 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, + 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, + 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, + 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, + 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, + 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, + 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, + 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, + 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, + 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, + 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, + 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, + 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, + 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, + 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, + 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, + 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, + { + 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, + 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, + 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, + 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, + 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, + 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, + 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, + 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, + 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, + 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, + 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, + 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, + 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, + 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, + 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, + 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, + 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, + 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, + 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, + 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, + 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, + 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, + 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, + 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, + 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, + 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, + 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, + 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, + 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, + 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, + 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, + 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, + 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, + 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, + 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, + 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, + 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, + 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, + 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, + 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, + 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, + 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, + 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, + 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, + 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, + 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, + 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, + 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, + 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, + 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, + 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, + 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, + 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, + 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, + 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, + 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, + 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, + 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, + 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, + 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, + 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, + 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, + 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, + 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, + { + 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, + 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, + 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, + 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, + 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, + 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, + 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, + 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, + 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, + 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, + 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, + 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, + 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, + 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, + 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, + 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, + 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, + 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, + 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, + 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, + 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, + 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, + 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, + 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, + 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, + 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, + 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, + 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, + 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, + 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, + 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, + 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, + 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, + 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, + 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, + 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, + 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, + 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, + 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, + 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, + 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, + 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, + 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, + 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, + 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, + 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, + 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, + 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, + 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, + 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, + 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, + 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, + 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, + 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, + 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, + 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, + 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, + 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, + 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, + 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, + 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, + 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, + 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, + 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} }, { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, @@ -385,7 +401,7 @@ Blowfish_initstate(blf_ctx *c) 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b - } }; + }}; *c = initstate; @@ -394,14 +410,15 @@ Blowfish_initstate(blf_ctx *c) uint32 Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current) { - uint8 i; - uint16 j; - uint32 temp; + uint8 i; + uint16 j; + uint32 temp; temp = 0x00000000; j = *current; - for (i = 0; i < 4; i++, j++) { + for (i = 0; i < 4; i++, j++) + { if (j >= databytes) j = 0; temp = (temp << 8) | data[j]; @@ -412,16 +429,17 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current) } void -Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) +Blowfish_expand0state(blf_ctx * c, const uint8 *key, uint16 keybytes) { - uint16 i; - uint16 j; - uint16 k; - uint32 temp; - uint32 data[2]; + uint16 i; + uint16 j; + uint16 k; + uint32 temp; + uint32 data[2]; j = 0; - for (i = 0; i < BLF_N + 2; i++) { + for (i = 0; i < BLF_N + 2; i++) + { /* Extract 4 int8 to 1 int32 from keystream */ temp = Blowfish_stream2word(key, keybytes, &j); c->P[i] = c->P[i] ^ temp; @@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) j = 0; data[0] = 0x00000000; data[1] = 0x00000000; - for (i = 0; i < BLF_N + 2; i += 2) { + for (i = 0; i < BLF_N + 2; i += 2) + { Blowfish_encipher(c, data); c->P[i] = data[0]; c->P[i + 1] = data[1]; } - for (i = 0; i < 4; i++) { - for (k = 0; k < 256; k += 2) { + for (i = 0; i < 4; i++) + { + for (k = 0; k < 256; k += 2) + { Blowfish_encipher(c, data); c->S[i][k] = data[0]; @@ -449,17 +470,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) void -Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, - const uint8 *key, uint16 keybytes) +Blowfish_expandstate(blf_ctx * c, const uint8 *data, uint16 databytes, + const uint8 *key, uint16 keybytes) { - uint16 i; - uint16 j; - uint16 k; - uint32 temp; - uint32 d[2]; + uint16 i; + uint16 j; + uint16 k; + uint32 temp; + uint32 d[2]; j = 0; - for (i = 0; i < BLF_N + 2; i++) { + for (i = 0; i < BLF_N + 2; i++) + { /* Extract 4 int8 to 1 int32 from keystream */ temp = Blowfish_stream2word(key, keybytes, &j); c->P[i] = c->P[i] ^ temp; @@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, j = 0; d[0] = 0x00000000; d[1] = 0x00000000; - for (i = 0; i < BLF_N + 2; i += 2) { + for (i = 0; i < BLF_N + 2; i += 2) + { d[0] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j); Blowfish_encipher(c, d); @@ -477,9 +500,11 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, c->P[i + 1] = d[1]; } - for (i = 0; i < 4; i++) { - for (k = 0; k < 256; k += 2) { - d[0]^= Blowfish_stream2word(data, databytes, &j); + for (i = 0; i < 4; i++) + { + for (k = 0; k < 256; k += 2) + { + d[0] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j); Blowfish_encipher(c, d); @@ -491,7 +516,7 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, } void -blf_key(blf_ctx *c, const uint8 *k, uint16 len) +blf_key(blf_ctx * c, const uint8 *k, uint16 len) { /* Initalize S-boxes and subkeys with Pi */ Blowfish_initstate(c); @@ -501,38 +526,43 @@ blf_key(blf_ctx *c, const uint8 *k, uint16 len) } void -blf_enc(blf_ctx *c, uint32 *data, uint16 blocks) +blf_enc(blf_ctx * c, uint32 *data, uint16 blocks) { - uint32 *d; - uint16 i; + uint32 *d; + uint16 i; d = data; - for (i = 0; i < blocks; i++) { + for (i = 0; i < blocks; i++) + { Blowfish_encipher(c, d); d += 2; } } void -blf_dec(blf_ctx *c, uint32 *data, uint16 blocks) +blf_dec(blf_ctx * c, uint32 *data, uint16 blocks) { - uint32 *d; - uint16 i; + uint32 *d; + uint16 i; d = data; - for (i = 0; i < blocks; i++) { + for (i = 0; i < blocks; i++) + { Blowfish_decipher(c, d); d += 2; } } void -blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len) +blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i; + uint32 l, + r, + d[2]; + uint32 i; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; @@ -553,12 +583,15 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len) } void -blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len) +blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i; + uint32 l, + r, + d[2]; + uint32 i; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; @@ -579,12 +612,16 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len) } void -blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len) +blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i, j; + uint32 l, + r, + d[2]; + uint32 i, + j; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { for (j = 0; j < 8; j++) data[j] ^= iv[j]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; @@ -608,15 +645,19 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len) } void -blf_cbc_decrypt(blf_ctx *c, uint8 *iva, uint8 *data, uint32 len) +blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint8 *iv; - uint32 i, j; + uint32 l, + r, + d[2]; + uint8 *iv; + uint32 i, + j; iv = data + len - 16; data = data + len - 8; - for (i = len - 8; i >= 8; i -= 8) { + for (i = len - 8; i >= 8; i -= 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; diff --git a/contrib/pgcrypto/blf.h b/contrib/pgcrypto/blf.h index daf9703b77..37d4021803 100644 --- a/contrib/pgcrypto/blf.h +++ b/contrib/pgcrypto/blf.h @@ -1,4 +1,4 @@ -/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */ +/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */ /* * Blowfish - a fast block cipher designed by Bruce Schneier @@ -10,15 +10,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by Niels Provos. + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. * 4. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. + * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -42,14 +42,15 @@ * of the key affect all cipherbits. */ -#define BLF_N 16 /* Number of Subkeys */ -#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ +#define BLF_N 16 /* Number of Subkeys */ +#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ /* Blowfish context */ -typedef struct BlowfishContext { - uint32 S[4][256]; /* S-Boxes */ - uint32 P[BLF_N + 2]; /* Subkeys */ -} blf_ctx; +typedef struct BlowfishContext +{ + uint32 S[4][256]; /* S-Boxes */ + uint32 P[BLF_N + 2]; /* Subkeys */ +} blf_ctx; /* Raw access to customized Blowfish * blf_key is just: @@ -57,26 +58,25 @@ typedef struct BlowfishContext { * Blowfish_expand0state( state, key, keylen ) */ -void Blowfish_encipher (blf_ctx *, uint32 *); -void Blowfish_decipher (blf_ctx *, uint32 *); -void Blowfish_initstate (blf_ctx *); -void Blowfish_expand0state (blf_ctx *, const uint8 *, uint16); -void Blowfish_expandstate - (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16); +void Blowfish_encipher(blf_ctx *, uint32 *); +void Blowfish_decipher(blf_ctx *, uint32 *); +void Blowfish_initstate(blf_ctx *); +void Blowfish_expand0state(blf_ctx *, const uint8 *, uint16); +void Blowfish_expandstate + (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16); /* Standard Blowfish */ -void blf_key (blf_ctx *, const uint8 *, uint16); -void blf_enc (blf_ctx *, uint32 *, uint16); -void blf_dec (blf_ctx *, uint32 *, uint16); +void blf_key(blf_ctx *, const uint8 *, uint16); +void blf_enc(blf_ctx *, uint32 *, uint16); +void blf_dec(blf_ctx *, uint32 *, uint16); /* Converts uint8 to uint32 */ -uint32 Blowfish_stream2word (const uint8 *, uint16, uint16 *); +uint32 Blowfish_stream2word(const uint8 *, uint16, uint16 *); -void blf_ecb_encrypt (blf_ctx *, uint8 *, uint32); -void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32); - -void blf_cbc_encrypt (blf_ctx *, uint8 *, uint8 *, uint32); -void blf_cbc_decrypt (blf_ctx *, uint8 *, uint8 *, uint32); +void blf_ecb_encrypt(blf_ctx *, uint8 *, uint32); +void blf_ecb_decrypt(blf_ctx *, uint8 *, uint32); +void blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32); +void blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32); #endif diff --git a/contrib/pgcrypto/crypt-blowfish.c b/contrib/pgcrypto/crypt-blowfish.c index d60807f241..3bc8e19fa9 100644 --- a/contrib/pgcrypto/crypt-blowfish.c +++ b/contrib/pgcrypto/crypt-blowfish.c @@ -57,10 +57,11 @@ typedef unsigned int BF_word; typedef BF_word BF_key[BF_N + 2]; -typedef struct { - BF_word S[4][0x100]; - BF_key P; -} BF_ctx; +typedef struct +{ + BF_word S[4][0x100]; + BF_key P; +} BF_ctx; /* * Magic IV for 64 Blowfish encryptions that we do at the end. @@ -347,7 +348,7 @@ static BF_ctx BF_init_state = { }; static unsigned char BF_itoa64[64 + 1] = - "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; +"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; static unsigned char BF_atoi64[0x60] = { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1, @@ -367,22 +368,30 @@ do { \ (dst) = tmp; \ } while (0) -static int BF_decode(BF_word *dst, const char *src, int size) +static int +BF_decode(BF_word * dst, const char *src, int size) { - unsigned char *dptr = (unsigned char *)dst; + unsigned char *dptr = (unsigned char *) dst; unsigned char *end = dptr + size; - unsigned char *sptr = (unsigned char *)src; - unsigned int tmp, c1, c2, c3, c4; - - do { + unsigned char *sptr = (unsigned char *) src; + unsigned int tmp, + c1, + c2, + c3, + c4; + + do + { BF_safe_atoi64(c1, *sptr++); BF_safe_atoi64(c2, *sptr++); *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4); - if (dptr >= end) break; + if (dptr >= end) + break; BF_safe_atoi64(c3, *sptr++); *dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2); - if (dptr >= end) break; + if (dptr >= end) + break; BF_safe_atoi64(c4, *sptr++); *dptr++ = ((c3 & 0x03) << 6) | c4; @@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size) return 0; } -static void BF_encode(char *dst, const BF_word *src, int size) +static void +BF_encode(char *dst, const BF_word * src, int size) { - unsigned char *sptr = (unsigned char *)src; + unsigned char *sptr = (unsigned char *) src; unsigned char *end = sptr + size; - unsigned char *dptr = (unsigned char *)dst; - unsigned int c1, c2; + unsigned char *dptr = (unsigned char *) dst; + unsigned int c1, + c2; - do { + do + { c1 = *sptr++; *dptr++ = BF_itoa64[c1 >> 2]; c1 = (c1 & 0x03) << 4; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size) c1 |= c2 >> 4; *dptr++ = BF_itoa64[c1]; c1 = (c2 & 0x0f) << 2; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -423,18 +437,20 @@ static void BF_encode(char *dst, const BF_word *src, int size) } while (sptr < end); } -static void BF_swap(BF_word *x, int count) +static void +BF_swap(BF_word * x, int count) { - static int endianness_check = 1; - char *is_little_endian = (char *)&endianness_check; - BF_word tmp; + static int endianness_check = 1; + char *is_little_endian = (char *) &endianness_check; + BF_word tmp; if (*is_little_endian) - do { - tmp = *x; - tmp = (tmp << 16) | (tmp >> 16); - *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); - } while (--count); + do + { + tmp = *x; + tmp = (tmp << 16) | (tmp >> 16); + *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); + } while (--count); } #if BF_SCALE @@ -504,7 +520,8 @@ static void BF_swap(BF_word *x, int count) #if BF_ASM -extern void _BF_body_r(BF_ctx *ctx); +extern void _BF_body_r(BF_ctx * ctx); + #define BF_body() \ _BF_body_r(&data.ctx); @@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx); *(ptr - 2) = L; \ *(ptr - 1) = R; \ } while (ptr < &data.ctx.S[3][0xFF]); - #endif -static void BF_set_key(const char *key, BF_key expanded, BF_key initial) +static void +BF_set_key(const char *key, BF_key expanded, BF_key initial) { const char *ptr = key; - int i, j; - BF_word tmp; + int i, + j; + BF_word tmp; - for (i = 0; i < BF_N + 2; i++) { + for (i = 0; i < BF_N + 2; i++) + { tmp = 0; - for (j = 0; j < 4; j++) { + for (j = 0; j < 4; j++) + { tmp <<= 8; tmp |= *ptr; - if (!*ptr) ptr = key; else ptr++; + if (!*ptr) + ptr = key; + else + ptr++; } expanded[i] = tmp; @@ -550,41 +573,51 @@ static void BF_set_key(const char *key, BF_key expanded, BF_key initial) } } -char *_crypt_blowfish_rn(const char *key, const char *setting, - char *output, int size) +char * +_crypt_blowfish_rn(const char *key, const char *setting, + char *output, int size) { - struct { - BF_ctx ctx; - BF_key expanded_key; - union { - BF_word salt[4]; - BF_word output[6]; - } binary; - } data; - BF_word L, R; - BF_word tmp1, tmp2, tmp3, tmp4; - BF_word *ptr; - BF_word count; - int i; - - if (size < 7 + 22 + 31 + 1) { + struct + { + BF_ctx ctx; + BF_key expanded_key; + union + { + BF_word salt[4]; + BF_word output[6]; + } binary; + } data; + BF_word L, + R; + BF_word tmp1, + tmp2, + tmp3, + tmp4; + BF_word *ptr; + BF_word count; + int i; + + if (size < 7 + 22 + 31 + 1) + { __set_errno(ERANGE); return NULL; } if (setting[0] != '$' || - setting[1] != '2' || - setting[2] != 'a' || - setting[3] != '$' || - setting[4] < '0' || setting[4] > '3' || - setting[5] < '0' || setting[5] > '9' || - setting[6] != '$') { + setting[1] != '2' || + setting[2] != 'a' || + setting[3] != '$' || + setting[4] < '0' || setting[4] > '3' || + setting[5] < '0' || setting[5] > '9' || + setting[6] != '$') + { __set_errno(EINVAL); return NULL; } - count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); - if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) { + count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); + if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) + { memset(data.binary.salt, 0, sizeof(data.binary.salt)); __set_errno(EINVAL); return NULL; @@ -596,7 +629,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S)); L = R = 0; - for (i = 0; i < BF_N + 2; i += 2) { + for (i = 0; i < BF_N + 2; i += 2) + { L ^= data.binary.salt[i & 2]; R ^= data.binary.salt[(i & 2) + 1]; BF_ENCRYPT; @@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, } ptr = data.ctx.S[0]; - do { + do + { ptr += 4; L ^= data.binary.salt[(BF_N + 2) & 3]; R ^= data.binary.salt[(BF_N + 3) & 3]; @@ -620,7 +655,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, *(ptr - 1) = R; } while (ptr < &data.ctx.S[3][0xFF]); - do { + do + { data.ctx.P[0] ^= data.expanded_key[0]; data.ctx.P[1] ^= data.expanded_key[1]; data.ctx.P[2] ^= data.expanded_key[2]; @@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, BF_body(); } while (--count); - for (i = 0; i < 6; i += 2) { + for (i = 0; i < 6; i += 2) + { L = BF_magic_w[i]; R = BF_magic_w[i + 1]; count = 64; - do { + do + { BF_ENCRYPT; } while (--count); @@ -683,7 +721,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, memcpy(output, setting, 7 + 22 - 1); output[7 + 22 - 1] = BF_itoa64[(int) - BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30]; + BF_atoi64[(int) setting[7 + 22 - 1] - 0x20] & 0x30]; /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ @@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, return output; } - diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c index de6b1865e3..eacb192ad0 100644 --- a/contrib/pgcrypto/crypt-des.c +++ b/contrib/pgcrypto/crypt-des.c @@ -244,8 +244,8 @@ des_init() } /* - * Convert the inverted S-boxes into 4 arrays of 8 bits. - * Each will handle 12 bits of the S-box input. + * Convert the inverted S-boxes into 4 arrays of 8 bits. Each will + * handle 12 bits of the S-box input. */ for (b = 0; b < 4; b++) for (i = 0; i < 64; i++) @@ -409,10 +409,9 @@ des_setkey(const char *key) && rawkey1 == old_rawkey1) { /* - * Already setup for this key. - * This optimisation fails on a zero key (which is weak and - * has bad parity anyway) in order to simplify the starting - * conditions. + * Already setup for this key. This optimisation fails on a zero + * key (which is weak and has bad parity anyway) in order to + * simplify the starting conditions. */ return (0); } @@ -420,7 +419,7 @@ des_setkey(const char *key) old_rawkey1 = rawkey1; /* - * Do key permutation and split into two 28-bit subkeys. + * Do key permutation and split into two 28-bit subkeys. */ k0 = key_perm_maskl[0][rawkey0 >> 25] | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f] @@ -438,8 +437,9 @@ des_setkey(const char *key) | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f] | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f] | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f]; + /* - * Rotate subkeys and do compression permutation. + * Rotate subkeys and do compression permutation. */ shifts = 0; for (round = 0; round < 16; round++) @@ -476,10 +476,10 @@ des_setkey(const char *key) } static int -do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) +do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count) { /* - * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format. + * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format. */ uint32 l, r, @@ -513,7 +513,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) } /* - * Do initial permutation (IP). + * Do initial permutation (IP). */ l = ip_maskl[0][l_in >> 24] | ip_maskl[1][(l_in >> 16) & 0xff] @@ -556,21 +556,24 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) | ((r & 0x000001f8) << 3) | ((r & 0x0000001f) << 1) | ((r & 0x80000000) >> 31); + /* - * Do salting for crypt() and friends, and - * XOR with the permuted key. + * Do salting for crypt() and friends, and XOR with the + * permuted key. */ f = (r48l ^ r48r) & saltbits; r48l ^= f ^ *kl++; r48r ^= f ^ *kr++; + /* - * Do sbox lookups (which shrink it back to 32 bits) - * and do the pbox permutation at the same time. + * Do sbox lookups (which shrink it back to 32 bits) and do + * the pbox permutation at the same time. */ f = psbox[0][m_sbox[0][r48l >> 12]] | psbox[1][m_sbox[1][r48l & 0xfff]] | psbox[2][m_sbox[2][r48r >> 12]] | psbox[3][m_sbox[3][r48r & 0xfff]]; + /* * Now that we've permuted things, complete f(). */ @@ -581,6 +584,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) r = l; l = f; } + /* * Do final permutation (inverse of IP). */ @@ -654,8 +658,8 @@ px_crypt_des(const char *key, const char *setting) /* - * Copy the key, shifting each character up by one bit - * and padding with zeros. + * Copy the key, shifting each character up by one bit and padding + * with zeros. */ q = (uint8 *) keybuf; while (q - (uint8 *) keybuf - 8) @@ -670,9 +674,8 @@ px_crypt_des(const char *key, const char *setting) if (*setting == _PASSWORD_EFMT1) { /* - * "new"-style: - * setting - underscore, 4 bytes of count, 4 bytes of salt - * key - unlimited characters + * "new"-style: setting - underscore, 4 bytes of count, 4 bytes of + * salt key - unlimited characters */ for (i = 1, count = 0L; i < 5; i++) count |= ascii_to_bin(setting[i]) << (i - 1) * 6; @@ -687,6 +690,7 @@ px_crypt_des(const char *key, const char *setting) */ if (des_cipher((uint8 *) keybuf, (uint8 *) keybuf, 0L, 1)) return (NULL); + /* * And XOR with the next 8 characters of the key. */ @@ -700,11 +704,10 @@ px_crypt_des(const char *key, const char *setting) strncpy(output, setting, 9); /* - * Double check that we weren't given a short setting. - * If we were, the above code will probably have created - * wierd values for count and salt, but we don't really care. - * Just make sure the output string doesn't have an extra - * NUL in it. + * Double check that we weren't given a short setting. If we were, + * the above code will probably have created wierd values for + * count and salt, but we don't really care. Just make sure the + * output string doesn't have an extra NUL in it. */ output[9] = '\0'; p = output + strlen(output); @@ -713,9 +716,7 @@ px_crypt_des(const char *key, const char *setting) #endif /* !DISABLE_XDES */ { /* - * "old"-style: - * setting - 2 bytes of salt - * key - up to 8 characters + * "old"-style: setting - 2 bytes of salt key - up to 8 characters */ count = 25; @@ -723,22 +724,24 @@ px_crypt_des(const char *key, const char *setting) | ascii_to_bin(setting[0]); output[0] = setting[0]; + /* - * If the encrypted password that the salt was extracted from - * is only 1 character long, the salt will be corrupted. We - * need to ensure that the output string doesn't have an extra - * NUL in it! + * If the encrypted password that the salt was extracted from is + * only 1 character long, the salt will be corrupted. We need to + * ensure that the output string doesn't have an extra NUL in it! */ output[1] = setting[1] ? setting[1] : output[0]; p = output + 2; } setup_salt(salt); + /* * Do it. */ if (do_des(0L, 0L, &r0, &r1, count)) return (NULL); + /* * Now encode the result... */ diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c index 6913826842..9c017b0e4d 100644 --- a/contrib/pgcrypto/crypt-gensalt.c +++ b/contrib/pgcrypto/crypt-gensalt.c @@ -7,7 +7,7 @@ * entirely in crypt_blowfish.c. * * Put bcrypt generator also here as crypt-blowfish.c - * may not be compiled always. -- marko + * may not be compiled always. -- marko */ #include "postgres.h" @@ -22,48 +22,55 @@ typedef unsigned int BF_word; unsigned char _crypt_itoa64[64 + 1] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; -char *_crypt_gensalt_traditional_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_traditional_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { - if (size < 2 || output_size < 2 + 1 || (count && count != 25)) { - if (output_size > 0) output[0] = '\0'; + if (size < 2 || output_size < 2 + 1 || (count && count != 25)) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 2 + 1) ? ERANGE : EINVAL); return NULL; } - output[0] = _crypt_itoa64[(unsigned int)input[0] & 0x3f]; - output[1] = _crypt_itoa64[(unsigned int)input[1] & 0x3f]; + output[0] = _crypt_itoa64[(unsigned int) input[0] & 0x3f]; + output[1] = _crypt_itoa64[(unsigned int) input[1] & 0x3f]; output[2] = '\0'; return output; } -char *_crypt_gensalt_extended_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_extended_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { unsigned long value; /* Even iteration counts make it easier to detect weak DES keys from a look * at the hash, so they should be avoided */ if (size < 3 || output_size < 1 + 4 + 4 + 1 || - (count && (count > 0xffffff || !(count & 1)))) { - if (output_size > 0) output[0] = '\0'; + (count && (count > 0xffffff || !(count & 1)))) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL); return NULL; } - if (!count) count = 725; + if (!count) + count = 725; output[0] = '_'; output[1] = _crypt_itoa64[count & 0x3f]; output[2] = _crypt_itoa64[(count >> 6) & 0x3f]; output[3] = _crypt_itoa64[(count >> 12) & 0x3f]; output[4] = _crypt_itoa64[(count >> 18) & 0x3f]; - value = (unsigned long)input[0] | - ((unsigned long)input[1] << 8) | - ((unsigned long)input[2] << 16); + value = (unsigned long) input[0] | + ((unsigned long) input[1] << 8) | + ((unsigned long) input[2] << 16); output[5] = _crypt_itoa64[value & 0x3f]; output[6] = _crypt_itoa64[(value >> 6) & 0x3f]; output[7] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count, return output; } -char *_crypt_gensalt_md5_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_md5_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { unsigned long value; - if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) { - if (output_size > 0) output[0] = '\0'; + if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL); return NULL; } @@ -87,19 +97,20 @@ char *_crypt_gensalt_md5_rn(unsigned long count, output[0] = '$'; output[1] = '1'; output[2] = '$'; - value = (unsigned long)input[0] | - ((unsigned long)input[1] << 8) | - ((unsigned long)input[2] << 16); + value = (unsigned long) input[0] | + ((unsigned long) input[1] << 8) | + ((unsigned long) input[2] << 16); output[3] = _crypt_itoa64[value & 0x3f]; output[4] = _crypt_itoa64[(value >> 6) & 0x3f]; output[5] = _crypt_itoa64[(value >> 12) & 0x3f]; output[6] = _crypt_itoa64[(value >> 18) & 0x3f]; output[7] = '\0'; - if (size >= 6 && output_size >= 3 + 4 + 4 + 1) { - value = (unsigned long)input[3] | - ((unsigned long)input[4] << 8) | - ((unsigned long)input[5] << 16); + if (size >= 6 && output_size >= 3 + 4 + 4 + 1) + { + value = (unsigned long) input[3] | + ((unsigned long) input[4] << 8) | + ((unsigned long) input[5] << 16); output[7] = _crypt_itoa64[value & 0x3f]; output[8] = _crypt_itoa64[(value >> 6) & 0x3f]; output[9] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -113,20 +124,24 @@ char *_crypt_gensalt_md5_rn(unsigned long count, static unsigned char BF_itoa64[64 + 1] = - "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; +"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; -static void BF_encode(char *dst, const BF_word *src, int size) +static void +BF_encode(char *dst, const BF_word * src, int size) { - unsigned char *sptr = (unsigned char *)src; + unsigned char *sptr = (unsigned char *) src; unsigned char *end = sptr + size; - unsigned char *dptr = (unsigned char *)dst; - unsigned int c1, c2; + unsigned char *dptr = (unsigned char *) dst; + unsigned int c1, + c2; - do { + do + { c1 = *sptr++; *dptr++ = BF_itoa64[c1 >> 2]; c1 = (c1 & 0x03) << 4; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size) c1 |= c2 >> 4; *dptr++ = BF_itoa64[c1]; c1 = (c2 & 0x0f) << 2; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size) } while (sptr < end); } -char *_crypt_gensalt_blowfish_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_blowfish_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { if (size < 16 || output_size < 7 + 22 + 1 || - (count && (count < 4 || count > 31))) { - if (output_size > 0) output[0] = '\0'; + (count && (count < 4 || count > 31))) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL); return NULL; } - if (!count) count = 5; + if (!count) + count = 5; output[0] = '$'; output[1] = '2'; @@ -167,9 +187,8 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count, output[5] = '0' + count % 10; output[6] = '$'; - BF_encode(&output[7], (BF_word *)input, 16); + BF_encode(&output[7], (BF_word *) input, 16); output[7 + 22] = '\0'; return output; } - diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c index 02fba69496..7b45bb2151 100644 --- a/contrib/pgcrypto/crypt-md5.c +++ b/contrib/pgcrypto/crypt-md5.c @@ -9,7 +9,7 @@ * $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $ * */ -/* $Id: crypt-md5.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ */ +/* $Id: crypt-md5.c,v 1.2 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> #include "px.h" @@ -23,12 +23,9 @@ char * px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) { - static char *magic = "$1$"; /* - * This string is magic for - * this algorithm. Having - * it this way, we can get - * get better later on - */ + static char *magic = "$1$"; /* This string is magic for this + * algorithm. Having it this way, we can + * get get better later on */ static char *p; static const char *sp, *ep; @@ -43,7 +40,7 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) if (!passwd || dstlen < 120) return NULL; - + /* Refine the Salt first */ sp = salt; @@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) px_md_finish(ctx, final); /* - * and now, just to make sure things don't run too fast - * On a 60 Mhz Pentium this takes 34 msec, so you would - * need 30 seconds to build a 1000 entry dictionary... + * and now, just to make sure things don't run too fast On a 60 Mhz + * Pentium this takes 34 msec, so you would need 30 seconds to build a + * 1000 entry dictionary... */ for (i = 0; i < 1000; i++) { diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c index 421f5f1739..00ff81e5b7 100644 --- a/contrib/pgcrypto/internal.c +++ b/contrib/pgcrypto/internal.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: internal.c,v 1.5 2001/10/15 19:12:48 tgl Exp $ + * $Id: internal.c,v 1.6 2001/10/25 05:49:19 momjian Exp $ */ @@ -61,11 +61,18 @@ static struct int_digest { char *name; void (*init) (PX_MD * h); -} int_digest_list[] = +} int_digest_list[] = + { - { "md5", init_md5 }, - { "sha1", init_sha1 }, - { NULL, NULL } + { + "md5", init_md5 + }, + { + "sha1", init_sha1 + }, + { + NULL, NULL + } }; /* MD5 */ @@ -83,7 +90,7 @@ int_md5_block_len(PX_MD * h) } static void -int_md5_update(PX_MD * h, const uint8 * data, uint dlen) +int_md5_update(PX_MD * h, const uint8 *data, uint dlen) { MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; @@ -99,7 +106,7 @@ int_md5_reset(PX_MD * h) } static void -int_md5_finish(PX_MD * h, uint8 * dst) +int_md5_finish(PX_MD * h, uint8 *dst) { MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; @@ -130,7 +137,7 @@ int_sha1_block_len(PX_MD * h) } static void -int_sha1_update(PX_MD * h, const uint8 * data, uint dlen) +int_sha1_update(PX_MD * h, const uint8 *data, uint dlen) { SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; @@ -146,7 +153,7 @@ int_sha1_reset(PX_MD * h) } static void -int_sha1_finish(PX_MD * h, uint8 * dst) +int_sha1_finish(PX_MD * h, uint8 *dst) { SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; @@ -209,22 +216,27 @@ init_sha1(PX_MD * md) #define INT_MAX_KEY (512/8) #define INT_MAX_IV (128/8) -struct int_ctx { - uint8 keybuf[INT_MAX_KEY]; - uint8 iv[INT_MAX_IV]; - union { - blf_ctx bf; +struct int_ctx +{ + uint8 keybuf[INT_MAX_KEY]; + uint8 iv[INT_MAX_IV]; + union + { + blf_ctx bf; rijndael_ctx rj; - } ctx; - uint keylen; - int is_init; - int mode; + } ctx; + uint keylen; + int is_init; + int mode; }; -static void intctx_free(PX_Cipher *c) +static void +intctx_free(PX_Cipher * c) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - if (cx) { + struct int_ctx *cx = (struct int_ctx *) c->ptr; + + if (cx) + { memset(cx, 0, sizeof *cx); px_free(cx); } @@ -238,78 +250,88 @@ static void intctx_free(PX_Cipher *c) #define MODE_ECB 0 #define MODE_CBC 1 -static uint rj_block_size(PX_Cipher *c) +static uint +rj_block_size(PX_Cipher * c) { - return 128/8; + return 128 / 8; } -static uint rj_key_size(PX_Cipher *c) +static uint +rj_key_size(PX_Cipher * c) { - return 256/8; + return 256 / 8; } -static uint rj_iv_size(PX_Cipher *c) +static uint +rj_iv_size(PX_Cipher * c) { - return 128/8; + return 128 / 8; } -static int rj_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +static int +rj_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; - if (klen <= 128/8) - cx->keylen = 128/8; - else if (klen <= 192/8) - cx->keylen = 192/8; - else if (klen <= 256/8) - cx->keylen = 256/8; + if (klen <= 128 / 8) + cx->keylen = 128 / 8; + else if (klen <= 192 / 8) + cx->keylen = 192 / 8; + else if (klen <= 256 / 8) + cx->keylen = 256 / 8; else return -1; memcpy(&cx->keybuf, key, klen); if (iv) - memcpy(cx->iv, iv, 128/8); + memcpy(cx->iv, iv, 128 / 8); return 0; } -static int rj_real_init(struct int_ctx *cx, int dir) +static int +rj_real_init(struct int_ctx * cx, int dir) { - aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen*8, dir); + aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir); return 0; } -static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +rj_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - - if (!cx->is_init) { + struct int_ctx *cx = (struct int_ctx *) c->ptr; + + if (!cx->is_init) + { if (rj_real_init(cx, 1)) return -1; } - + if (dlen == 0) return 0; - if ((dlen & 15) || (((unsigned)res) & 3)) + if ((dlen & 15) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - if (cx->mode == MODE_CBC) { + if (cx->mode == MODE_CBC) + { aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen); memcpy(cx->iv, res + dlen - 16, 16); - } else + } + else aes_ecb_encrypt(&cx->ctx.rj, res, dlen); - + return 0; } -static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +rj_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - + struct int_ctx *cx = (struct int_ctx *) c->ptr; + if (!cx->is_init) if (rj_real_init(cx, 0)) return -1; @@ -317,17 +339,19 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) if (dlen == 0) return 0; - if ((dlen & 15) || (((unsigned)res) & 3)) + if ((dlen & 15) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - if (cx->mode == MODE_CBC) { + if (cx->mode == MODE_CBC) + { aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen); memcpy(cx->iv, data + dlen - 16, 16); - } else + } + else aes_ecb_decrypt(&cx->ctx.rj, res, dlen); - + return 0; } @@ -335,11 +359,12 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) * initializers */ -static PX_Cipher * rj_load(int mode) +static PX_Cipher * +rj_load(int mode) { - PX_Cipher *c; + PX_Cipher *c; struct int_ctx *cx; - + c = px_alloc(sizeof *c); memset(c, 0, sizeof *c); @@ -363,24 +388,28 @@ static PX_Cipher * rj_load(int mode) * blowfish */ -static uint bf_block_size(PX_Cipher *c) +static uint +bf_block_size(PX_Cipher * c) { return 8; } -static uint bf_key_size(PX_Cipher *c) +static uint +bf_key_size(PX_Cipher * c) { return BLF_MAXKEYLEN; } -static uint bf_iv_size(PX_Cipher *c) +static uint +bf_iv_size(PX_Cipher * c) { return 8; } -static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +static int +bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; blf_key(&cx->ctx.bf, key, klen); if (iv) @@ -389,55 +418,60 @@ static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) return 0; } -static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +bf_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; if (dlen == 0) return 0; - - if ((dlen & 7) || (((unsigned)res) & 3)) + + if ((dlen & 7) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - switch (cx->mode) { - case MODE_ECB: - blf_ecb_encrypt(&cx->ctx.bf, res, dlen); - break; - case MODE_CBC: - blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen); - memcpy(cx->iv, res + dlen - 8, 8); + switch (cx->mode) + { + case MODE_ECB: + blf_ecb_encrypt(&cx->ctx.bf, res, dlen); + break; + case MODE_CBC: + blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen); + memcpy(cx->iv, res + dlen - 8, 8); } return 0; } -static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +bf_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; if (dlen == 0) return 0; - if ((dlen & 7) || (((unsigned)res) & 3)) + if ((dlen & 7) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - switch (cx->mode) { - case MODE_ECB: - blf_ecb_decrypt(&cx->ctx.bf, res, dlen); - break; - case MODE_CBC: - blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen); - memcpy(cx->iv, data + dlen - 8, 8); + switch (cx->mode) + { + case MODE_ECB: + blf_ecb_decrypt(&cx->ctx.bf, res, dlen); + break; + case MODE_CBC: + blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen); + memcpy(cx->iv, data + dlen - 8, 8); } return 0; } -static PX_Cipher * bf_load(int mode) +static PX_Cipher * +bf_load(int mode) { - PX_Cipher *c; + PX_Cipher *c; struct int_ctx *cx; - + c = px_alloc(sizeof *c); memset(c, 0, sizeof *c); @@ -458,47 +492,64 @@ static PX_Cipher * bf_load(int mode) /* ciphers */ -static PX_Cipher * rj_128_ecb() +static PX_Cipher * +rj_128_ecb() { return rj_load(MODE_ECB); } -static PX_Cipher * rj_128_cbc() +static PX_Cipher * +rj_128_cbc() { return rj_load(MODE_CBC); } -static PX_Cipher * bf_ecb_load() +static PX_Cipher * +bf_ecb_load() { return bf_load(MODE_ECB); } -static PX_Cipher * bf_cbc_load() +static PX_Cipher * +bf_cbc_load() { return bf_load(MODE_CBC); } -static struct { - char *name; - PX_Cipher *(*load)(void); -} int_ciphers [] = { - { "bf-cbc", bf_cbc_load }, - { "bf-ecb", bf_ecb_load }, - { "aes-128-cbc", rj_128_cbc }, - { "aes-128-ecb", rj_128_ecb }, - { NULL, NULL } +static struct +{ + char *name; + PX_Cipher *(*load) (void); +} int_ciphers[] = + +{ + { + "bf-cbc", bf_cbc_load + }, + { + "bf-ecb", bf_ecb_load + }, + { + "aes-128-cbc", rj_128_cbc + }, + { + "aes-128-ecb", rj_128_ecb + }, + { + NULL, NULL + } }; -static PX_Alias int_aliases [] = { - { "bf", "bf-cbc" }, - { "blowfish", "bf-cbc" }, - { "aes", "aes-128-cbc" }, - { "aes-ecb", "aes-128-ecb" }, - { "aes-cbc", "aes-128-cbc" }, - { "aes-128", "aes-128-cbc" }, - { "rijndael", "aes-128-cbc" }, - { "rijndael-128", "aes-128-cbc" }, - { NULL, NULL } +static PX_Alias int_aliases[] = { + {"bf", "bf-cbc"}, + {"blowfish", "bf-cbc"}, + {"aes", "aes-128-cbc"}, + {"aes-ecb", "aes-128-ecb"}, + {"aes-cbc", "aes-128-cbc"}, + {"aes-128", "aes-128-cbc"}, + {"rijndael", "aes-128-cbc"}, + {"rijndael-128", "aes-128-cbc"}, + {NULL, NULL} }; /* PUBLIC FUNCTIONS */ @@ -523,15 +574,16 @@ px_find_digest(const char *name, PX_MD ** res) } int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - int i; - PX_Cipher *c = NULL; + int i; + PX_Cipher *c = NULL; name = px_resolve_alias(int_aliases, name); for (i = 0; int_ciphers[i].name; i++) - if (!strcmp(int_ciphers[i].name, name)) { + if (!strcmp(int_ciphers[i].name, name)) + { c = int_ciphers[i].load(); break; } @@ -542,5 +594,3 @@ px_find_cipher(const char *name, PX_Cipher **res) *res = c; return 0; } - - diff --git a/contrib/pgcrypto/md5.c b/contrib/pgcrypto/md5.c index d022d61627..4b03f19606 100644 --- a/contrib/pgcrypto/md5.c +++ b/contrib/pgcrypto/md5.c @@ -1,4 +1,4 @@ -/* $Id: md5.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */ +/* $Id: md5.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ */ /* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */ /* @@ -132,7 +132,7 @@ static const uint8 md5_paddat[MD5_BUFLEN] = { static void md5_calc(uint8 *, md5_ctxt *); void -md5_init(md5_ctxt *ctxt) +md5_init(md5_ctxt * ctxt) { ctxt->md5_n = 0; ctxt->md5_i = 0; @@ -144,7 +144,7 @@ md5_init(md5_ctxt *ctxt) } void -md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len) +md5_loop(md5_ctxt * ctxt, const uint8 *input, unsigned len) { unsigned int gap, i; @@ -173,7 +173,7 @@ md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len) } void -md5_pad(md5_ctxt *ctxt) +md5_pad(md5_ctxt * ctxt) { unsigned int gap; @@ -215,7 +215,7 @@ md5_pad(md5_ctxt *ctxt) } void -md5_result(uint8 *digest, md5_ctxt *ctxt) +md5_result(uint8 *digest, md5_ctxt * ctxt) { /* 4 byte words */ #if BYTE_ORDER == LITTLE_ENDIAN @@ -242,11 +242,11 @@ md5_result(uint8 *digest, md5_ctxt *ctxt) } #if BYTE_ORDER == BIG_ENDIAN -static uint32 X[16]; +static uint32 X[16]; #endif static void -md5_calc(uint8 *b64, md5_ctxt *ctxt) +md5_calc(uint8 *b64, md5_ctxt * ctxt) { uint32 A = ctxt->md5_sta; uint32 B = ctxt->md5_stb; diff --git a/contrib/pgcrypto/mhash.c b/contrib/pgcrypto/mhash.c index 36d70471a9..8811232c37 100644 --- a/contrib/pgcrypto/mhash.c +++ b/contrib/pgcrypto/mhash.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: mhash.c,v 1.4 2001/08/21 00:42:41 momjian Exp $ + * $Id: mhash.c,v 1.5 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -75,7 +75,7 @@ digest_reset(PX_MD * h) } static void -digest_update(PX_MD * h, const uint8 * data, uint dlen) +digest_update(PX_MD * h, const uint8 *data, uint dlen) { MHASH mh = (MHASH) h->p.ptr; @@ -83,7 +83,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen) } static void -digest_finish(PX_MD * h, uint8 * dst) +digest_finish(PX_MD * h, uint8 *dst) { MHASH mh = (MHASH) h->p.ptr; uint hlen = digest_result_size(h); @@ -111,34 +111,37 @@ digest_free(PX_MD * h) /* ENCRYPT / DECRYPT */ static uint -cipher_block_size(PX_Cipher *c) +cipher_block_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_get_block_size(ctx); } static uint -cipher_key_size(PX_Cipher *c) +cipher_key_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_get_key_size(ctx); } static uint -cipher_iv_size(PX_Cipher *c) +cipher_iv_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_mode_has_iv(ctx) ? mcrypt_enc_get_iv_size(ctx) : 0; } static int -cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +cipher_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; - err = mcrypt_generic_init(ctx, (char *)key, klen, (char*)iv); + err = mcrypt_generic_init(ctx, (char *) key, klen, (char *) iv); if (err < 0) elog(ERROR, "mcrypt_generic_init error: %s", mcrypt_strerror(err)); @@ -147,10 +150,10 @@ cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) } static int -cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +cipher_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; memcpy(res, data, dlen); @@ -161,10 +164,10 @@ cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) } static int -cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +cipher_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; memcpy(res, data, dlen); @@ -176,15 +179,15 @@ cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) static void -cipher_free(PX_Cipher *c) +cipher_free(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; if (c->pstat) mcrypt_generic_end(ctx); else mcrypt_module_close(ctx); - + px_free(c); } @@ -223,33 +226,34 @@ static char *modes[] = { }; static PX_Alias aliases[] = { - {"bf", "blowfish" }, - {"3des", "tripledes" }, - {"des3", "tripledes" }, - {"aes", "rijndael-128" }, - {"rijndael", "rijndael-128" }, - {"aes-128", "rijndael-128" }, - {"aes-192", "rijndael-192" }, - {"aes-256", "rijndael-256" }, - { NULL, NULL } + {"bf", "blowfish"}, + {"3des", "tripledes"}, + {"des3", "tripledes"}, + {"aes", "rijndael-128"}, + {"rijndael", "rijndael-128"}, + {"aes-128", "rijndael-128"}, + {"aes-192", "rijndael-192"}, + {"aes-256", "rijndael-256"}, + {NULL, NULL} }; static PX_Alias mode_aliases[] = { -#if 0 /* N/A */ - { "cfb", "ncfb" }, - { "ofb", "nofb" }, - { "cfb64", "ncfb" }, +#if 0 /* N/A */ + {"cfb", "ncfb"}, + {"ofb", "nofb"}, + {"cfb64", "ncfb"}, #endif /* { "ofb64", "nofb" }, not sure it works */ - { "cfb8", "cfb" }, - { "ofb8", "ofb" }, - { NULL, NULL } + {"cfb8", "cfb"}, + {"ofb8", "ofb"}, + {NULL, NULL} }; -static int is_mode(char *s) +static int +is_mode(char *s) { - char **p; - + char **p; + if (*s >= '0' && *s <= '9') return 0; @@ -263,7 +267,7 @@ static int is_mode(char *s) /* PUBLIC FUNCTIONS */ int -px_find_digest(const char *name, PX_MD **res) +px_find_digest(const char *name, PX_MD ** res) { PX_MD *h; MHASH mh; @@ -290,19 +294,21 @@ px_find_digest(const char *name, PX_MD **res) int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - char nbuf[PX_MAX_NAMELEN + 1]; + char nbuf[PX_MAX_NAMELEN + 1]; const char *mode = NULL; - char *p; - MCRYPT ctx; + char *p; + MCRYPT ctx; - PX_Cipher *c; + PX_Cipher *c; strcpy(nbuf, name); - - if ((p = strrchr(nbuf, '-')) != NULL) { - if (is_mode(p + 1)) { + + if ((p = strrchr(nbuf, '-')) != NULL) + { + if (is_mode(p + 1)) + { mode = p + 1; *p = 0; } @@ -310,19 +316,19 @@ px_find_cipher(const char *name, PX_Cipher **res) name = px_resolve_alias(aliases, nbuf); - if (!mode) { + if (!mode) + { mode = "cbc"; + /* - if (mcrypt_module_is_block_algorithm(name, NULL)) - mode = "cbc"; - else - mode = "stream"; - */ + * if (mcrypt_module_is_block_algorithm(name, NULL)) mode = "cbc"; + * else mode = "stream"; + */ } mode = px_resolve_alias(mode_aliases, mode); - - ctx = mcrypt_module_open((char*)name, NULL, (char*)mode, NULL); - if (ctx == (void*)MCRYPT_FAILED) + + ctx = mcrypt_module_open((char *) name, NULL, (char *) mode, NULL); + if (ctx == (void *) MCRYPT_FAILED) return -1; c = palloc(sizeof *c); @@ -339,4 +345,3 @@ px_find_cipher(const char *name, PX_Cipher **res) *res = c; return 0; } - diff --git a/contrib/pgcrypto/misc.c b/contrib/pgcrypto/misc.c index 7a3c429708..5c803c0d5b 100644 --- a/contrib/pgcrypto/misc.c +++ b/contrib/pgcrypto/misc.c @@ -33,7 +33,7 @@ #include "px-crypt.h" char px_crypt_a64[] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; /* 0000000000111111111122222222223333333333444444444455555555556666 */ /* 0123456789012345678901234567890123456789012345678901234567890123 */ diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c index 6b2ae9c98a..f9769b7e20 100644 --- a/contrib/pgcrypto/openssl.c +++ b/contrib/pgcrypto/openssl.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: openssl.c,v 1.5 2001/09/23 04:12:44 momjian Exp $ + * $Id: openssl.c,v 1.6 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -60,7 +60,7 @@ digest_reset(PX_MD * h) } static void -digest_update(PX_MD * h, const uint8 * data, uint dlen) +digest_update(PX_MD * h, const uint8 *data, uint dlen) { EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; @@ -68,7 +68,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen) } static void -digest_finish(PX_MD * h, uint8 * dst) +digest_finish(PX_MD * h, uint8 *dst) { EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; @@ -94,50 +94,57 @@ digest_free(PX_MD * h) */ -typedef struct { - union { - struct { - BF_KEY key; - int num; - } bf; +typedef struct +{ + union + { + struct + { + BF_KEY key; + int num; + } bf; EVP_CIPHER_CTX evp_ctx; - } u; + } u; const EVP_CIPHER *evp_ciph; - uint8 key[EVP_MAX_KEY_LENGTH]; - uint8 iv[EVP_MAX_IV_LENGTH]; - uint klen; - uint init; -} ossldata; + uint8 key[EVP_MAX_KEY_LENGTH]; + uint8 iv[EVP_MAX_IV_LENGTH]; + uint klen; + uint init; +} ossldata; /* generic EVP */ static uint -gen_evp_block_size(PX_Cipher *c) +gen_evp_block_size(PX_Cipher * c) { - ossldata *od = (ossldata *)c->ptr; + ossldata *od = (ossldata *) c->ptr; + return EVP_CIPHER_block_size(od->evp_ciph); } static uint -gen_evp_key_size(PX_Cipher *c) +gen_evp_key_size(PX_Cipher * c) { - ossldata *od = (ossldata *)c->ptr; + ossldata *od = (ossldata *) c->ptr; + return EVP_CIPHER_key_length(od->evp_ciph); } static uint -gen_evp_iv_size(PX_Cipher *c) +gen_evp_iv_size(PX_Cipher * c) { - uint ivlen; - ossldata *od = (ossldata *)c->ptr; + uint ivlen; + ossldata *od = (ossldata *) c->ptr; + ivlen = EVP_CIPHER_iv_length(od->evp_ciph); return ivlen; } static void -gen_evp_free(PX_Cipher *c) +gen_evp_free(PX_Cipher * c) { - ossldata *od = (ossldata*)c->ptr; + ossldata *od = (ossldata *) c->ptr; + memset(od, 0, sizeof(*od)); pfree(od); pfree(c); @@ -146,13 +153,14 @@ gen_evp_free(PX_Cipher *c) /* fun */ static int -gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +gen_evp_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - ossldata *od = (ossldata*)c->ptr; - uint bs = gen_evp_block_size(c); - if (iv) { + ossldata *od = (ossldata *) c->ptr; + uint bs = gen_evp_block_size(c); + + if (iv) memcpy(od->iv, iv, bs); - } else + else memset(od->iv, 0, bs); memcpy(od->key, key, klen); od->klen = klen; @@ -161,19 +169,20 @@ gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) } static void -_gen_init(PX_Cipher *c, int enc) +_gen_init(PX_Cipher * c, int enc) { - ossldata *od = c->ptr; - + ossldata *od = c->ptr; + od->evp_ciph->init(&od->u.evp_ctx, od->key, od->iv, enc); od->init = 1; od->u.evp_ctx.encrypt = enc; } static int -gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +gen_evp_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + if (!od->init) _gen_init(c, 1); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); @@ -181,9 +190,10 @@ gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) } static int -gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +gen_evp_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + if (!od->init) _gen_init(c, 0); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); @@ -193,84 +203,95 @@ gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) /* Blowfish */ static int -bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_set_key(&od->u.bf.key, klen, key); - if (iv) { + if (iv) memcpy(od->iv, iv, BF_BLOCK); - } else + else memset(od->iv, 0, BF_BLOCK); od->u.bf.num = 0; return 0; } static int -bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - uint bs = gen_evp_block_size(c), i; - ossldata *od = c->ptr; + uint bs = gen_evp_block_size(c), + i; + ossldata *od = c->ptr; + for (i = 0; i < dlen / bs; i++) - BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_ENCRYPT); + BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_ENCRYPT); return 0; } static int -bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - uint bs = gen_evp_block_size(c), i; - ossldata *od = c->ptr; + uint bs = gen_evp_block_size(c), + i; + ossldata *od = c->ptr; + for (i = 0; i < dlen / bs; i++) - BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_DECRYPT); + BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_DECRYPT); return 0; } static int -bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT); return 0; } static int -bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT); return 0; } static int -bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, - &od->u.bf.num, BF_ENCRYPT); + &od->u.bf.num, BF_ENCRYPT); return 0; } static int -bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, - &od->u.bf.num, BF_DECRYPT); + &od->u.bf.num, BF_DECRYPT); return 0; } static int -bf_ofb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ofb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); return 0; } static int -bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ofb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); return 0; } @@ -279,14 +300,14 @@ bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) * aliases */ -static PX_Alias ossl_aliases [] = { - { "bf", "bf-cbc" }, - { "blowfish", "bf-cbc" }, - { "blowfish-cbc", "bf-cbc" }, - { "blowfish-ecb", "bf-ecb" }, - { "blowfish-cfb", "bf-cfb" }, - { "blowfish-ofb", "bf-ofb" }, - { NULL } +static PX_Alias ossl_aliases[] = { + {"bf", "bf-cbc"}, + {"blowfish", "bf-cbc"}, + {"blowfish-cbc", "bf-cbc"}, + {"blowfish-ecb", "bf-ecb"}, + {"blowfish-cfb", "bf-cfb"}, + {"blowfish-ofb", "bf-ofb"}, + {NULL} }; /* @@ -299,19 +320,44 @@ static PX_Alias ossl_mode_aliases [] = { /* * Special handlers */ -struct { - char *name; - PX_Cipher cf; -} spec_types [] = { - { "bf-cbc", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free}}, - { "bf-ecb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free}}, - { "bf-cfb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free}}, - { "bf-ofb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free}}, - { NULL } +struct +{ + char *name; + PX_Cipher cf; +} spec_types[] = + +{ + { + "bf-cbc", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free + } + }, + { + "bf-ecb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free + } + }, + { + "bf-cfb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free + } + }, + { + "bf-ofb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free + } + }, + { + NULL + } }; /* @@ -322,7 +368,7 @@ static PX_Cipher gen_evp_handler = { gen_evp_init, gen_evp_encrypt, gen_evp_decrypt, gen_evp_free }; -static int px_openssl_initialized = 0; +static int px_openssl_initialized = 0; /* ATM not needed static void *o_alloc(uint s) { return px_alloc(s); } @@ -333,7 +379,7 @@ static void o_free(void *p) { px_free(p); } /* PUBLIC functions */ int -px_find_digest(const char *name, PX_MD **res) +px_find_digest(const char *name, PX_MD ** res) { const EVP_MD *md; EVP_MD_CTX *ctx; @@ -342,7 +388,7 @@ px_find_digest(const char *name, PX_MD **res) if (!px_openssl_initialized) { px_openssl_initialized = 1; - /*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ + /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */ OpenSSL_add_all_algorithms(); } @@ -368,17 +414,19 @@ px_find_digest(const char *name, PX_MD **res) int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - uint i; - PX_Cipher *c = NULL, *csrc; - ossldata *od; + uint i; + PX_Cipher *c = NULL, + *csrc; + ossldata *od; const EVP_CIPHER *evp_c; - if (!px_openssl_initialized) { + if (!px_openssl_initialized) + { px_openssl_initialized = 1; - /*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ + /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */ OpenSSL_add_all_algorithms(); } @@ -390,23 +438,23 @@ px_find_cipher(const char *name, PX_Cipher **res) od = px_alloc(sizeof(*od)); memset(od, 0, sizeof(*od)); od->evp_ciph = evp_c; - + csrc = NULL; for (i = 0; spec_types[i].name; i++) - if (!strcmp(name, spec_types[i].name)) { + if (!strcmp(name, spec_types[i].name)) + { csrc = &spec_types[i].cf; break; } - + if (csrc == NULL) csrc = &gen_evp_handler; c = px_alloc(sizeof(*c)); memcpy(c, csrc, sizeof(*c)); c->ptr = od; - + *res = c; return 0; } - diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c index 2bd9b21e16..a6424e61fb 100644 --- a/contrib/pgcrypto/pgcrypto.c +++ b/contrib/pgcrypto/pgcrypto.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.c,v 1.9 2001/09/23 04:12:44 momjian Exp $ + * $Id: pgcrypto.c,v 1.10 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -41,7 +41,7 @@ typedef int (*PFN) (const char *name, void **res); static void * - find_provider(text * name, PFN pf, char *desc, int silent); + find_provider(text *name, PFN pf, char *desc, int silent); /* SQL function: hash(text, text) returns text */ PG_FUNCTION_INFO_V1(pg_digest); @@ -313,17 +313,21 @@ PG_FUNCTION_INFO_V1(pg_encrypt); Datum pg_encrypt(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen; - + int err; + bytea *data, + *key, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(2); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -341,8 +345,9 @@ pg_encrypt(PG_FUNCTION_ARGS) PG_FREE_IF_COPY(data, 0); PG_FREE_IF_COPY(key, 1); PG_FREE_IF_COPY(type, 2); - - if (err) { + + if (err) + { pfree(res); elog(ERROR, "encrypt error: %d", err); } @@ -357,17 +362,21 @@ PG_FUNCTION_INFO_V1(pg_decrypt); Datum pg_decrypt(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen; - + int err; + bytea *data, + *key, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(2); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -401,18 +410,24 @@ PG_FUNCTION_INFO_V1(pg_encrypt_iv); Datum pg_encrypt_iv(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *iv, *res; - text *type; - PX_Combo *c; - uint dlen, klen, ivlen, rlen; - + int err; + bytea *data, + *key, + *iv, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + ivlen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) - || PG_ARGISNULL(2) || PG_ARGISNULL(3)) + || PG_ARGISNULL(2) || PG_ARGISNULL(3)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(3); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -449,18 +464,24 @@ PG_FUNCTION_INFO_V1(pg_decrypt_iv); Datum pg_decrypt_iv(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *iv, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen, ivlen; - + int err; + bytea *data, + *key, + *iv, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen, + ivlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) - || PG_ARGISNULL(2) || PG_ARGISNULL(3)) + || PG_ARGISNULL(2) || PG_ARGISNULL(3)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(3); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -480,7 +501,7 @@ pg_decrypt_iv(PG_FUNCTION_ARGS) if (err) elog(ERROR, "decrypt_iv error: %d", err); - + VARATT_SIZEP(res) = VARHDRSZ + rlen; PG_FREE_IF_COPY(data, 0); @@ -497,15 +518,15 @@ PG_FUNCTION_INFO_V1(pg_cipher_exists); Datum pg_cipher_exists(PG_FUNCTION_ARGS) { - text *arg; - PX_Combo *c; + text *arg; + PX_Combo *c; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); arg = PG_GETARG_TEXT_P(0); - c = find_provider(arg, (PFN)px_find_combo, "Cipher", 1); + c = find_provider(arg, (PFN) px_find_combo, "Cipher", 1); if (c != NULL) px_combo_free(c); @@ -514,7 +535,7 @@ pg_cipher_exists(PG_FUNCTION_ARGS) static void * -find_provider(text * name, +find_provider(text *name, PFN provider_lookup, char *desc, int silent) { diff --git a/contrib/pgcrypto/pgcrypto.h b/contrib/pgcrypto/pgcrypto.h index 1b49c8d895..26d04c5dc4 100644 --- a/contrib/pgcrypto/pgcrypto.h +++ b/contrib/pgcrypto/pgcrypto.h @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.h,v 1.5 2001/09/23 04:12:44 momjian Exp $ + * $Id: pgcrypto.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */ #ifndef _PG_CRYPTO_H @@ -45,6 +45,4 @@ Datum pg_decrypt(PG_FUNCTION_ARGS); Datum pg_encrypt_iv(PG_FUNCTION_ARGS); Datum pg_decrypt_iv(PG_FUNCTION_ARGS); Datum pg_cipher_exists(PG_FUNCTION_ARGS); - #endif - diff --git a/contrib/pgcrypto/px-crypt.c b/contrib/pgcrypto/px-crypt.c index 7d767279b1..c082140808 100644 --- a/contrib/pgcrypto/px-crypt.c +++ b/contrib/pgcrypto/px-crypt.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-crypt.c,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px-crypt.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #include <postgres.h> @@ -38,7 +38,7 @@ static char * run_crypt_des(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; @@ -51,37 +51,51 @@ run_crypt_des(const char *psw, const char *salt, static char * run_crypt_md5(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; + res = px_crypt_md5(psw, salt, buf, len); return res; } static char * run_crypt_bf(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; + res = _crypt_blowfish_rn(psw, salt, buf, len); return res; } static struct { - char *id; + char *id; unsigned id_len; char *(*crypt) (const char *psw, const char *salt, char *buf, unsigned len); } px_crypt_list[] = { - { "$2a$", 4, run_crypt_bf }, - { "$2$", 3, NULL }, /* N/A */ - { "$1$", 3, run_crypt_md5 }, - { "_", 1, run_crypt_des }, - { "", 0, run_crypt_des }, - { NULL, 0, NULL } + { + "$2a$", 4, run_crypt_bf + }, + { + "$2$", 3, NULL + }, /* N/A */ + { + "$1$", 3, run_crypt_md5 + }, + { + "_", 1, run_crypt_des + }, + { + "", 0, run_crypt_des + }, + { + NULL, 0, NULL + } }; char * @@ -125,41 +139,45 @@ px_crypt(const char *psw, const char *salt, * salt generators */ -struct generator { - char *name; - char *(*gen)(unsigned long count, const char *input, int size, - char *output, int output_size); - int input_len; - int def_rounds; - int min_rounds; - int max_rounds; +struct generator +{ + char *name; + char *(*gen) (unsigned long count, const char *input, int size, + char *output, int output_size); + int input_len; + int def_rounds; + int min_rounds; + int max_rounds; }; -static struct generator gen_list [] = { - { "des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0 }, - { "md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0 }, - { "xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF }, - { "bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31 }, - { NULL, NULL, 0, 0, 0 } +static struct generator gen_list[] = { + {"des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0}, + {"md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0}, + {"xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF}, + {"bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31}, + {NULL, NULL, 0, 0, 0} }; uint px_gen_salt(const char *salt_type, char *buf, int rounds) { - int i, res; + int i, + res; struct generator *g; - char *p; - char rbuf[16]; - - for (i = 0; gen_list[i].name; i++) { + char *p; + char rbuf[16]; + + for (i = 0; gen_list[i].name; i++) + { g = &gen_list[i]; if (strcasecmp(g->name, salt_type) != 0) continue; - if (g->def_rounds) { + if (g->def_rounds) + { if (rounds == 0) rounds = g->def_rounds; - + if (rounds < g->min_rounds || rounds > g->max_rounds) return 0; } @@ -170,10 +188,9 @@ px_gen_salt(const char *salt_type, char *buf, int rounds) p = g->gen(rounds, rbuf, g->input_len, buf, PX_MAX_SALT_LEN); memset(rbuf, 0, sizeof(rbuf)); - + return p != NULL ? strlen(p) : 0; } return 0; } - diff --git a/contrib/pgcrypto/px-crypt.h b/contrib/pgcrypto/px-crypt.h index 5edebb3d3b..7265d41491 100644 --- a/contrib/pgcrypto/px-crypt.h +++ b/contrib/pgcrypto/px-crypt.h @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-crypt.h,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px-crypt.h,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #ifndef _PX_CRYPT_H @@ -36,7 +36,7 @@ #define PX_MAX_CRYPT 128 /* max salt returned by gen_salt() */ -#define PX_MAX_SALT_LEN 128 +#define PX_MAX_SALT_LEN 128 /* default rounds for xdes salt */ /* NetBSD bin/passwd/local_passwd.c has (29 * 25)*/ @@ -58,19 +58,20 @@ unsigned px_gen_salt(const char *salt_type, char *dst, int rounds); /* misc.c */ extern void px_crypt_to64(char *s, unsigned long v, int n); extern char px_crypt_a64[]; + /* avoid conflicts with system libs */ #define _crypt_to64 px_crypt_to64 #define _crypt_a64 px_crypt_a64 /* crypt-gensalt.c */ char *_crypt_gensalt_traditional_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_extended_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_md5_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_blowfish_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); #ifndef PX_SYSTEM_CRYPT @@ -85,8 +86,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, char *px_crypt_des(const char *key, const char *setting); /* crypt-md5.c */ -char *px_crypt_md5(const char *pw, const char *salt, - char *dst, unsigned dstlen); - +char *px_crypt_md5(const char *pw, const char *salt, + char *dst, unsigned dstlen); #endif /* !PX_SYSTEM_CRYPT */ #endif /* _PX_CRYPT_H */ diff --git a/contrib/pgcrypto/px-hmac.c b/contrib/pgcrypto/px-hmac.c index d635aba124..147a559238 100644 --- a/contrib/pgcrypto/px-hmac.c +++ b/contrib/pgcrypto/px-hmac.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-hmac.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ + * $Id: px-hmac.c,v 1.2 2001/10/25 05:49:20 momjian Exp $ */ @@ -50,7 +50,7 @@ hmac_block_size(PX_HMAC * h) } static void -hmac_init(PX_HMAC * h, const uint8 * key, uint klen) +hmac_init(PX_HMAC * h, const uint8 *key, uint klen) { uint bs, hlen, @@ -95,13 +95,13 @@ hmac_reset(PX_HMAC * h) } static void -hmac_update(PX_HMAC * h, const uint8 * data, uint dlen) +hmac_update(PX_HMAC * h, const uint8 *data, uint dlen) { px_md_update(h->md, data, dlen); } static void -hmac_finish(PX_HMAC * h, uint8 * dst) +hmac_finish(PX_HMAC * h, uint8 *dst) { PX_MD *md = h->md; uint bs, diff --git a/contrib/pgcrypto/px.c b/contrib/pgcrypto/px.c index 9c18f6f250..20550bf100 100644 --- a/contrib/pgcrypto/px.c +++ b/contrib/pgcrypto/px.c @@ -1,7 +1,7 @@ /* * px.c * Various cryptographic stuff for PostgreSQL. - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px.c,v 1.2 2001/09/06 03:21:39 momjian Exp $ + * $Id: px.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #include <postgres.h> @@ -35,9 +35,10 @@ const char * -px_resolve_alias(const PX_Alias *list, const char *name) +px_resolve_alias(const PX_Alias * list, const char *name) { - while (list->name) { + while (list->name) + { if (!strcasecmp(list->alias, name)) return list->name; list++; @@ -50,32 +51,35 @@ px_resolve_alias(const PX_Alias *list, const char *name) */ static uint -combo_encrypt_len(PX_Combo *cx, uint dlen) +combo_encrypt_len(PX_Combo * cx, uint dlen) { return dlen + 512; } static uint -combo_decrypt_len(PX_Combo *cx, uint dlen) +combo_decrypt_len(PX_Combo * cx, uint dlen) { return dlen; } static int -combo_init(PX_Combo *cx, const uint8 *key, uint klen, - const uint8 *iv, uint ivlen) +combo_init(PX_Combo * cx, const uint8 *key, uint klen, + const uint8 *iv, uint ivlen) { - int err; - uint bs, ks, ivs; - PX_Cipher *c = cx->cipher; - uint8 *ivbuf = NULL; - uint8 *keybuf; + int err; + uint bs, + ks, + ivs; + PX_Cipher *c = cx->cipher; + uint8 *ivbuf = NULL; + uint8 *keybuf; bs = px_cipher_block_size(c); ks = px_cipher_key_size(c); ivs = px_cipher_iv_size(c); - if (ivs > 0) { + if (ivs > 0) + { ivbuf = px_alloc(ivs); memset(ivbuf, 0, ivs); if (ivlen > ivs) @@ -97,39 +101,48 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen, } static int -combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen) +combo_encrypt(PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen) { - int err = 0; - uint8 *bbuf; - uint bs, maxlen, bpos, i, pad; + int err = 0; + uint8 *bbuf; + uint bs, + maxlen, + bpos, + i, + pad; - PX_Cipher *c = cx->cipher; + PX_Cipher *c = cx->cipher; bbuf = NULL; maxlen = *rlen; bs = px_cipher_block_size(c); - + /* encrypt */ - if (bs > 1) { + if (bs > 1) + { bbuf = px_alloc(bs * 4); bpos = dlen % bs; *rlen = dlen - bpos; memcpy(bbuf, data + *rlen, bpos); /* encrypt full-block data */ - if (*rlen) { + if (*rlen) + { err = px_cipher_encrypt(c, data, *rlen, res); if (err) goto out; } - + /* bbuf has now bpos bytes of stuff */ - if (cx->padding) { + if (cx->padding) + { pad = bs - (bpos % bs); for (i = 0; i < pad; i++) bbuf[bpos++] = pad; - } else if (bpos % bs) { + } + else if (bpos % bs) + { /* ERROR? */ pad = bs - (bpos % bs); for (i = 0; i < pad; i++) @@ -137,11 +150,14 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, } /* encrypt the rest - pad */ - if (bpos) { + if (bpos) + { err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen); *rlen += bpos; } - } else { + } + else + { /* stream cipher/mode - no pad needed */ err = px_cipher_encrypt(c, data, dlen, res); if (err) @@ -149,48 +165,53 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, *rlen = dlen; } out: - if (bbuf) px_free(bbuf); + if (bbuf) + px_free(bbuf); return err; } static int -combo_decrypt(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen) +combo_decrypt(PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen) { - uint bs, i, pad; - uint pad_ok; + uint bs, + i, + pad; + uint pad_ok; - PX_Cipher *c = cx->cipher; + PX_Cipher *c = cx->cipher; bs = px_cipher_block_size(c); - if (bs > 1 && (dlen % bs) != 0) { + if (bs > 1 && (dlen % bs) != 0) goto block_error; - } - + /* decrypt */ *rlen = dlen; px_cipher_decrypt(c, data, dlen, res); - + /* unpad */ - if (bs > 1 && cx->padding) { + if (bs > 1 && cx->padding) + { pad = res[*rlen - 1]; pad_ok = 0; - if (pad > 0 && pad <= bs && pad <= *rlen) { + if (pad > 0 && pad <= bs && pad <= *rlen) + { pad_ok = 1; for (i = *rlen - pad; i < *rlen; i++) - if (res[i] != pad) { + if (res[i] != pad) + { pad_ok = 0; break; } } - + if (pad_ok) *rlen -= pad; } return 0; - + /* error reporting should be done in pgcrypto.c */ block_error: elog(NOTICE, "Data not a multiple of block size"); @@ -198,7 +219,7 @@ block_error: } static void -combo_free(PX_Combo *cx) +combo_free(PX_Combo * cx) { if (cx->cipher) px_cipher_free(cx->cipher); @@ -211,31 +232,38 @@ combo_free(PX_Combo *cx) static int parse_cipher_name(char *full, char **cipher, char **pad) { - char *p, *p2, *q; + char *p, + *p2, + *q; + *cipher = full; *pad = NULL; - + p = strchr(full, '/'); if (p != NULL) *p++ = 0; - while (p != NULL) { + while (p != NULL) + { if ((q = strchr(p, '/')) != NULL) *q++ = 0; - - if (!*p) { + + if (!*p) + { p = q; continue; } p2 = strchr(p, ':'); - if (p2 != NULL) { + if (p2 != NULL) + { *p2++ = 0; if (!strcmp(p, "pad")) *pad = p2; else return -1; - } else + } + else return -1; - + p = q; } return 0; @@ -244,12 +272,14 @@ parse_cipher_name(char *full, char **cipher, char **pad) /* provider */ int -px_find_combo(const char *name, PX_Combo **res) +px_find_combo(const char *name, PX_Combo ** res) { - int err; - char *buf, *s_cipher, *s_pad; + int err; + char *buf, + *s_cipher, + *s_pad; - PX_Combo *cx; + PX_Combo *cx; cx = px_alloc(sizeof(*cx)); memset(cx, 0, sizeof(*cx)); @@ -258,7 +288,8 @@ px_find_combo(const char *name, PX_Combo **res) strcpy(buf, name); err = parse_cipher_name(buf, &s_cipher, &s_pad); - if (err) { + if (err) + { px_free(buf); px_free(cx); return err; @@ -267,15 +298,17 @@ px_find_combo(const char *name, PX_Combo **res) err = px_find_cipher(s_cipher, &cx->cipher); if (err) goto err1; - - if (s_pad != NULL) { + + if (s_pad != NULL) + { if (!strcmp(s_pad, "pkcs")) cx->padding = 1; else if (!strcmp(s_pad, "none")) cx->padding = 0; else goto err1; - } else + } + else cx->padding = 1; cx->init = combo_init; @@ -290,7 +323,7 @@ px_find_combo(const char *name, PX_Combo **res) *res = cx; return 0; - + err1: if (cx->cipher) px_cipher_free(cx->cipher); @@ -298,4 +331,3 @@ err1: px_free(buf); return -1; } - diff --git a/contrib/pgcrypto/px.h b/contrib/pgcrypto/px.h index d4cffc3c06..d2a87b26e1 100644 --- a/contrib/pgcrypto/px.h +++ b/contrib/pgcrypto/px.h @@ -1,7 +1,7 @@ /* * px.h * Header file for pgcrypto. - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px.h,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px.h,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #ifndef __PX_H @@ -36,22 +36,21 @@ #define px_alloc(s) palloc(s) #define px_realloc(p, s) prealloc(p, s) -#define px_free(p) pfree(p) +#define px_free(p) pfree(p) #else -void *xalloc(size_t s); -void *xrealloc(void *p, size_t s); -void xfree(void *p); +void *xalloc(size_t s); +void *xrealloc(void *p, size_t s); +void xfree(void *p); #define px_alloc(s) xalloc(s) #define px_realloc(p, s) xrealloc(p, s) -#define px_free(p) xfree(p) - +#define px_free(p) xfree(p) #endif /* max len of 'type' parms */ -#define PX_MAX_NAMELEN 128 +#define PX_MAX_NAMELEN 128 /* max salt returned */ #define PX_MAX_SALT_LEN 128 @@ -63,79 +62,86 @@ typedef struct px_hmac PX_HMAC; typedef struct px_cipher PX_Cipher; typedef struct px_combo PX_Combo; -struct px_digest { - uint (*result_size)(PX_MD *h); - uint (*block_size)(PX_MD *h); - void (*reset)(PX_MD *h); - void (*update)(PX_MD *h, const uint8 *data, uint dlen); - void (*finish)(PX_MD *h, uint8 *dst); - void (*free)(PX_MD *h); +struct px_digest +{ + uint (*result_size) (PX_MD * h); + uint (*block_size) (PX_MD * h); + void (*reset) (PX_MD * h); + void (*update) (PX_MD * h, const uint8 *data, uint dlen); + void (*finish) (PX_MD * h, uint8 *dst); + void (*free) (PX_MD * h); /* private */ - union { - uint code; + union + { + uint code; const void *ptr; - } p; + } p; }; -struct px_alias { - char *alias; - char *name; +struct px_alias +{ + char *alias; + char *name; }; -struct px_hmac { - uint (*result_size)(PX_HMAC *h); - uint (*block_size)(PX_HMAC *h); - void (*reset)(PX_HMAC *h); - void (*update)(PX_HMAC *h, const uint8 *data, uint dlen); - void (*finish)(PX_HMAC *h, uint8 *dst); - void (*free)(PX_HMAC *h); - void (*init)(PX_HMAC *h, const uint8 *key, uint klen); - - PX_MD *md; +struct px_hmac +{ + uint (*result_size) (PX_HMAC * h); + uint (*block_size) (PX_HMAC * h); + void (*reset) (PX_HMAC * h); + void (*update) (PX_HMAC * h, const uint8 *data, uint dlen); + void (*finish) (PX_HMAC * h, uint8 *dst); + void (*free) (PX_HMAC * h); + void (*init) (PX_HMAC * h, const uint8 *key, uint klen); + + PX_MD *md; /* private */ - struct { - uint8 *ipad; - uint8 *opad; - } p; + struct + { + uint8 *ipad; + uint8 *opad; + } p; }; -struct px_cipher { - uint (*block_size)(PX_Cipher *c); - uint (*key_size)(PX_Cipher *c); /* max key len */ - uint (*iv_size)(PX_Cipher *c); - - int (*init)(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv); - int (*encrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); - int (*decrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); - void (*free)(PX_Cipher *c); +struct px_cipher +{ + uint (*block_size) (PX_Cipher * c); + uint (*key_size) (PX_Cipher * c); /* max key len */ + uint (*iv_size) (PX_Cipher * c); + + int (*init) (PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv); + int (*encrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res); + int (*decrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res); + void (*free) (PX_Cipher * c); /* private */ - void *ptr; - int pstat; /* mcrypt uses it */ + void *ptr; + int pstat; /* mcrypt uses it */ }; -struct px_combo { - int (*init)(PX_Combo *cx, const uint8 *key, uint klen, - const uint8 *iv, uint ivlen); - int (*encrypt)(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen); - int (*decrypt)(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen); - uint (*encrypt_len)(PX_Combo *cx, uint dlen); - uint (*decrypt_len)(PX_Combo *cx, uint dlen); - void (*free)(PX_Combo *cx); - - PX_Cipher *cipher; - uint padding; +struct px_combo +{ + int (*init) (PX_Combo * cx, const uint8 *key, uint klen, + const uint8 *iv, uint ivlen); + int (*encrypt) (PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen); + int (*decrypt) (PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen); + uint (*encrypt_len) (PX_Combo * cx, uint dlen); + uint (*decrypt_len) (PX_Combo * cx, uint dlen); + void (*free) (PX_Combo * cx); + + PX_Cipher *cipher; + uint padding; }; -int px_find_digest(const char *name, PX_MD **res); -int px_find_hmac(const char *name, PX_HMAC **res); -int px_find_cipher(const char *name, PX_Cipher **res); -int px_find_combo(const char *name, PX_Combo **res); +int px_find_digest(const char *name, PX_MD ** res); +int px_find_hmac(const char *name, PX_HMAC ** res); +int px_find_cipher(const char *name, PX_Cipher ** res); +int px_find_combo(const char *name, PX_Combo ** res); -int px_get_random_bytes(uint8 *dst, unsigned count); +int px_get_random_bytes(uint8 *dst, unsigned count); -const char *px_resolve_alias(const PX_Alias *aliases, const char *name); +const char *px_resolve_alias(const PX_Alias * aliases, const char *name); #define px_md_result_size(md) (md)->result_size(md) #define px_md_block_size(md) (md)->block_size(md) @@ -174,6 +180,4 @@ const char *px_resolve_alias(const PX_Alias *aliases, const char *name); (c)->decrypt(c, data, dlen, res, rlen) #define px_combo_free(c) (c)->free(c) - -#endif /* __PX_H */ - +#endif /* __PX_H */ diff --git a/contrib/pgcrypto/random.c b/contrib/pgcrypto/random.c index 179d450ef9..559e40c456 100644 --- a/contrib/pgcrypto/random.c +++ b/contrib/pgcrypto/random.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: random.c,v 1.2 2001/09/29 03:12:51 momjian Exp $ + * $Id: random.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ @@ -44,13 +44,15 @@ static int safe_read(int fd, void *buf, size_t count) { - int done = 0; - char *p = buf; - int res; - - while (count) { + int done = 0; + char *p = buf; + int res; + + while (count) + { res = read(fd, p, count); - if (res <= 0) { + if (res <= 0) + { if (errno == EINTR) continue; return -1; @@ -65,8 +67,8 @@ safe_read(int fd, void *buf, size_t count) int px_get_random_bytes(uint8 *dst, unsigned count) { - int fd; - int res; + int fd; + int res; fd = open(RAND_DEV, O_RDONLY); if (fd == -1) @@ -75,21 +77,20 @@ px_get_random_bytes(uint8 *dst, unsigned count) close(fd); return res; } - -#endif /* RAND_DEV */ +#endif /* RAND_DEV */ #ifdef RAND_SILLY -int px_get_random_bytes(uint8 *dst, unsigned count) +int +px_get_random_bytes(uint8 *dst, unsigned count) { - int i; - for (i = 0; i < count; i++) { + int i; + + for (i = 0; i < count; i++) *dst++ = random(); - } return i; } - -#endif /* RAND_SILLY */ +#endif /* RAND_SILLY */ #ifdef RAND_OPENSSL @@ -98,30 +99,29 @@ int px_get_random_bytes(uint8 *dst, unsigned count) #include <openssl/rand.h> #include <openssl/err.h> -static int openssl_random_init = 0; +static int openssl_random_init = 0; -int px_get_random_bytes(uint8 *dst, unsigned count) +int +px_get_random_bytes(uint8 *dst, unsigned count) { - int res; + int res; - if (!openssl_random_init) { - if (RAND_get_rand_method() == NULL) { + if (!openssl_random_init) + { + if (RAND_get_rand_method() == NULL) RAND_set_rand_method(RAND_SSLeay()); - } openssl_random_init = 1; } - + /* - * OpenSSL random should re-feeded occasionally. - * From /dev/urandom preferrably. + * OpenSSL random should re-feeded occasionally. From /dev/urandom + * preferrably. */ - + res = RAND_bytes(dst, count); if (res > 0) return count; return -1; } - -#endif /* RAND_OPENSSL */ - +#endif /* RAND_OPENSSL */ diff --git a/contrib/pgcrypto/rijndael.c b/contrib/pgcrypto/rijndael.c index 258202fa99..cca8759e8b 100644 --- a/contrib/pgcrypto/rijndael.c +++ b/contrib/pgcrypto/rijndael.c @@ -1,40 +1,40 @@ -/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */ - -/* This is an independent implementation of the encryption algorithm: */ -/* */ -/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ -/* */ -/* which is a candidate algorithm in the Advanced Encryption Standard */ -/* programme of the US National Institute of Standards and Technology. */ -/* */ -/* Copyright in this implementation is held by Dr B R Gladman but I */ +/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */ + +/* This is an independent implementation of the encryption algorithm: */ +/* */ +/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ +/* */ +/* which is a candidate algorithm in the Advanced Encryption Standard */ +/* programme of the US National Institute of Standards and Technology. */ +/* */ +/* Copyright in this implementation is held by Dr B R Gladman but I */ /* hereby give permission for its free direct or derivative use subject */ -/* to acknowledgment of its origin and compliance with any conditions */ -/* that the originators of the algorithm place on its exploitation. */ -/* */ -/* Dr Brian Gladman ([email protected]) 14th January 1999 */ +/* to acknowledgment of its origin and compliance with any conditions */ +/* that the originators of the algorithm place on its exploitation. */ +/* */ +/* Dr Brian Gladman ([email protected]) 14th January 1999 */ /* Timing data for Rijndael (rijndael.c) Algorithm: rijndael (rijndael.c) 128 bit key: -Key Setup: 305/1389 cycles (encrypt/decrypt) -Encrypt: 374 cycles = 68.4 mbits/sec -Decrypt: 352 cycles = 72.7 mbits/sec -Mean: 363 cycles = 70.5 mbits/sec +Key Setup: 305/1389 cycles (encrypt/decrypt) +Encrypt: 374 cycles = 68.4 mbits/sec +Decrypt: 352 cycles = 72.7 mbits/sec +Mean: 363 cycles = 70.5 mbits/sec 192 bit key: -Key Setup: 277/1595 cycles (encrypt/decrypt) -Encrypt: 439 cycles = 58.3 mbits/sec -Decrypt: 425 cycles = 60.2 mbits/sec -Mean: 432 cycles = 59.3 mbits/sec +Key Setup: 277/1595 cycles (encrypt/decrypt) +Encrypt: 439 cycles = 58.3 mbits/sec +Decrypt: 425 cycles = 60.2 mbits/sec +Mean: 432 cycles = 59.3 mbits/sec 256 bit key: -Key Setup: 374/1960 cycles (encrypt/decrypt) -Encrypt: 502 cycles = 51.0 mbits/sec -Decrypt: 498 cycles = 51.4 mbits/sec -Mean: 500 cycles = 51.2 mbits/sec +Key Setup: 374/1960 cycles (encrypt/decrypt) +Encrypt: 502 cycles = 51.0 mbits/sec +Decrypt: 498 cycles = 51.4 mbits/sec +Mean: 500 cycles = 51.2 mbits/sec */ @@ -47,29 +47,29 @@ Mean: 500 cycles = 51.2 mbits/sec static void gen_tabs(void); -/* 3. Basic macros for speeding up generic operations */ +/* 3. Basic macros for speeding up generic operations */ -/* Circular rotate of 32 bit values */ +/* Circular rotate of 32 bit values */ -#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n)))) -#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n)))) +#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n)))) +#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n)))) -/* Invert byte order in a 32 bit variable */ +/* Invert byte order in a 32 bit variable */ -#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00)) +#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00)) -/* Extract byte from a 32 bit quantity (little endian notation) */ +/* Extract byte from a 32 bit quantity (little endian notation) */ -#define byte(x,n) ((u1byte)((x) >> (8 * n))) +#define byte(x,n) ((u1byte)((x) >> (8 * n))) #if BYTE_ORDER != LITTLE_ENDIAN #define BYTE_SWAP #endif -#ifdef BYTE_SWAP -#define io_swap(x) bswap(x) +#ifdef BYTE_SWAP +#define io_swap(x) bswap(x) #else -#define io_swap(x) (x) +#define io_swap(x) (x) #endif #ifdef PRINT_TABS @@ -81,279 +81,311 @@ static void gen_tabs(void); #include "rijndael.tbl" #define tab_gen 1 -#else /* !PRE_CALC_TABLES */ +#else /* !PRE_CALC_TABLES */ -static u1byte pow_tab[256]; -static u1byte log_tab[256]; -static u1byte sbx_tab[256]; -static u1byte isb_tab[256]; -static u4byte rco_tab[ 10]; -static u4byte ft_tab[4][256]; -static u4byte it_tab[4][256]; +static u1byte pow_tab[256]; +static u1byte log_tab[256]; +static u1byte sbx_tab[256]; +static u1byte isb_tab[256]; +static u4byte rco_tab[10]; +static u4byte ft_tab[4][256]; +static u4byte it_tab[4][256]; -#ifdef LARGE_TABLES -static u4byte fl_tab[4][256]; -static u4byte il_tab[4][256]; +#ifdef LARGE_TABLES +static u4byte fl_tab[4][256]; +static u4byte il_tab[4][256]; #endif -static u4byte tab_gen = 0; -#endif /* !PRE_CALC_TABLES */ +static u4byte tab_gen = 0; +#endif /* !PRE_CALC_TABLES */ -#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0) +#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0) -#define f_rn(bo, bi, n, k) \ - bo[n] = ft_tab[0][byte(bi[n],0)] ^ \ - ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ - ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) +#define f_rn(bo, bi, n, k) \ + bo[n] = ft_tab[0][byte(bi[n],0)] ^ \ + ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ + ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) -#define i_rn(bo, bi, n, k) \ - bo[n] = it_tab[0][byte(bi[n],0)] ^ \ - it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ - it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) +#define i_rn(bo, bi, n, k) \ + bo[n] = it_tab[0][byte(bi[n],0)] ^ \ + it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ + it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) #ifdef LARGE_TABLES -#define ls_box(x) \ - ( fl_tab[0][byte(x, 0)] ^ \ - fl_tab[1][byte(x, 1)] ^ \ - fl_tab[2][byte(x, 2)] ^ \ - fl_tab[3][byte(x, 3)] ) +#define ls_box(x) \ + ( fl_tab[0][byte(x, 0)] ^ \ + fl_tab[1][byte(x, 1)] ^ \ + fl_tab[2][byte(x, 2)] ^ \ + fl_tab[3][byte(x, 3)] ) -#define f_rl(bo, bi, n, k) \ - bo[n] = fl_tab[0][byte(bi[n],0)] ^ \ - fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ - fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) +#define f_rl(bo, bi, n, k) \ + bo[n] = fl_tab[0][byte(bi[n],0)] ^ \ + fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ + fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) -#define i_rl(bo, bi, n, k) \ - bo[n] = il_tab[0][byte(bi[n],0)] ^ \ - il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ - il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) +#define i_rl(bo, bi, n, k) \ + bo[n] = il_tab[0][byte(bi[n],0)] ^ \ + il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ + il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) #else -#define ls_box(x) \ - ((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \ - ((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \ - ((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \ - ((u4byte)sbx_tab[byte(x, 3)] << 24) - -#define f_rl(bo, bi, n, k) \ - bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n) - -#define i_rl(bo, bi, n, k) \ - bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) - +#define ls_box(x) \ + ((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \ + ((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \ + ((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \ + ((u4byte)sbx_tab[byte(x, 3)] << 24) + +#define f_rl(bo, bi, n, k) \ + bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n) + +#define i_rl(bo, bi, n, k) \ + bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) #endif static void gen_tabs(void) { #ifndef PRE_CALC_TABLES - u4byte i, t; - u1byte p, q; + u4byte i, + t; + u1byte p, + q; - /* log and power tables for GF(2**8) finite field with */ - /* 0x11b as modular polynomial - the simplest prmitive */ - /* root is 0x11, used here to generate the tables */ + /* log and power tables for GF(2**8) finite field with */ + /* 0x11b as modular polynomial - the simplest prmitive */ + /* root is 0x11, used here to generate the tables */ - for(i = 0,p = 1; i < 256; ++i) { - pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i; + for (i = 0, p = 1; i < 256; ++i) + { + pow_tab[i] = (u1byte) p; + log_tab[p] = (u1byte) i; p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0); } - log_tab[1] = 0; p = 1; + log_tab[1] = 0; + p = 1; - for(i = 0; i < 10; ++i) { - rco_tab[i] = p; + for (i = 0; i < 10; ++i) + { + rco_tab[i] = p; p = (p << 1) ^ (p & 0x80 ? 0x1b : 0); } - /* note that the affine byte transformation matrix in */ - /* rijndael specification is in big endian format with */ - /* bit 0 as the most significant bit. In the remainder */ - /* of the specification the bits are numbered from the */ - /* least significant end of a byte. */ - - for(i = 0; i < 256; ++i) { - p = (i ? pow_tab[255 - log_tab[i]] : 0); q = p; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q ^ 0x63; - sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i; + /* note that the affine byte transformation matrix in */ + /* rijndael specification is in big endian format with */ + /* bit 0 as the most significant bit. In the remainder */ + /* of the specification the bits are numbered from the */ + /* least significant end of a byte. */ + + for (i = 0; i < 256; ++i) + { + p = (i ? pow_tab[255 - log_tab[i]] : 0); + q = p; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q ^ 0x63; + sbx_tab[i] = (u1byte) p; + isb_tab[p] = (u1byte) i; } - for(i = 0; i < 256; ++i) { - p = sbx_tab[i]; + for (i = 0; i < 256; ++i) + { + p = sbx_tab[i]; -#ifdef LARGE_TABLES - - t = p; fl_tab[0][i] = t; - fl_tab[1][i] = rotl(t, 8); +#ifdef LARGE_TABLES + + t = p; + fl_tab[0][i] = t; + fl_tab[1][i] = rotl(t, 8); fl_tab[2][i] = rotl(t, 16); fl_tab[3][i] = rotl(t, 24); #endif - t = ((u4byte)ff_mult(2, p)) | - ((u4byte)p << 8) | - ((u4byte)p << 16) | - ((u4byte)ff_mult(3, p) << 24); - + t = ((u4byte) ff_mult(2, p)) | + ((u4byte) p << 8) | + ((u4byte) p << 16) | + ((u4byte) ff_mult(3, p) << 24); + ft_tab[0][i] = t; - ft_tab[1][i] = rotl(t, 8); + ft_tab[1][i] = rotl(t, 8); ft_tab[2][i] = rotl(t, 16); ft_tab[3][i] = rotl(t, 24); - p = isb_tab[i]; + p = isb_tab[i]; -#ifdef LARGE_TABLES - - t = p; il_tab[0][i] = t; - il_tab[1][i] = rotl(t, 8); - il_tab[2][i] = rotl(t, 16); +#ifdef LARGE_TABLES + + t = p; + il_tab[0][i] = t; + il_tab[1][i] = rotl(t, 8); + il_tab[2][i] = rotl(t, 16); il_tab[3][i] = rotl(t, 24); -#endif - t = ((u4byte)ff_mult(14, p)) | - ((u4byte)ff_mult( 9, p) << 8) | - ((u4byte)ff_mult(13, p) << 16) | - ((u4byte)ff_mult(11, p) << 24); - - it_tab[0][i] = t; - it_tab[1][i] = rotl(t, 8); - it_tab[2][i] = rotl(t, 16); - it_tab[3][i] = rotl(t, 24); +#endif + t = ((u4byte) ff_mult(14, p)) | + ((u4byte) ff_mult(9, p) << 8) | + ((u4byte) ff_mult(13, p) << 16) | + ((u4byte) ff_mult(11, p) << 24); + + it_tab[0][i] = t; + it_tab[1][i] = rotl(t, 8); + it_tab[2][i] = rotl(t, 16); + it_tab[3][i] = rotl(t, 24); } tab_gen = 1; -#endif /* !PRE_CALC_TABLES */ +#endif /* !PRE_CALC_TABLES */ } #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b) -#define imix_col(y,x) \ - u = star_x(x); \ - v = star_x(u); \ - w = star_x(v); \ - t = w ^ (x); \ - (y) = u ^ v ^ w; \ +#define imix_col(y,x) \ + u = star_x(x); \ + v = star_x(u); \ + w = star_x(v); \ + t = w ^ (x); \ + (y) = u ^ v ^ w; \ (y) ^= rotr(u ^ t, 8) ^ \ - rotr(v ^ t, 16) ^ \ - rotr(t,24) + rotr(v ^ t, 16) ^ \ + rotr(t,24) -/* initialise the key schedule from the user supplied key */ +/* initialise the key schedule from the user supplied key */ -#define loop4(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \ - t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \ - t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \ - t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \ +#define loop4(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \ + t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \ + t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \ + t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \ } while (0) -#define loop6(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \ - t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \ - t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \ - t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \ - t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \ - t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \ +#define loop6(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \ + t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \ + t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \ + t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \ + t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \ + t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \ } while (0) -#define loop8(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \ - t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \ - t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \ - t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \ - t = e_key[8 * i + 4] ^ ls_box(t); \ - e_key[8 * i + 12] = t; \ - t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \ - t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \ - t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \ +#define loop8(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \ + t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \ + t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \ + t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \ + t = e_key[8 * i + 4] ^ ls_box(t); \ + e_key[8 * i + 12] = t; \ + t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \ + t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \ + t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \ } while (0) rijndael_ctx * -rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len, - int encrypt) -{ - u4byte i, t, u, v, w; - u4byte *e_key = ctx->e_key; - u4byte *d_key = ctx->d_key; +rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len, + int encrypt) +{ + u4byte i, + t, + u, + v, + w; + u4byte *e_key = ctx->e_key; + u4byte *d_key = ctx->d_key; ctx->decrypt = !encrypt; - if(!tab_gen) + if (!tab_gen) gen_tabs(); ctx->k_len = (key_len + 31) / 32; - e_key[0] = io_swap(in_key[0]); e_key[1] = io_swap(in_key[1]); - e_key[2] = io_swap(in_key[2]); e_key[3] = io_swap(in_key[3]); - - switch(ctx->k_len) { - case 4: t = e_key[3]; - for(i = 0; i < 10; ++i) - loop4(i); - break; - - case 6: e_key[4] = io_swap(in_key[4]); t = e_key[5] = io_swap(in_key[5]); - for(i = 0; i < 8; ++i) - loop6(i); - break; - - case 8: e_key[4] = io_swap(in_key[4]); e_key[5] = io_swap(in_key[5]); - e_key[6] = io_swap(in_key[6]); t = e_key[7] = io_swap(in_key[7]); - for(i = 0; i < 7; ++i) - loop8(i); - break; + e_key[0] = io_swap(in_key[0]); + e_key[1] = io_swap(in_key[1]); + e_key[2] = io_swap(in_key[2]); + e_key[3] = io_swap(in_key[3]); + + switch (ctx->k_len) + { + case 4: + t = e_key[3]; + for (i = 0; i < 10; ++i) + loop4(i); + break; + + case 6: + e_key[4] = io_swap(in_key[4]); + t = e_key[5] = io_swap(in_key[5]); + for (i = 0; i < 8; ++i) + loop6(i); + break; + + case 8: + e_key[4] = io_swap(in_key[4]); + e_key[5] = io_swap(in_key[5]); + e_key[6] = io_swap(in_key[6]); + t = e_key[7] = io_swap(in_key[7]); + for (i = 0; i < 7; ++i) + loop8(i); + break; } - if (!encrypt) { - d_key[0] = e_key[0]; d_key[1] = e_key[1]; - d_key[2] = e_key[2]; d_key[3] = e_key[3]; + if (!encrypt) + { + d_key[0] = e_key[0]; + d_key[1] = e_key[1]; + d_key[2] = e_key[2]; + d_key[3] = e_key[3]; - for(i = 4; i < 4 * ctx->k_len + 24; ++i) { + for (i = 4; i < 4 * ctx->k_len + 24; ++i) imix_col(d_key[i], e_key[i]); - } } return ctx; } -/* encrypt a block of text */ +/* encrypt a block of text */ #define f_nround(bo, bi, k) \ - f_rn(bo, bi, 0, k); \ - f_rn(bo, bi, 1, k); \ - f_rn(bo, bi, 2, k); \ - f_rn(bo, bi, 3, k); \ - k += 4 + f_rn(bo, bi, 0, k); \ + f_rn(bo, bi, 1, k); \ + f_rn(bo, bi, 2, k); \ + f_rn(bo, bi, 3, k); \ + k += 4 #define f_lround(bo, bi, k) \ - f_rl(bo, bi, 0, k); \ - f_rl(bo, bi, 1, k); \ - f_rl(bo, bi, 2, k); \ - f_rl(bo, bi, 3, k) + f_rl(bo, bi, 0, k); \ + f_rl(bo, bi, 1, k); \ + f_rl(bo, bi, 2, k); \ + f_rl(bo, bi, 3, k) void -rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) -{ - u4byte k_len = ctx->k_len; - u4byte *e_key = ctx->e_key; - u4byte b0[4], b1[4], *kp; +rijndael_encrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk) +{ + u4byte k_len = ctx->k_len; + u4byte *e_key = ctx->e_key; + u4byte b0[4], + b1[4], + *kp; b0[0] = io_swap(in_blk[0]) ^ e_key[0]; b0[1] = io_swap(in_blk[1]) ^ e_key[1]; @@ -362,46 +394,59 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) kp = e_key + 4; - if(k_len > 6) { - f_nround(b1, b0, kp); f_nround(b0, b1, kp); + if (k_len > 6) + { + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); } - if(k_len > 4) { - f_nround(b1, b0, kp); f_nround(b0, b1, kp); + if (k_len > 4) + { + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); } - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_lround(b0, b1, kp); - - out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); - out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_lround(b0, b1, kp); + + out_blk[0] = io_swap(b0[0]); + out_blk[1] = io_swap(b0[1]); + out_blk[2] = io_swap(b0[2]); + out_blk[3] = io_swap(b0[3]); } -/* decrypt a block of text */ +/* decrypt a block of text */ #define i_nround(bo, bi, k) \ - i_rn(bo, bi, 0, k); \ - i_rn(bo, bi, 1, k); \ - i_rn(bo, bi, 2, k); \ - i_rn(bo, bi, 3, k); \ - k -= 4 + i_rn(bo, bi, 0, k); \ + i_rn(bo, bi, 1, k); \ + i_rn(bo, bi, 2, k); \ + i_rn(bo, bi, 3, k); \ + k -= 4 #define i_lround(bo, bi, k) \ - i_rl(bo, bi, 0, k); \ - i_rl(bo, bi, 1, k); \ - i_rl(bo, bi, 2, k); \ - i_rl(bo, bi, 3, k) + i_rl(bo, bi, 0, k); \ + i_rl(bo, bi, 1, k); \ + i_rl(bo, bi, 2, k); \ + i_rl(bo, bi, 3, k) void -rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) -{ - u4byte b0[4], b1[4], *kp; - u4byte k_len = ctx->k_len; - u4byte *e_key = ctx->e_key; - u4byte *d_key = ctx->d_key; +rijndael_decrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk) +{ + u4byte b0[4], + b1[4], + *kp; + u4byte k_len = ctx->k_len; + u4byte *e_key = ctx->e_key; + u4byte *d_key = ctx->d_key; b0[0] = io_swap(in_blk[0]) ^ e_key[4 * k_len + 24]; b0[1] = io_swap(in_blk[1]) ^ e_key[4 * k_len + 25]; @@ -410,22 +455,33 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) kp = d_key + 4 * (k_len + 5); - if(k_len > 6) { - i_nround(b1, b0, kp); i_nround(b0, b1, kp); + if (k_len > 6) + { + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); } - if(k_len > 4) { - i_nround(b1, b0, kp); i_nround(b0, b1, kp); + if (k_len > 4) + { + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); } - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_lround(b0, b1, kp); - - out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); - out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_lround(b0, b1, kp); + + out_blk[0] = io_swap(b0[0]); + out_blk[1] = io_swap(b0[1]); + out_blk[2] = io_swap(b0[2]); + out_blk[3] = io_swap(b0[3]); } /* @@ -435,19 +491,24 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) * should be true for PX. -marko */ -void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc) +void +aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc) { - uint32 *k; - k = (uint32*)key; + uint32 *k; + + k = (uint32 *) key; rijndael_set_key(ctx, k, keybits, enc); } -void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) +void +aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len) { - unsigned bs = 16; - uint32 *d; - while (len >= bs) { - d = (uint32*)data; + unsigned bs = 16; + uint32 *d; + + while (len >= bs) + { + d = (uint32 *) data; rijndael_encrypt(ctx, d, d); len -= bs; @@ -455,12 +516,15 @@ void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) } } -void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) +void +aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len) { - unsigned bs = 16; - uint32 *d; - while (len >= bs) { - d = (uint32*)data; + unsigned bs = 16; + uint32 *d; + + while (len >= bs) + { + d = (uint32 *) data; rijndael_decrypt(ctx, d, d); len -= bs; @@ -468,42 +532,55 @@ void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) } } -void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) +void +aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len) { - uint32 *iv = (uint32 *)iva; - uint32 *d = (uint32 *)data; - unsigned bs = 16; - - while (len >= bs) { - d[0] ^= iv[0]; d[1] ^= iv[1]; - d[2] ^= iv[2]; d[3] ^= iv[3]; - + uint32 *iv = (uint32 *) iva; + uint32 *d = (uint32 *) data; + unsigned bs = 16; + + while (len >= bs) + { + d[0] ^= iv[0]; + d[1] ^= iv[1]; + d[2] ^= iv[2]; + d[3] ^= iv[3]; + rijndael_encrypt(ctx, d, d); iv = d; - d += bs/4; + d += bs / 4; len -= bs; } } -void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) +void +aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len) { - uint32 *d = (uint32 *)data; - unsigned bs = 16; - uint32 buf[4], iv[4]; + uint32 *d = (uint32 *) data; + unsigned bs = 16; + uint32 buf[4], + iv[4]; memcpy(iv, iva, bs); - while (len >= bs) { - buf[0] = d[0]; buf[1] = d[1]; - buf[2] = d[2]; buf[3] = d[3]; - + while (len >= bs) + { + buf[0] = d[0]; + buf[1] = d[1]; + buf[2] = d[2]; + buf[3] = d[3]; + rijndael_decrypt(ctx, buf, d); - - d[0] ^= iv[0]; d[1] ^= iv[1]; - d[2] ^= iv[2]; d[3] ^= iv[3]; - - iv[0] = buf[0]; iv[1] = buf[1]; - iv[2] = buf[2]; iv[3] = buf[3]; + + d[0] ^= iv[0]; + d[1] ^= iv[1]; + d[2] ^= iv[2]; + d[3] ^= iv[3]; + + iv[0] = buf[0]; + iv[1] = buf[1]; + iv[2] = buf[2]; + iv[3] = buf[3]; d += 4; len -= bs; } @@ -514,15 +591,18 @@ void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) * * On i386 lifts 17k from .bss to .rodata * and avoids 1k code and setup time. - * -marko + * -marko */ #ifdef PRINT_TABS -static void show256u8(char *name, uint8 *data) +static void +show256u8(char *name, uint8 *data) { - int i; + int i; + printf("static const u1byte %s[256] = {\n ", name); - for (i = 0; i < 256; ) { + for (i = 0; i < 256;) + { printf("%u", pow_tab[i++]); if (i < 256) printf(i % 16 ? ", " : ",\n "); @@ -531,12 +611,17 @@ static void show256u8(char *name, uint8 *data) } -static void show4x256u32(char *name, uint32 data[4][256]) +static void +show4x256u32(char *name, uint32 data[4][256]) { - int i, j; + int i, + j; + printf("static const u4byte %s[4][256] = {\n{\n ", name); - for (i = 0; i < 4; i++) { - for (j = 0; j < 256; ) { + for (i = 0; i < 4; i++) + { + for (j = 0; j < 256;) + { printf("0x%08x", data[i][j]); j++; if (j < 256) @@ -547,11 +632,12 @@ static void show4x256u32(char *name, uint32 data[4][256]) printf("};\n\n"); } -int main() +int +main() { - int i; - char *hdr = "/* Generated by rijndael.c */\n\n"; - + int i; + char *hdr = "/* Generated by rijndael.c */\n\n"; + gen_tabs(); printf(hdr); @@ -559,7 +645,7 @@ int main() show256u8("log_tab", log_tab); show256u8("sbx_tab", sbx_tab); show256u8("isb_tab", isb_tab); - + show4x256u32("ft_tab", ft_tab); show4x256u32("it_tab", it_tab); #ifdef LARGE_TABLES @@ -567,14 +653,15 @@ int main() show4x256u32("il_tab", il_tab); #endif printf("static const u4byte rco_tab[10] = {\n "); - for (i = 0; i < 10; i++) { + for (i = 0; i < 10; i++) + { printf("0x%08x", rco_tab[i]); - if (i < 9) printf(", "); - if (i == 4) printf("\n "); + if (i < 9) + printf(", "); + if (i == 4) + printf("\n "); } printf("\n};\n\n"); return 0; } - #endif - diff --git a/contrib/pgcrypto/rijndael.h b/contrib/pgcrypto/rijndael.h index bdefda828f..2f54e0c738 100644 --- a/contrib/pgcrypto/rijndael.h +++ b/contrib/pgcrypto/rijndael.h @@ -1,57 +1,57 @@ -/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */ - -/* This is an independent implementation of the encryption algorithm: */ -/* */ -/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ -/* */ -/* which is a candidate algorithm in the Advanced Encryption Standard */ -/* programme of the US National Institute of Standards and Technology. */ -/* */ -/* Copyright in this implementation is held by Dr B R Gladman but I */ +/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */ + +/* This is an independent implementation of the encryption algorithm: */ +/* */ +/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ +/* */ +/* which is a candidate algorithm in the Advanced Encryption Standard */ +/* programme of the US National Institute of Standards and Technology. */ +/* */ +/* Copyright in this implementation is held by Dr B R Gladman but I */ /* hereby give permission for its free direct or derivative use subject */ -/* to acknowledgment of its origin and compliance with any conditions */ -/* that the originators of the algorithm place on its exploitation. */ -/* */ -/* Dr Brian Gladman ([email protected]) 14th January 1999 */ +/* to acknowledgment of its origin and compliance with any conditions */ +/* that the originators of the algorithm place on its exploitation. */ +/* */ +/* Dr Brian Gladman ([email protected]) 14th January 1999 */ #ifndef _RIJNDAEL_H_ #define _RIJNDAEL_H_ -/* 1. Standard types for AES cryptography source code */ +/* 1. Standard types for AES cryptography source code */ -typedef uint8 u1byte; /* an 8 bit unsigned character type */ -typedef uint16 u2byte; /* a 16 bit unsigned integer type */ -typedef uint32 u4byte; /* a 32 bit unsigned integer type */ +typedef uint8 u1byte; /* an 8 bit unsigned character type */ +typedef uint16 u2byte; /* a 16 bit unsigned integer type */ +typedef uint32 u4byte; /* a 32 bit unsigned integer type */ -typedef int8 s1byte; /* an 8 bit signed character type */ -typedef int16 s2byte; /* a 16 bit signed integer type */ -typedef int32 s4byte; /* a 32 bit signed integer type */ +typedef int8 s1byte; /* an 8 bit signed character type */ +typedef int16 s2byte; /* a 16 bit signed integer type */ +typedef int32 s4byte; /* a 32 bit signed integer type */ -typedef struct _rijndael_ctx { - u4byte k_len; - int decrypt; - u4byte e_key[64]; - u4byte d_key[64]; -} rijndael_ctx; +typedef struct _rijndael_ctx +{ + u4byte k_len; + int decrypt; + u4byte e_key[64]; + u4byte d_key[64]; +} rijndael_ctx; -/* 2. Standard interface for AES cryptographic routines */ +/* 2. Standard interface for AES cryptographic routines */ /* These are all based on 32 bit unsigned values and will therefore */ -/* require endian conversions for big-endian architectures */ +/* require endian conversions for big-endian architectures */ rijndael_ctx * -rijndael_set_key (rijndael_ctx *, const u4byte *, const u4byte, int); -void rijndael_encrypt (rijndael_ctx *, const u4byte *, u4byte *); -void rijndael_decrypt (rijndael_ctx *, const u4byte *, u4byte *); + rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int); +void rijndael_encrypt(rijndael_ctx *, const u4byte *, u4byte *); +void rijndael_decrypt(rijndael_ctx *, const u4byte *, u4byte *); /* conventional interface */ -void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc); -void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len); -void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len); -void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len); -void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len); +void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc); +void aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len); +void aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len); +void aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len); +void aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len); - -#endif /* _RIJNDAEL_H_ */ +#endif /* _RIJNDAEL_H_ */ diff --git a/contrib/pgcrypto/sha1.c b/contrib/pgcrypto/sha1.c index 20c6230540..2609569790 100644 --- a/contrib/pgcrypto/sha1.c +++ b/contrib/pgcrypto/sha1.c @@ -1,4 +1,4 @@ -/* $Id: sha1.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */ +/* $Id: sha1.c,v 1.8 2001/10/25 05:49:20 momjian Exp $ */ /* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ /* @@ -87,7 +87,7 @@ do { \ static void sha1_step(struct sha1_ctxt *); static void -sha1_step(struct sha1_ctxt *ctxt) +sha1_step(struct sha1_ctxt * ctxt) { uint32 a, b, @@ -232,7 +232,7 @@ sha1_step(struct sha1_ctxt *ctxt) /*------------------------------------------------------------*/ void -sha1_init(struct sha1_ctxt *ctxt) +sha1_init(struct sha1_ctxt * ctxt) { bzero(ctxt, sizeof(struct sha1_ctxt)); H(0) = 0x67452301; @@ -243,7 +243,7 @@ sha1_init(struct sha1_ctxt *ctxt) } void -sha1_pad(struct sha1_ctxt *ctxt) +sha1_pad(struct sha1_ctxt * ctxt) { size_t padlen; /* pad length in bytes */ size_t padstart; @@ -286,7 +286,7 @@ sha1_pad(struct sha1_ctxt *ctxt) } void -sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len) +sha1_loop(struct sha1_ctxt * ctxt, const uint8 *input0, size_t len) { const uint8 *input; size_t gaplen; @@ -314,7 +314,7 @@ sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len) } void -sha1_result(struct sha1_ctxt *ctxt, uint8 *digest0) +sha1_result(struct sha1_ctxt * ctxt, uint8 *digest0) { uint8 *digest; diff --git a/contrib/pgcrypto/sha1.h b/contrib/pgcrypto/sha1.h index c83bd7191a..03c6443ccc 100644 --- a/contrib/pgcrypto/sha1.h +++ b/contrib/pgcrypto/sha1.h @@ -1,4 +1,4 @@ -/* $Id: sha1.h,v 1.5 2001/08/21 00:42:41 momjian Exp $ */ +/* $Id: sha1.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */ /* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */ /* @@ -71,5 +71,4 @@ typedef struct sha1_ctxt SHA1_CTX; #define SHA1Final(x, y) sha1_result((y), (x)) #define SHA1_RESULTLEN (160/8) - #endif /* _NETINET6_SHA1_H_ */ diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c index e88be90501..45e9229810 100644 --- a/contrib/pgstattuple/pgstattuple.c +++ b/contrib/pgstattuple/pgstattuple.c @@ -1,5 +1,5 @@ /* - * $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.1 2001/10/01 01:52:38 ishii Exp $ + * $Header: /cvsroot/pgsql/contrib/pgstattuple/pgstattuple.c,v 1.2 2001/10/25 05:49:20 momjian Exp $ * * Copyright (c) 2001 Tatsuo Ishii * @@ -42,90 +42,91 @@ extern Datum pgstattuple(PG_FUNCTION_ARGS); Datum pgstattuple(PG_FUNCTION_ARGS) { - Name p = PG_GETARG_NAME(0); - - Relation rel; - HeapScanDesc scan; - HeapTuple tuple; - BlockNumber nblocks; - BlockNumber block = InvalidBlockNumber; - double table_len; - uint64 tuple_len = 0; - uint64 dead_tuple_len = 0; - uint32 tuple_count = 0; - uint32 dead_tuple_count = 0; - double tuple_percent; - double dead_tuple_percent; - - Buffer buffer = InvalidBuffer; - uint64 free_space = 0; /* free/reusable space in bytes */ - double free_percent; /* free/reusable space in % */ - - rel = heap_openr(NameStr(*p), NoLock); - nblocks = RelationGetNumberOfBlocks(rel); - scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL); - - while ((tuple = heap_getnext(scan,0))) - { - if (HeapTupleSatisfiesNow(tuple->t_data)) + Name p = PG_GETARG_NAME(0); + + Relation rel; + HeapScanDesc scan; + HeapTuple tuple; + BlockNumber nblocks; + BlockNumber block = InvalidBlockNumber; + double table_len; + uint64 tuple_len = 0; + uint64 dead_tuple_len = 0; + uint32 tuple_count = 0; + uint32 dead_tuple_count = 0; + double tuple_percent; + double dead_tuple_percent; + + Buffer buffer = InvalidBuffer; + uint64 free_space = 0; /* free/reusable space in bytes */ + double free_percent; /* free/reusable space in % */ + + rel = heap_openr(NameStr(*p), NoLock); + nblocks = RelationGetNumberOfBlocks(rel); + scan = heap_beginscan(rel, false, SnapshotAny, 0, NULL); + + while ((tuple = heap_getnext(scan, 0))) { - tuple_len += tuple->t_len; - tuple_count++; + if (HeapTupleSatisfiesNow(tuple->t_data)) + { + tuple_len += tuple->t_len; + tuple_count++; + } + else + { + dead_tuple_len += tuple->t_len; + dead_tuple_count++; + } + + if (!BlockNumberIsValid(block) || + block != BlockIdGetBlockNumber(&tuple->t_self.ip_blkid)) + { + block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid); + buffer = ReadBuffer(rel, block); + free_space += PageGetFreeSpace((Page) BufferGetPage(buffer)); + ReleaseBuffer(buffer); + } } - else + heap_endscan(scan); + heap_close(rel, NoLock); + + table_len = (double) nblocks *BLCKSZ; + + if (nblocks == 0) { - dead_tuple_len += tuple->t_len; - dead_tuple_count++; + tuple_percent = 0.0; + dead_tuple_percent = 0.0; + free_percent = 0.0; } - - if (!BlockNumberIsValid(block) || - block != BlockIdGetBlockNumber(&tuple->t_self.ip_blkid)) + else { - block = BlockIdGetBlockNumber(&tuple->t_self.ip_blkid); - buffer = ReadBuffer(rel, block); - free_space += PageGetFreeSpace((Page)BufferGetPage(buffer)); - ReleaseBuffer(buffer); + tuple_percent = (double) tuple_len *100.0 / table_len; + dead_tuple_percent = (double) dead_tuple_len *100.0 / table_len; + free_percent = (double) free_space *100.0 / table_len; } - } - heap_endscan(scan); - heap_close(rel, NoLock); - - table_len = (double)nblocks*BLCKSZ; - - if (nblocks == 0) - { - tuple_percent = 0.0; - dead_tuple_percent = 0.0; - free_percent = 0.0; - } - else - { - tuple_percent = (double)tuple_len*100.0/table_len; - dead_tuple_percent = (double)dead_tuple_len*100.0/table_len; - free_percent = (double)free_space*100.0/table_len; - } - elog(NOTICE,"physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%", + elog(NOTICE, "physical length: %.2fMB live tuples: %u (%.2fMB, %.2f%%) dead tuples: %u (%.2fMB, %.2f%%) free/reusable space: %.2fMB (%.2f%%) overhead: %.2f%%", - table_len/1024/1024, /* phsical length in MB */ + table_len / 1024 / 1024, /* phsical length in MB */ - tuple_count, /* number of live tuples */ - (double)tuple_len/1024/1024, /* live tuples in MB */ - tuple_percent, /* live tuples in % */ + tuple_count, /* number of live tuples */ + (double) tuple_len / 1024 / 1024, /* live tuples in MB */ + tuple_percent, /* live tuples in % */ - dead_tuple_count, /* number of dead tuples */ - (double)dead_tuple_len/1024/1024, /* dead tuples in MB */ - dead_tuple_percent, /* dead tuples in % */ + dead_tuple_count, /* number of dead tuples */ + (double) dead_tuple_len / 1024 / 1024, /* dead tuples in MB */ + dead_tuple_percent, /* dead tuples in % */ - (double)free_space/1024/1024, /* free/available space in MB */ + (double) free_space / 1024 / 1024, /* free/available space in + * MB */ - free_percent, /* free/available space in % */ + free_percent, /* free/available space in % */ - /* overhead in % */ - (nblocks == 0)?0.0: 100.0 - - tuple_percent - - dead_tuple_percent - - free_percent); + /* overhead in % */ + (nblocks == 0) ? 0.0 : 100.0 + - tuple_percent + - dead_tuple_percent + - free_percent); - PG_RETURN_FLOAT8(dead_tuple_percent); + PG_RETURN_FLOAT8(dead_tuple_percent); } diff --git a/contrib/rserv/rserv.c b/contrib/rserv/rserv.c index 02c71220d6..be4a136a1b 100644 --- a/contrib/rserv/rserv.c +++ b/contrib/rserv/rserv.c @@ -24,7 +24,6 @@ Datum _rserv_debug_(PG_FUNCTION_ARGS); HeapTuple _rserv_log_(void); int32 _rserv_sync_(int32); int32 _rserv_debug_(int32); - #endif static int debug = 0; @@ -44,7 +43,7 @@ _rserv_log_() char **args; /* argument: argnum */ Relation rel; /* triggered relation */ HeapTuple tuple; /* tuple to return */ - HeapTuple newtuple = NULL;/* tuple to return */ + HeapTuple newtuple = NULL; /* tuple to return */ TupleDesc tupdesc; /* tuple description */ int keynum; char *key; @@ -88,6 +87,7 @@ _rserv_log_() newtuple = CurrentTriggerData->tg_newtuple; #ifndef PG_FUNCTION_INFO_V1 + /* * Setting CurrentTriggerData to NULL prevents direct calls to trigger * functions in queries. Normally, trigger functions have to be called @@ -207,7 +207,6 @@ _rserv_sync_(int32 server) { #ifdef PG_FUNCTION_INFO_V1 int32 server = PG_GETARG_INT32(0); - #endif char sql[8192]; char buf[8192]; @@ -253,7 +252,6 @@ _rserv_debug_(int32 newval) { #ifdef PG_FUNCTION_INFO_V1 int32 newval = PG_GETARG_INT32(0); - #endif int32 oldval = debug; diff --git a/contrib/rtree_gist/rtree_gist.c b/contrib/rtree_gist/rtree_gist.c index ca6263fc9e..cbbe024c03 100644 --- a/contrib/rtree_gist/rtree_gist.c +++ b/contrib/rtree_gist/rtree_gist.c @@ -1,13 +1,13 @@ /*------------------------------------------------------------------------- * * rtree_gist.c - * pg_amproc entries for GiSTs over 2-D boxes. + * pg_amproc entries for GiSTs over 2-D boxes. * This gives R-tree behavior, with Guttman's poly-time split algorithm. * * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.3 2001/10/01 17:53:11 tgl Exp $ + * $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.4 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -20,9 +20,9 @@ #include "utils/geo_decls.h" #include "utils/elog.h" -typedef Datum (*RDF)(PG_FUNCTION_ARGS); -typedef Datum (*BINARY_UNION)(Datum, Datum, int*); -typedef float (*SIZE_BOX)(Datum); +typedef Datum (*RDF) (PG_FUNCTION_ARGS); +typedef Datum (*BINARY_UNION) (Datum, Datum, int *); +typedef float (*SIZE_BOX) (Datum); /* ** box ops @@ -34,24 +34,24 @@ PG_FUNCTION_INFO_V1(gbox_consistent); PG_FUNCTION_INFO_V1(gbox_penalty); PG_FUNCTION_INFO_V1(gbox_same); -Datum gbox_compress(PG_FUNCTION_ARGS); -Datum gbox_union(PG_FUNCTION_ARGS); -Datum gbox_picksplit(PG_FUNCTION_ARGS); -Datum gbox_consistent(PG_FUNCTION_ARGS); -Datum gbox_penalty(PG_FUNCTION_ARGS); -Datum gbox_same(PG_FUNCTION_ARGS); +Datum gbox_compress(PG_FUNCTION_ARGS); +Datum gbox_union(PG_FUNCTION_ARGS); +Datum gbox_picksplit(PG_FUNCTION_ARGS); +Datum gbox_consistent(PG_FUNCTION_ARGS); +Datum gbox_penalty(PG_FUNCTION_ARGS); +Datum gbox_same(PG_FUNCTION_ARGS); static bool gbox_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy); -static float size_box( Datum box ); +static float size_box(Datum box); /* -** Polygon ops +** Polygon ops */ PG_FUNCTION_INFO_V1(gpoly_compress); PG_FUNCTION_INFO_V1(gpoly_consistent); -Datum gpoly_compress(PG_FUNCTION_ARGS); -Datum gpoly_consistent(PG_FUNCTION_ARGS); +Datum gpoly_compress(PG_FUNCTION_ARGS); +Datum gpoly_consistent(PG_FUNCTION_ARGS); /* ** Common rtree-function (for all ops) @@ -60,7 +60,7 @@ static bool rtree_internal_consistent(BOX *key, BOX *query, StrategyNumber strat PG_FUNCTION_INFO_V1(rtree_decompress); -Datum rtree_decompress(PG_FUNCTION_ARGS); +Datum rtree_decompress(PG_FUNCTION_ARGS); /************************************************** * Box ops @@ -75,21 +75,21 @@ Datum rtree_decompress(PG_FUNCTION_ARGS); Datum gbox_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); - BOX *query = (BOX*) PG_GETARG_POINTER(1); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - - /* - ** if entry is not leaf, use gbox_internal_consistent, - ** else use gbox_leaf_consistent - */ - if ( ! (DatumGetPointer(entry->key) != NULL && query) ) + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + BOX *query = (BOX *) PG_GETARG_POINTER(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* + * * if entry is not leaf, use gbox_internal_consistent, * else use + * gbox_leaf_consistent + */ + if (!(DatumGetPointer(entry->key) != NULL && query)) PG_RETURN_BOOL(FALSE); - if (GIST_LEAF(entry)) - PG_RETURN_BOOL(gbox_leaf_consistent((BOX *) DatumGetPointer(entry->key), query, strategy)); - else - PG_RETURN_BOOL(rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), query, strategy)); + if (GIST_LEAF(entry)) + PG_RETURN_BOOL(gbox_leaf_consistent((BOX *) DatumGetPointer(entry->key), query, strategy)); + else + PG_RETURN_BOOL(rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), query, strategy)); } @@ -100,30 +100,33 @@ gbox_consistent(PG_FUNCTION_ARGS) Datum gbox_union(PG_FUNCTION_ARGS) { - bytea *entryvec = (bytea*) PG_GETARG_POINTER(0); - int *sizep = (int*) PG_GETARG_POINTER(1); - int numranges, i; - BOX *cur, *pageunion; - - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - pageunion = (BOX *)palloc( sizeof(BOX) ); - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[0].key ); - memcpy( (void*)pageunion, (void*)cur, sizeof( BOX ) ); - - for (i = 1; i < numranges; i++) { - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key ); - if ( pageunion->high.x < cur->high.x ) - pageunion->high.x = cur->high.x; - if ( pageunion->low.x > cur->low.x ) - pageunion->low.x = cur->low.x; - if ( pageunion->high.y < cur->high.y ) - pageunion->high.y = cur->high.y; - if ( pageunion->low.y > cur->low.y ) - pageunion->low.y = cur->low.y; - } - *sizep = sizeof(BOX); - - PG_RETURN_POINTER(pageunion); + bytea *entryvec = (bytea *) PG_GETARG_POINTER(0); + int *sizep = (int *) PG_GETARG_POINTER(1); + int numranges, + i; + BOX *cur, + *pageunion; + + numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY); + pageunion = (BOX *) palloc(sizeof(BOX)); + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key); + memcpy((void *) pageunion, (void *) cur, sizeof(BOX)); + + for (i = 1; i < numranges; i++) + { + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key); + if (pageunion->high.x < cur->high.x) + pageunion->high.x = cur->high.x; + if (pageunion->low.x > cur->low.x) + pageunion->low.x = cur->low.x; + if (pageunion->high.y < cur->high.y) + pageunion->high.y = cur->high.y; + if (pageunion->low.y > cur->low.y) + pageunion->low.y = cur->low.y; + } + *sizep = sizeof(BOX); + + PG_RETURN_POINTER(pageunion); } /* @@ -143,18 +146,19 @@ gbox_compress(PG_FUNCTION_ARGS) Datum gbox_penalty(PG_FUNCTION_ARGS) { - GISTENTRY *origentry = (GISTENTRY*) PG_GETARG_POINTER(0); - GISTENTRY *newentry = (GISTENTRY*) PG_GETARG_POINTER(1); - float *result = (float*) PG_GETARG_POINTER(2); - Datum ud; - float tmp1; - - ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key); - tmp1 = size_box( ud ); - if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud)); - - *result = tmp1 - size_box( origentry->key ); - PG_RETURN_POINTER(result); + GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + Datum ud; + float tmp1; + + ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key); + tmp1 = size_box(ud); + if (DatumGetPointer(ud) != NULL) + pfree(DatumGetPointer(ud)); + + *result = tmp1 - size_box(origentry->key); + PG_RETURN_POINTER(result); } /* @@ -165,145 +169,183 @@ gbox_penalty(PG_FUNCTION_ARGS) Datum gbox_picksplit(PG_FUNCTION_ARGS) { - bytea *entryvec = (bytea*)PG_GETARG_POINTER(0); - GIST_SPLITVEC *v = (GIST_SPLITVEC*)PG_GETARG_POINTER(1); - OffsetNumber i; - OffsetNumber *listL, *listR, *listB, *listT; - BOX *unionL,*unionR,*unionB,*unionT; - int posL, posR, posB, posT; - BOX pageunion; - BOX *cur; - char direction=' '; - bool allisequal=true; - OffsetNumber maxoff; - int nbytes; - - posL = posR = posB = posT = 0; - maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1; - - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key ); - memcpy( (void*)&pageunion, (void*)cur, sizeof( BOX ) ); - - /* find MBR */ - for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i)) { - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key ); - if ( pageunion.high.x < cur->high.x ) - { allisequal=false; pageunion.high.x = cur->high.x; } - if ( pageunion.low.x > cur->low.x ) - { allisequal=false; pageunion.low.x = cur->low.x; } - if ( pageunion.high.y < cur->high.y ) - { allisequal=false; pageunion.high.y = cur->high.y; } - if ( pageunion.low.y > cur->low.y ) - { allisequal=false; pageunion.low.y = cur->low.y; } - } - - nbytes = (maxoff + 2) * sizeof(OffsetNumber); - listL = (OffsetNumber*)palloc( nbytes ); - listR = (OffsetNumber*)palloc( nbytes ); - unionL = (BOX*)palloc( sizeof(BOX) ); - unionR = (BOX*)palloc( sizeof(BOX) ); - if ( allisequal ) { - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key ); - if ( memcmp( (void*)cur, (void*)&pageunion, sizeof( BOX ) ) == 0 ) { - v->spl_left = listL; - v->spl_right = listR; - v->spl_nleft = v->spl_nright = 0; - memcpy( (void*)unionL, (void*)&pageunion, sizeof( BOX ) ); - memcpy( (void*)unionR, (void*)&pageunion, sizeof( BOX ) ); - - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - if (i <= (maxoff - FirstOffsetNumber + 1)/2) { - v->spl_left[ v->spl_nleft ] = i; - v->spl_nleft++; - } else { - v->spl_right[ v->spl_nright ] = i; - v->spl_nright++; - } + bytea *entryvec = (bytea *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + OffsetNumber i; + OffsetNumber *listL, + *listR, + *listB, + *listT; + BOX *unionL, + *unionR, + *unionB, + *unionT; + int posL, + posR, + posB, + posT; + BOX pageunion; + BOX *cur; + char direction = ' '; + bool allisequal = true; + OffsetNumber maxoff; + int nbytes; + + posL = posR = posB = posT = 0; + maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1; + + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key); + memcpy((void *) &pageunion, (void *) cur, sizeof(BOX)); + + /* find MBR */ + for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i)) + { + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key); + if (pageunion.high.x < cur->high.x) + { + allisequal = false; + pageunion.high.x = cur->high.x; } - v->spl_ldatum = BoxPGetDatum( unionL ); - v->spl_rdatum = BoxPGetDatum( unionR ); + if (pageunion.low.x > cur->low.x) + { + allisequal = false; + pageunion.low.x = cur->low.x; + } + if (pageunion.high.y < cur->high.y) + { + allisequal = false; + pageunion.high.y = cur->high.y; + } + if (pageunion.low.y > cur->low.y) + { + allisequal = false; + pageunion.low.y = cur->low.y; + } + } - PG_RETURN_POINTER( v ); + nbytes = (maxoff + 2) * sizeof(OffsetNumber); + listL = (OffsetNumber *) palloc(nbytes); + listR = (OffsetNumber *) palloc(nbytes); + unionL = (BOX *) palloc(sizeof(BOX)); + unionR = (BOX *) palloc(sizeof(BOX)); + if (allisequal) + { + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key); + if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0) + { + v->spl_left = listL; + v->spl_right = listR; + v->spl_nleft = v->spl_nright = 0; + memcpy((void *) unionL, (void *) &pageunion, sizeof(BOX)); + memcpy((void *) unionR, (void *) &pageunion, sizeof(BOX)); + + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + if (i <= (maxoff - FirstOffsetNumber + 1) / 2) + { + v->spl_left[v->spl_nleft] = i; + v->spl_nleft++; + } + else + { + v->spl_right[v->spl_nright] = i; + v->spl_nright++; + } + } + v->spl_ldatum = BoxPGetDatum(unionL); + v->spl_rdatum = BoxPGetDatum(unionR); + + PG_RETURN_POINTER(v); + } } - } - listB = (OffsetNumber*)palloc( nbytes ); - listT = (OffsetNumber*)palloc( nbytes ); - unionB = (BOX*)palloc( sizeof(BOX) ); - unionT = (BOX*)palloc( sizeof(BOX) ); + listB = (OffsetNumber *) palloc(nbytes); + listT = (OffsetNumber *) palloc(nbytes); + unionB = (BOX *) palloc(sizeof(BOX)); + unionT = (BOX *) palloc(sizeof(BOX)); #define ADDLIST( list, unionD, pos ) do { \ if ( pos ) { \ - if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \ - if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \ - if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \ - if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \ + if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \ + if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \ + if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \ + if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \ } else { \ - memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \ + memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \ } \ list[pos] = i; \ (pos)++; \ } while(0) - for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key ); - if ( cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x ) - ADDLIST( listL, unionL, posL ); - else - ADDLIST( listR, unionR, posR ); - if ( cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y ) - ADDLIST( listB, unionB, posB ); - else - ADDLIST( listT, unionT, posT ); - } - - /* which split more optimal? */ - - if ( Max( posL, posR ) < Max( posB, posT ) ) { - direction = 'x'; - } else if ( Max( posL, posR ) > Max( posB, posT ) ) { - direction = 'y'; - } else { - Datum interLR = DirectFunctionCall2(rt_box_inter, - BoxPGetDatum(unionL), - BoxPGetDatum(unionR)); - Datum interBT = DirectFunctionCall2(rt_box_inter, - BoxPGetDatum(unionB), - BoxPGetDatum(unionT)); - float sizeLR, sizeBT; - - sizeLR = size_box( interLR ); - sizeBT = size_box( interBT ); - - if ( sizeLR < sizeBT ) + for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) + { + cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key); + if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x) + ADDLIST(listL, unionL, posL); + else + ADDLIST(listR, unionR, posR); + if (cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y) + ADDLIST(listB, unionB, posB); + else + ADDLIST(listT, unionT, posT); + } + + /* which split more optimal? */ + + if (Max(posL, posR) < Max(posB, posT)) direction = 'x'; - else + else if (Max(posL, posR) > Max(posB, posT)) direction = 'y'; + else + { + Datum interLR = DirectFunctionCall2(rt_box_inter, + BoxPGetDatum(unionL), + BoxPGetDatum(unionR)); + Datum interBT = DirectFunctionCall2(rt_box_inter, + BoxPGetDatum(unionB), + BoxPGetDatum(unionT)); + float sizeLR, + sizeBT; + + sizeLR = size_box(interLR); + sizeBT = size_box(interBT); + + if (sizeLR < sizeBT) + direction = 'x'; + else + direction = 'y'; + } + + if (direction == 'x') + { + pfree(unionB); + pfree(listB); + pfree(unionT); + pfree(listT); + + v->spl_left = listL; + v->spl_right = listR; + v->spl_nleft = posL; + v->spl_nright = posR; + v->spl_ldatum = BoxPGetDatum(unionL); + v->spl_rdatum = BoxPGetDatum(unionR); + } + else + { + pfree(unionR); + pfree(listR); + pfree(unionL); + pfree(listL); + + v->spl_left = listB; + v->spl_right = listT; + v->spl_nleft = posB; + v->spl_nright = posT; + v->spl_ldatum = BoxPGetDatum(unionB); + v->spl_rdatum = BoxPGetDatum(unionT); } - if ( direction == 'x' ) { - pfree( unionB ); pfree( listB ); - pfree( unionT ); pfree( listT ); - - v->spl_left = listL; - v->spl_right = listR; - v->spl_nleft = posL; - v->spl_nright = posR; - v->spl_ldatum = BoxPGetDatum( unionL ); - v->spl_rdatum = BoxPGetDatum( unionR ); - } else { - pfree( unionR ); pfree( listR ); - pfree( unionL ); pfree( listL ); - - v->spl_left = listB; - v->spl_right = listT; - v->spl_nleft = posB; - v->spl_nright = posT; - v->spl_ldatum = BoxPGetDatum( unionB ); - v->spl_rdatum = BoxPGetDatum( unionT ); - } - - PG_RETURN_POINTER (v); + PG_RETURN_POINTER(v); } /* @@ -312,66 +354,71 @@ gbox_picksplit(PG_FUNCTION_ARGS) Datum gbox_same(PG_FUNCTION_ARGS) { - BOX *b1 = (BOX*) PG_GETARG_POINTER(0); - BOX *b2 = (BOX*) PG_GETARG_POINTER(1); - bool *result = (bool*) PG_GETARG_POINTER(2); - if ( b1 && b2 ) - *result = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(b1), PointerGetDatum(b2)) ); - else - *result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE; - PG_RETURN_POINTER(result); + BOX *b1 = (BOX *) PG_GETARG_POINTER(0); + BOX *b2 = (BOX *) PG_GETARG_POINTER(1); + bool *result = (bool *) PG_GETARG_POINTER(2); + + if (b1 && b2) + *result = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(b1), PointerGetDatum(b2))); + else + *result = (b1 == NULL && b2 == NULL) ? TRUE : FALSE; + PG_RETURN_POINTER(result); } -/* +/* ** SUPPORT ROUTINES for boxes */ -static bool +static bool gbox_leaf_consistent(BOX *key, - BOX *query, - StrategyNumber strategy) + BOX *query, + StrategyNumber strategy) { - bool retval; - - switch(strategy) { - case RTLeftStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_left, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTOverLeftStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTOverlapStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTOverRightStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overright, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTRightStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTSameStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTContainsStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTContainedByStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_contained, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - default: - retval = FALSE; - } - return(retval); + bool retval; + + switch (strategy) + { + case RTLeftStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_left, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTOverLeftStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTOverlapStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTOverRightStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overright, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTRightStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTSameStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_same, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTContainsStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTContainedByStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_contained, PointerGetDatum(key), PointerGetDatum(query))); + break; + default: + retval = FALSE; + } + return (retval); } -static float -size_box( Datum box ) { - if ( DatumGetPointer(box) != NULL ) { - float size; +static float +size_box(Datum box) +{ + if (DatumGetPointer(box) != NULL) + { + float size; - DirectFunctionCall2( rt_box_size, - box, PointerGetDatum( &size ) ); + DirectFunctionCall2(rt_box_size, + box, PointerGetDatum(&size)); return size; - } else + } + else return 0.0; } @@ -382,91 +429,97 @@ size_box( Datum box ) { Datum gpoly_compress(PG_FUNCTION_ARGS) { - GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0); - GISTENTRY *retval; + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *retval; - if ( entry->leafkey) { + if (entry->leafkey) + { retval = palloc(sizeof(GISTENTRY)); - if ( DatumGetPointer(entry->key) != NULL ) { - POLYGON *in; - BOX *r; + if (DatumGetPointer(entry->key) != NULL) + { + POLYGON *in; + BOX *r; + in = (POLYGON *) PG_DETOAST_DATUM(entry->key); - r = (BOX *) palloc( sizeof(BOX) ); - memcpy( (void*)r, (void*)&(in->boundbox), sizeof(BOX) ); - if ( in != (POLYGON *) DatumGetPointer(entry->key) ) - pfree( in ); + r = (BOX *) palloc(sizeof(BOX)); + memcpy((void *) r, (void *) &(in->boundbox), sizeof(BOX)); + if (in != (POLYGON *) DatumGetPointer(entry->key)) + pfree(in); gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, entry->offset, sizeof(BOX), FALSE); - } else { + } + else + { gistentryinit(*retval, (Datum) 0, entry->rel, entry->page, - entry->offset, 0,FALSE); - } - } else { - retval = entry; + entry->offset, 0, FALSE); + } } - PG_RETURN_POINTER( retval ); + else + retval = entry; + PG_RETURN_POINTER(retval); } Datum gpoly_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0); - POLYGON *query = (POLYGON*)PG_DETOAST_DATUM( PG_GETARG_POINTER(1) ); - StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); - bool result; - - /* - ** if entry is not leaf, use gbox_internal_consistent, - ** else use gbox_leaf_consistent - */ - if ( ! (DatumGetPointer(entry->key) != NULL && query) ) + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + POLYGON *query = (POLYGON *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1)); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + bool result; + + /* + * * if entry is not leaf, use gbox_internal_consistent, * else use + * gbox_leaf_consistent + */ + if (!(DatumGetPointer(entry->key) != NULL && query)) PG_RETURN_BOOL(FALSE); - result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), - &(query->boundbox), strategy); + result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key), + &(query->boundbox), strategy); - PG_FREE_IF_COPY(query,1); - PG_RETURN_BOOL( result ); + PG_FREE_IF_COPY(query, 1); + PG_RETURN_BOOL(result); } /***************************************** * Common rtree-function (for all ops) *****************************************/ -static bool +static bool rtree_internal_consistent(BOX *key, - BOX *query, - StrategyNumber strategy) + BOX *query, + StrategyNumber strategy) { - bool retval; - - switch(strategy) { - case RTLeftStrategyNumber: - case RTOverLeftStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overleft, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTOverlapStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTOverRightStrategyNumber: - case RTRightStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_right, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTSameStrategyNumber: - case RTContainsStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_contain, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - case RTContainedByStrategyNumber: - retval = DatumGetBool( DirectFunctionCall2( box_overlap, PointerGetDatum(key), PointerGetDatum(query) ) ); - break; - default: - retval = FALSE; - } - return(retval); + bool retval; + + switch (strategy) + { + case RTLeftStrategyNumber: + case RTOverLeftStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overleft, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTOverlapStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTOverRightStrategyNumber: + case RTRightStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_right, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_contain, PointerGetDatum(key), PointerGetDatum(query))); + break; + case RTContainedByStrategyNumber: + retval = DatumGetBool(DirectFunctionCall2(box_overlap, PointerGetDatum(key), PointerGetDatum(query))); + break; + default: + retval = FALSE; + } + return (retval); } /* diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c index 124299ab44..097304b638 100644 --- a/contrib/seg/seg.c +++ b/contrib/seg/seg.c @@ -138,7 +138,6 @@ seg_out(SEG * seg) if (seg->lower == seg->upper && seg->l_ext == seg->u_ext) { - /* * indicates that this interval was built by seg_in off a single * point @@ -219,7 +218,6 @@ gseg_consistent(GISTENTRY *entry, SEG * query, StrategyNumber strategy) { - /* * * if entry is not leaf, use gseg_internal_consistent, * else use * gseg_leaf_consistent @@ -253,7 +251,7 @@ gseg_union(bytea *entryvec, int *sizep) for (i = 1; i < numranges; i++) { out = gseg_binary_union(tmp, (SEG *) - DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key), + DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key), sizep); if (i > 1) pfree(tmp); @@ -267,13 +265,13 @@ gseg_union(bytea *entryvec, int *sizep) ** GiST Compress and Decompress methods for segments ** do not do anything. */ -GISTENTRY * +GISTENTRY * gseg_compress(GISTENTRY *entry) { return (entry); } -GISTENTRY * +GISTENTRY * gseg_decompress(GISTENTRY *entry) { return (entry); @@ -415,7 +413,6 @@ gseg_picksplit(bytea *entryvec, maxoff = OffsetNumberNext(maxoff); for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) { - /* * If we've already decided where to place this item, just put it * on the right list. Otherwise, we need to figure out which page @@ -614,7 +611,7 @@ seg_overlap(SEG * a, SEG * b) ((a->upper >= b->upper) && (a->lower <= b->upper)) || ((b->upper >= a->upper) && (b->lower <= a->upper)) - ); + ); } /* seg_overleft -- is the right edge of (a) located to the left of the right edge of (b)? @@ -757,7 +754,6 @@ seg_size(SEG * a) int32 seg_cmp(SEG * a, SEG * b) { - /* * First compare on lower boundary position */ @@ -968,7 +964,6 @@ restore(char *result, float val, int n) { if (abs(exp) <= 4) { - /* * remove the decimal point from the mantyssa and write the * digits to the buf array @@ -989,7 +984,6 @@ restore(char *result, float val, int n) { if (dp - 10 + exp >= n) { - /* * the decimal point is behind the last significant * digit; the digits in between must be converted to diff --git a/contrib/spi/refint.c b/contrib/spi/refint.c index dcc9f54daf..441c1e884d 100644 --- a/contrib/spi/refint.c +++ b/contrib/spi/refint.c @@ -52,7 +52,7 @@ check_primary_key(PG_FUNCTION_ARGS) HeapTuple tuple = NULL; /* tuple to return */ TupleDesc tupdesc; /* tuple description */ EPlan *plan; /* prepared plan */ - Oid *argtypes = NULL;/* key types to prepare execution plan */ + Oid *argtypes = NULL; /* key types to prepare execution plan */ bool isnull; /* to know is some column NULL or not */ char ident[2 * NAMEDATALEN]; /* to identify myself */ int ret; @@ -235,10 +235,10 @@ check_foreign_key(PG_FUNCTION_ARGS) char *relname; /* referencing relation name */ Relation rel; /* triggered relation */ HeapTuple trigtuple = NULL; /* tuple to being changed */ - HeapTuple newtuple = NULL;/* tuple to return */ + HeapTuple newtuple = NULL; /* tuple to return */ TupleDesc tupdesc; /* tuple description */ EPlan *plan; /* prepared plan(s) */ - Oid *argtypes = NULL;/* key types to prepare execution plan */ + Oid *argtypes = NULL; /* key types to prepare execution plan */ bool isnull; /* to know is some column NULL or not */ bool isequal = true; /* are keys in both tuples equal (in * UPDATE) */ @@ -402,11 +402,11 @@ check_foreign_key(PG_FUNCTION_ARGS) /*--------- * For 'R'estrict action we construct SELECT query: * - * SELECT 1 + * SELECT 1 * FROM _referencing_relation_ * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] * - * to check is tuple referenced or not. + * to check is tuple referenced or not. *--------- */ if (action == 'r') @@ -537,7 +537,6 @@ check_foreign_key(PG_FUNCTION_ARGS) */ for (r = 0; r < nrefs; r++) { - /* * For 'R'estrict we may to execute plan for one tuple only, for * other actions - for all tuples. diff --git a/contrib/string/string_io.c b/contrib/string/string_io.c index 840782dd51..fdc6da1915 100644 --- a/contrib/string/string_io.c +++ b/contrib/string/string_io.c @@ -359,7 +359,6 @@ c_charin(unsigned char *str) { return (string_input(str, 1, 0, NULL)); } - #endif /* end of file */ diff --git a/contrib/string/string_io.h b/contrib/string/string_io.h index 556c33660c..b6a368698a 100644 --- a/contrib/string/string_io.h +++ b/contrib/string/string_io.h @@ -13,7 +13,6 @@ struct varlena *c_textin(unsigned char *str); int32 * c_charin(unsigned char *str) #endif - #endif /* diff --git a/contrib/tsearch/crc32.c b/contrib/tsearch/crc32.c index 61cb6ed3ed..dc93db727c 100644 --- a/contrib/tsearch/crc32.c +++ b/contrib/tsearch/crc32.c @@ -87,15 +87,17 @@ static const unsigned int crc32tab[256] = { 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, }; -unsigned int crc32_sz(char * buf, int size){ +unsigned int +crc32_sz(char *buf, int size) +{ unsigned int crc = ~0; - char *p ; - int len, nr; + char *p; + int len, + nr; - len = 0 ; - nr=size; - for (len += nr, p = buf; nr--; ++p) { - _CRC32_(crc, *p) ; - } + len = 0; + nr = size; + for (len += nr, p = buf; nr--; ++p) + _CRC32_(crc, *p); return ~crc; } diff --git a/contrib/tsearch/crc32.h b/contrib/tsearch/crc32.h index c4f5ed703c..b08065d8c8 100644 --- a/contrib/tsearch/crc32.h +++ b/contrib/tsearch/crc32.h @@ -2,9 +2,8 @@ #define _CRC32_H /* Returns crc32 of data block */ -extern unsigned int crc32_sz(char * buf, int size); +extern unsigned int crc32_sz(char *buf, int size); /* Returns crc32 of null-terminated string */ #define crc32(buf) crc32_sz((buf),strlen(buf)) - #endif diff --git a/contrib/tsearch/deflex.h b/contrib/tsearch/deflex.h index 8c74595a68..7fbd84adf1 100644 --- a/contrib/tsearch/deflex.h +++ b/contrib/tsearch/deflex.h @@ -12,12 +12,12 @@ #define HOST 6 #define FLOAT 7 #define FINT 8 -#define PARTWORD 9 -#define NONLATINPARTWORD 10 -#define LATPARTWORD 11 -#define SPACE 12 -#define SYMTAG 13 -#define HTTP 14 +#define PARTWORD 9 +#define NONLATINPARTWORD 10 +#define LATPARTWORD 11 +#define SPACE 12 +#define SYMTAG 13 +#define HTTP 14 #define DEFISWORD 15 #define DEFISLATWORD 16 #define DEFISNONLATINWORD 17 @@ -25,6 +25,4 @@ #define FILEPATH 19 extern const char *descr[]; - #endif - diff --git a/contrib/tsearch/gistidx.h b/contrib/tsearch/gistidx.h index dc991ab0d7..f4576a1d24 100644 --- a/contrib/tsearch/gistidx.h +++ b/contrib/tsearch/gistidx.h @@ -9,7 +9,8 @@ * signature defines */ #define BITBYTE 8 -#define SIGLENINT 64 /* >121 => key will toast, so it will not work !!! */ +#define SIGLENINT 64 /* >121 => key will toast, so it will not + * work !!! */ #define SIGLEN ( sizeof(int4)*SIGLENINT ) #define SIGLENBIT (SIGLEN*BITBYTE) @@ -21,9 +22,9 @@ typedef char *BITVECP; a;\ } #define LOOPBIT(a) \ - for(i=0;i<SIGLENBIT;i++) {\ - a;\ - } + for(i=0;i<SIGLENBIT;i++) {\ + a;\ + } #define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITBYTE ) ) ) #define GETBITBYTE(x,i) ( ((char)(x)) >> i & 0x01 ) @@ -38,27 +39,27 @@ typedef char *BITVECP; /* - * type of index key + * type of index key */ -typedef struct { - int4 len; - int4 flag; - char data[1]; -} GISTTYPE; +typedef struct +{ + int4 len; + int4 flag; + char data[1]; +} GISTTYPE; -#define ARRKEY 0x01 -#define SIGNKEY 0x02 -#define ALLISTRUE 0x04 +#define ARRKEY 0x01 +#define SIGNKEY 0x02 +#define ALLISTRUE 0x04 -#define ISARRKEY(x) ( ((GISTTYPE*)x)->flag & ARRKEY ) +#define ISARRKEY(x) ( ((GISTTYPE*)x)->flag & ARRKEY ) #define ISSIGNKEY(x) ( ((GISTTYPE*)x)->flag & SIGNKEY ) #define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE ) -#define GTHDRSIZE ( sizeof(int4)*2 ) +#define GTHDRSIZE ( sizeof(int4)*2 ) #define CALCGTSIZE(flag, len) ( GTHDRSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(int4)) : (((flag) & ALLISTRUE) ? 0 : SIGLEN) ) ) #define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) ) #define GETARR(x) ( (int4*)( (char*)x+GTHDRSIZE ) ) -#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) ) +#define ARRNELEM(x) ( ( ((GISTTYPE*)x)->len - GTHDRSIZE )/sizeof(int4) ) #endif - diff --git a/contrib/tsearch/morph.c b/contrib/tsearch/morph.c index a31946ac86..3a66ecbbc6 100644 --- a/contrib/tsearch/morph.c +++ b/contrib/tsearch/morph.c @@ -3,7 +3,7 @@ * New dictionary is include in dict.h. For languages which * use latin charset it may be need to modify mapdict table. * Teodor Sigaev <[email protected]> - */ + */ #include "postgres.h" #include "utils/elog.h" @@ -20,157 +20,183 @@ * All of this methods are optional, but * if all methods are NULL, then dictionary does nothing :) * Return value of lemmatize must be palloced or the same. - * Return value of init must be malloced in other case - * it will be free in end of transaction! + * Return value of init must be malloced in other case + * it will be free in end of transaction! */ -typedef struct { - char localename[LOCALE_NAME_BUFLEN]; +typedef struct +{ + char localename[LOCALE_NAME_BUFLEN]; /* init dictionary */ - void* (*init)(void); + void *(*init) (void); /* close dictionary */ - void (*close)(void*); + void (*close) (void *); /* find in dictionary */ - char* (*lemmatize)(void*,char*,int*); - int (*is_stoplemm)(void*,char*,int); - int (*is_stemstoplemm)(void*,char*,int); -} DICT; + char *(*lemmatize) (void *, char *, int *); + int (*is_stoplemm) (void *, char *, int); + int (*is_stemstoplemm) (void *, char *, int); +} DICT; /* insert all dictionaries */ #define DICT_BODY #include "dict.h" -#undef DICT_BODY +#undef DICT_BODY -/* fill dictionary's structure */ +/* fill dictionary's structure */ #define DICT_TABLE -DICT dicts[] = { +DICT dicts[] = { { - "C",NULL,NULL,NULL,NULL,NULL /* fake dictionary */ + "C", NULL, NULL, NULL, NULL, NULL /* fake dictionary */ } #include "dict.h" }; + #undef DICT_TABLE /* array for storing dictinary's objects (if needed) */ -void* dictobjs[ lengthof(dicts) ]; +void *dictobjs[ + lengthof(dicts)]; #define STOPLEXEM -2 #define BYLOCALE -1 -#define NODICT 0 -#define DEFAULTDICT 1 - +#define NODICT 0 +#define DEFAULTDICT 1 + #define MAXNDICT 2 -typedef int2 MAPDICT[MAXNDICT]; +typedef int2 MAPDICT[MAXNDICT]; + #define GETDICT(x,i) *( ((int2*)(x)) + (i) ) /* map dictionaries for lexem type */ static MAPDICT mapdict[] = { - {NODICT, NODICT}, /* not used */ - {DEFAULTDICT, NODICT}, /* LATWORD */ - {BYLOCALE, NODICT}, /* NONLATINWORD */ - {BYLOCALE, DEFAULTDICT}, /* UWORD */ - {NODICT, NODICT}, /* EMAIL */ - {NODICT, NODICT}, /* FURL */ - {NODICT, NODICT}, /* HOST */ - {NODICT, NODICT}, /* FLOAT */ - {NODICT, NODICT}, /* FINT */ - {BYLOCALE, DEFAULTDICT}, /* PARTWORD */ - {BYLOCALE, NODICT}, /* NONLATINPARTWORD */ - {DEFAULTDICT, NODICT}, /* LATPARTWORD */ - {STOPLEXEM, NODICT}, /* SPACE */ - {STOPLEXEM, NODICT}, /* SYMTAG */ - {STOPLEXEM, NODICT}, /* HTTP */ - {BYLOCALE, DEFAULTDICT}, /* DEFISWORD */ - {DEFAULTDICT, NODICT}, /* DEFISLATWORD */ - {BYLOCALE, NODICT}, /* DEFISNONLATINWORD */ - {NODICT, NODICT}, /* URI */ - {NODICT, NODICT} /* FILEPATH */ + {NODICT, NODICT}, /* not used */ + {DEFAULTDICT, NODICT}, /* LATWORD */ + {BYLOCALE, NODICT}, /* NONLATINWORD */ + {BYLOCALE, DEFAULTDICT}, /* UWORD */ + {NODICT, NODICT}, /* EMAIL */ + {NODICT, NODICT}, /* FURL */ + {NODICT, NODICT}, /* HOST */ + {NODICT, NODICT}, /* FLOAT */ + {NODICT, NODICT}, /* FINT */ + {BYLOCALE, DEFAULTDICT}, /* PARTWORD */ + {BYLOCALE, NODICT}, /* NONLATINPARTWORD */ + {DEFAULTDICT, NODICT}, /* LATPARTWORD */ + {STOPLEXEM, NODICT}, /* SPACE */ + {STOPLEXEM, NODICT}, /* SYMTAG */ + {STOPLEXEM, NODICT}, /* HTTP */ + {BYLOCALE, DEFAULTDICT}, /* DEFISWORD */ + {DEFAULTDICT, NODICT}, /* DEFISLATWORD */ + {BYLOCALE, NODICT}, /* DEFISNONLATINWORD */ + {NODICT, NODICT}, /* URI */ + {NODICT, NODICT} /* FILEPATH */ }; -static bool inited=false; +static bool inited = false; + +void +initmorph(void) +{ + int i, + j, + k; + MAPDICT *md; + bool needinit[lengthof(dicts)]; -void initmorph(void) { - int i,j,k; - MAPDICT *md; - bool needinit[ lengthof(dicts) ]; #ifdef USE_LOCALE - PG_LocaleCategories lc; + PG_LocaleCategories lc; - int bylocaledict = NODICT; + int bylocaledict = NODICT; #endif - if ( inited ) return; - for(i=1; i<lengthof(dicts);i++) + if (inited) + return; + for (i = 1; i < lengthof(dicts); i++) needinit[i] = false; - + #ifdef USE_LOCALE PGLC_current(&lc); - for(i=1;i<lengthof(dicts);i++) - if (strcmp( dicts[i].localename, lc.lang ) == 0) { + for (i = 1; i < lengthof(dicts); i++) + if (strcmp(dicts[i].localename, lc.lang) == 0) + { bylocaledict = i; break; } PGLC_free_categories(&lc); #endif - for(i=1; i<lengthof(mapdict);i++) { - k=0; + for (i = 1; i < lengthof(mapdict); i++) + { + k = 0; md = &mapdict[i]; - for(j=0;j<MAXNDICT;j++) { - GETDICT(md,k) = GETDICT(md,j); - if ( GETDICT(md,k) == NODICT ) { + for (j = 0; j < MAXNDICT; j++) + { + GETDICT(md, k) = GETDICT(md, j); + if (GETDICT(md, k) == NODICT) break; - } else if ( GETDICT(md,k) == BYLOCALE ) { + else if (GETDICT(md, k) == BYLOCALE) + { #ifdef USE_LOCALE - if ( bylocaledict == NODICT ) + if (bylocaledict == NODICT) continue; - GETDICT(md,k) = bylocaledict; + GETDICT(md, k) = bylocaledict; #else continue; #endif } - if ( GETDICT(md,k) >= (int2)lengthof(dicts) ) + if (GETDICT(md, k) >= (int2) lengthof(dicts)) continue; - needinit[ GETDICT(md,k) ] = true; - k++; + needinit[GETDICT(md, k)] = true; + k++; } - for(;k<MAXNDICT;k++) - if ( GETDICT(md,k) != STOPLEXEM ) - GETDICT(md,k) = NODICT; + for (; k < MAXNDICT; k++) + if (GETDICT(md, k) != STOPLEXEM) + GETDICT(md, k) = NODICT; } - for(i=1; i<lengthof(dicts);i++) - if ( needinit[i] && dicts[i].init ) - dictobjs[i] = (*(dicts[i].init))(); - + for (i = 1; i < lengthof(dicts); i++) + if (needinit[i] && dicts[i].init) + dictobjs[i] = (*(dicts[i].init)) (); + inited = true; return; } -char* lemmatize( char* word, int *len, int type ) { - int2 nd; - int i; - DICT *dict; +char * +lemmatize(char *word, int *len, int type) +{ + int2 nd; + int i; + DICT *dict; - for(i=0;i<MAXNDICT;i++) { - nd = GETDICT( &mapdict[type], i ); - if ( nd == NODICT ) { - /* there is no dictionary */ + for (i = 0; i < MAXNDICT; i++) + { + nd = GETDICT(&mapdict[type], i); + if (nd == NODICT) + { + /* there is no dictionary */ return word; - } else if ( nd == STOPLEXEM ) { + } + else if (nd == STOPLEXEM) + { /* word is stopword */ return NULL; - } else { - dict = &dicts[ nd ]; - if ( dict->is_stoplemm && (*(dict->is_stoplemm))(dictobjs[nd], word, *len) ) + } + else + { + dict = &dicts[nd]; + if (dict->is_stoplemm && (*(dict->is_stoplemm)) (dictobjs[nd], word, *len)) return NULL; - if ( dict->lemmatize ) { - int oldlen = *len; - char *newword = (*(dict->lemmatize))(dictobjs[nd], word, len); + if (dict->lemmatize) + { + int oldlen = *len; + char *newword = (*(dict->lemmatize)) (dictobjs[nd], word, len); + /* word is recognized by distionary */ - if ( newword != word || *len != oldlen ) { - if ( dict->is_stemstoplemm && - (*(dict->is_stemstoplemm))(dictobjs[nd], word, *len) ) { - if ( newword != word && newword) + if (newword != word || *len != oldlen) + { + if (dict->is_stemstoplemm && + (*(dict->is_stemstoplemm)) (dictobjs[nd], word, *len)) + { + if (newword != word && newword) pfree(newword); return NULL; } @@ -183,6 +209,8 @@ char* lemmatize( char* word, int *len, int type ) { return word; } -bool is_stoptype(int type) { - return ( GETDICT( &mapdict[type], 0 ) == STOPLEXEM ) ? true : false; +bool +is_stoptype(int type) +{ + return (GETDICT(&mapdict[type], 0) == STOPLEXEM) ? true : false; } diff --git a/contrib/tsearch/morph.h b/contrib/tsearch/morph.h index 1e8f361ed9..1c64227fae 100644 --- a/contrib/tsearch/morph.h +++ b/contrib/tsearch/morph.h @@ -1,9 +1,9 @@ #ifndef __MORPH_H__ #define __MORPH_H__ -void initmorph(void); +void initmorph(void); -char* lemmatize( char* word, int *len, int type ); +char *lemmatize(char *word, int *len, int type); -bool is_stoptype(int type); +bool is_stoptype(int type); #endif diff --git a/contrib/tsearch/parser.h b/contrib/tsearch/parser.h index 780cb587d5..0e43e675fb 100644 --- a/contrib/tsearch/parser.h +++ b/contrib/tsearch/parser.h @@ -1,11 +1,10 @@ #ifndef __PARSER_H__ #define __PARSER_H__ -char *token; -int tokenlen; -int tsearch_yylex(void); -void start_parse_str(char*, int); -void start_parse_fh(FILE*, int); -void end_parse(void); - +char *token; +int tokenlen; +int tsearch_yylex(void); +void start_parse_str(char *, int); +void start_parse_fh(FILE *, int); +void end_parse(void); #endif diff --git a/contrib/tsearch/query.c b/contrib/tsearch/query.c index 238432ea43..90687d38cf 100644 --- a/contrib/tsearch/query.c +++ b/contrib/tsearch/query.c @@ -31,112 +31,131 @@ #include "parser.h" PG_FUNCTION_INFO_V1(mqtxt_in); -Datum mqtxt_in(PG_FUNCTION_ARGS); +Datum mqtxt_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(qtxt_in); -Datum qtxt_in(PG_FUNCTION_ARGS); +Datum qtxt_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(qtxt_out); -Datum qtxt_out(PG_FUNCTION_ARGS); +Datum qtxt_out(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(execqtxt); -Datum execqtxt(PG_FUNCTION_ARGS); +Datum execqtxt(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(rexecqtxt); -Datum rexecqtxt(PG_FUNCTION_ARGS); +Datum rexecqtxt(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(querytree); -Datum querytree(PG_FUNCTION_ARGS); - -#define END 0 -#define ERR 1 -#define VAL 2 -#define OPR 3 -#define OPEN 4 -#define CLOSE 5 -#define VALTRUE 6 /* for stop words */ +Datum querytree(PG_FUNCTION_ARGS); + +#define END 0 +#define ERR 1 +#define VAL 2 +#define OPR 3 +#define OPEN 4 +#define CLOSE 5 +#define VALTRUE 6 /* for stop words */ #define VALFALSE 7 /* parser's states */ -#define WAITOPERAND 1 +#define WAITOPERAND 1 #define WAITOPERATOR 2 /* * node of query tree, also used * for storing polish notation in parser */ -typedef struct NODE { - int4 type; - int4 val; - int2 distance; - int2 length; - struct NODE *next; -} NODE; - -typedef struct { - char *buf; - int4 state; - int4 count; - /* reverse polish notation in list (for temprorary usage)*/ - NODE *str; +typedef struct NODE +{ + int4 type; + int4 val; + int2 distance; + int2 length; + struct NODE *next; +} NODE; + +typedef struct +{ + char *buf; + int4 state; + int4 count; + /* reverse polish notation in list (for temprorary usage) */ + NODE *str; /* number in str */ - int4 num; + int4 num; /* user-friendly operand */ - int4 lenop; - int4 sumlen; - char *op; - char *curop; + int4 lenop; + int4 sumlen; + char *op; + char *curop; /* state for value's parser */ - TI_IN_STATE valstate; -} QPRS_STATE; + TI_IN_STATE valstate; +} QPRS_STATE; /* * get token from query string */ -static int4 -gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) { - while(1) { - switch(state->state) { - case WAITOPERAND: - if ( *(state->buf) == '!' ) { +static int4 +gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval) +{ + while (1) + { + switch (state->state) + { + case WAITOPERAND: + if (*(state->buf) == '!') + { (state->buf)++; - *val = (int4)'!'; + *val = (int4) '!'; return OPR; - } else if ( *(state->buf) == '(' ) { + } + else if (*(state->buf) == '(') + { state->count++; (state->buf)++; return OPEN; - } else if ( *(state->buf) != ' ' ) { + } + else if (*(state->buf) != ' ') + { state->valstate.prsbuf = state->buf; state->state = WAITOPERATOR; - if ( gettoken_txtidx( &(state->valstate) ) ) { + if (gettoken_txtidx(&(state->valstate))) + { *strval = state->valstate.word; *lenval = state->valstate.curpos - state->valstate.word; state->buf = state->valstate.prsbuf; return VAL; - } else + } + else elog(ERROR, "No operand"); } break; case WAITOPERATOR: - if ( *(state->buf) == '&' || *(state->buf) == '|' ) { + if (*(state->buf) == '&' || *(state->buf) == '|') + { state->state = WAITOPERAND; *val = (int4) *(state->buf); - (state->buf)++; + (state->buf)++; return OPR; - } else if ( *(state->buf) == ')' ) { + } + else if (*(state->buf) == ')') + { (state->buf)++; state->count--; - return ( state->count <0 ) ? ERR : CLOSE; - } else if ( *(state->buf) == '\0' ) { - return ( state->count ) ? ERR : END; - } else if ( *(state->buf) != ' ' ) + return (state->count < 0) ? ERR : CLOSE; + } + else if (*(state->buf) == '\0') + return (state->count) ? ERR : END; + else if (*(state->buf) != ' ') return ERR; break; - default: + default: return ERR; break; - } - (state->buf)++; + } + (state->buf)++; } return END; } @@ -145,16 +164,18 @@ gettoken_query( QPRS_STATE* state, int4* val, int4* lenval, char** strval ) { * push new one in polish notation reverse view */ static void -pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) { - NODE *tmp = (NODE*)palloc(sizeof(NODE)); - tmp->type=type; - tmp->val =val; - if ( distance>0xffff ) - elog(ERROR,"Value is too big"); - if ( lenval > 0xffff ) - elog(ERROR,"Operand is too long"); - tmp->distance=distance; - tmp->length=lenval; +pushquery(QPRS_STATE * state, int4 type, int4 val, int4 distance, int4 lenval) +{ + NODE *tmp = (NODE *) palloc(sizeof(NODE)); + + tmp->type = type; + tmp->val = val; + if (distance > 0xffff) + elog(ERROR, "Value is too big"); + if (lenval > 0xffff) + elog(ERROR, "Operand is too long"); + tmp->distance = distance; + tmp->length = lenval; tmp->next = state->str; state->str = tmp; state->num++; @@ -164,20 +185,23 @@ pushquery( QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval) { * This function is used for query_txt parsing */ static void -pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) { - if ( lenval>0xffff ) +pushval_asis(QPRS_STATE * state, int type, char *strval, int lenval) +{ + if (lenval > 0xffff) elog(ERROR, "Word is too long"); - pushquery(state, type, crc32_sz( (uint8*)strval, lenval ), - state->curop - state->op, lenval); + pushquery(state, type, crc32_sz((uint8 *) strval, lenval), + state->curop - state->op, lenval); + + while (state->curop - state->op + lenval + 1 >= state->lenop) + { + int4 tmp = state->curop - state->op; - while ( state->curop - state->op + lenval + 1 >= state->lenop ) { - int4 tmp = state->curop - state->op; state->lenop *= 2; - state->op = (char*)repalloc( (void*)state->op, state->lenop ); + state->op = (char *) repalloc((void *) state->op, state->lenop); state->curop = state->op + tmp; } - memcpy( (void*)state->curop, (void*)strval, lenval ); + memcpy((void *) state->curop, (void *) strval, lenval); state->curop += lenval; *(state->curop) = '\0'; state->curop++; @@ -189,28 +213,34 @@ pushval_asis(QPRS_STATE *state, int type, char* strval, int lenval) { * This function is used for mquery_txt parsing */ static void -pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) { - int4 type, lenlemm; - int4 count = 0; - char *lemm; - - start_parse_str( strval, lenval ); - while( (type=tsearch_yylex()) != 0 ) { - if ( tokenlen>0xffff ) { +pushval_morph(QPRS_STATE * state, int typeval, char *strval, int lenval) +{ + int4 type, + lenlemm; + int4 count = 0; + char *lemm; + + start_parse_str(strval, lenval); + while ((type = tsearch_yylex()) != 0) + { + if (tokenlen > 0xffff) + { end_parse(); elog(ERROR, "Word is too long"); } lenlemm = tokenlen; - lemm = lemmatize( token, &lenlemm, type ); - if ( lemm ) { - pushval_asis(state,VAL,lemm,lenlemm); - if ( lemm != token ) pfree(lemm); - } else { - pushval_asis(state,VALTRUE,0,0); + lemm = lemmatize(token, &lenlemm, type); + if (lemm) + { + pushval_asis(state, VAL, lemm, lenlemm); + if (lemm != token) + pfree(lemm); } - if ( count ) - pushquery(state, OPR, (int4)'&', 0,0); - count++; + else + pushval_asis(state, VALTRUE, 0, 0); + if (count) + pushquery(state, OPR, (int4) '&', 0, 0); + count++; } end_parse(); } @@ -219,100 +249,114 @@ pushval_morph(QPRS_STATE *state, int typeval, char* strval, int lenval) { /* * make polish notaion of query */ -static int4 -makepol(QPRS_STATE *state, void (*pushval)(QPRS_STATE*,int,char*,int)) { - int4 val,type; - int4 lenval; - char *strval; - int4 stack[STACKDEPTH]; - int4 lenstack=0; - - while( (type=gettoken_query(state, &val, &lenval, &strval))!=END ) { - switch(type) { +static int4 +makepol(QPRS_STATE * state, void (*pushval) (QPRS_STATE *, int, char *, int)) +{ + int4 val, + type; + int4 lenval; + char *strval; + int4 stack[STACKDEPTH]; + int4 lenstack = 0; + + while ((type = gettoken_query(state, &val, &lenval, &strval)) != END) + { + switch (type) + { case VAL: - (*pushval)(state, VAL, strval, lenval); - while ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || - stack[ lenstack-1 ] == (int4)'!') ) { + (*pushval) (state, VAL, strval, lenval); + while (lenstack && (stack[lenstack - 1] == (int4) '&' || + stack[lenstack - 1] == (int4) '!')) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); } break; case OPR: - if ( lenstack && val == (int4) '|' ) { - pushquery(state, OPR, val, 0,0); - } else { - if ( lenstack == STACKDEPTH ) - elog(ERROR,"Stack too short"); - stack[ lenstack ] = val; + if (lenstack && val == (int4) '|') + pushquery(state, OPR, val, 0, 0); + else + { + if (lenstack == STACKDEPTH) + elog(ERROR, "Stack too short"); + stack[lenstack] = val; lenstack++; } break; case OPEN: - if ( makepol( state, pushval ) == ERR ) return ERR; - if ( lenstack && (stack[ lenstack-1 ] == (int4)'&' || - stack[ lenstack-1 ] == (int4)'!') ) { + if (makepol(state, pushval) == ERR) + return ERR; + if (lenstack && (stack[lenstack - 1] == (int4) '&' || + stack[lenstack - 1] == (int4) '!')) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); } break; case CLOSE: - while ( lenstack ) { + while (lenstack) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ], 0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); }; return END; break; case ERR: default: - elog(ERROR,"Syntax error"); + elog(ERROR, "Syntax error"); return ERR; - + } } - while (lenstack) { + while (lenstack) + { lenstack--; - pushquery(state, OPR, stack[ lenstack ],0,0); + pushquery(state, OPR, stack[lenstack], 0, 0); }; return END; } -typedef struct { - WordEntry *arrb; - WordEntry *arre; - char *values; - char *operand; -} CHKVAL; +typedef struct +{ + WordEntry *arrb; + WordEntry *arre; + char *values; + char *operand; +} CHKVAL; /* * compare 2 string values */ static int4 -ValCompare( CHKVAL *chkval, WordEntry *ptr, ITEM *item ) { - if ( ptr->len == item->length ) +ValCompare(CHKVAL * chkval, WordEntry * ptr, ITEM * item) +{ + if (ptr->len == item->length) return strncmp( - &(chkval->values[ ptr->pos ]), - &(chkval->operand[item->distance]), - item->length ); + &(chkval->values[ptr->pos]), + &(chkval->operand[item->distance]), + item->length); - return ( ptr->len > item->length ) ? 1 : -1; -} + return (ptr->len > item->length) ? 1 : -1; +} /* * is there value 'val' in array or not ? */ static bool -checkcondition_str( void *checkval, ITEM* val ) { - WordEntry *StopLow = ((CHKVAL*)checkval)->arrb; - WordEntry *StopHigh = ((CHKVAL*)checkval)->arre; - WordEntry *StopMiddle; - int difference; - - /* Loop invariant: StopLow <= val < StopHigh */ - - while (StopLow < StopHigh) { +checkcondition_str(void *checkval, ITEM * val) +{ + WordEntry *StopLow = ((CHKVAL *) checkval)->arrb; + WordEntry *StopHigh = ((CHKVAL *) checkval)->arre; + WordEntry *StopMiddle; + int difference; + + /* Loop invariant: StopLow <= val < StopHigh */ + + while (StopLow < StopHigh) + { StopMiddle = StopLow + (StopHigh - StopLow) / 2; - difference = ValCompare((CHKVAL*)checkval, StopMiddle, val); - if (difference == 0) + difference = ValCompare((CHKVAL *) checkval, StopMiddle, val); + if (difference == 0) return (true); else if (difference < 0) StopLow = StopMiddle + 1; @@ -320,27 +364,33 @@ checkcondition_str( void *checkval, ITEM* val ) { StopHigh = StopMiddle; } - return (false); + return (false); } /* * check for boolean condition */ bool -execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *checkval, ITEM *val )) { - if ( curitem->type == VAL ) { - return (*chkcond)( checkval, curitem ); - } else if ( curitem->val == (int4)'!' ) { - return ( calcnot ) ? - ( ( execute(curitem + 1, checkval, calcnot, chkcond) ) ? false : true ) - : true; - } else if ( curitem->val == (int4)'&' ) { - if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) +execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val)) +{ + if (curitem->type == VAL) + return (*chkcond) (checkval, curitem); + else if (curitem->val == (int4) '!') + { + return (calcnot) ? + ((execute(curitem + 1, checkval, calcnot, chkcond)) ? false : true) + : true; + } + else if (curitem->val == (int4) '&') + { + if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) return execute(curitem + 1, checkval, calcnot, chkcond); else return false; - } else { /* |-operator */ - if ( execute(curitem + curitem->left, checkval, calcnot, chkcond) ) + } + else + { /* |-operator */ + if (execute(curitem + curitem->left, checkval, calcnot, chkcond)) return true; else return execute(curitem + 1, checkval, calcnot, chkcond); @@ -349,69 +399,79 @@ execute( ITEM* curitem, void *checkval, bool calcnot, bool (*chkcond)(void *chec } /* - * boolean operations + * boolean operations */ Datum -rexecqtxt(PG_FUNCTION_ARGS) { +rexecqtxt(PG_FUNCTION_ARGS) +{ return DirectFunctionCall2( - execqtxt, - PG_GETARG_DATUM(1), - PG_GETARG_DATUM(0) + execqtxt, + PG_GETARG_DATUM(1), + PG_GETARG_DATUM(0) ); } Datum -execqtxt(PG_FUNCTION_ARGS) { - txtidx *val = ( txtidx * )DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - QUERYTYPE *query = ( QUERYTYPE * )DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); - CHKVAL chkval; - bool result; - - if ( ! val->size ) { - PG_FREE_IF_COPY(val,0); - PG_FREE_IF_COPY(query,1); - PG_RETURN_BOOL( false ); +execqtxt(PG_FUNCTION_ARGS) +{ + txtidx *val = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); + CHKVAL chkval; + bool result; + + if (!val->size) + { + PG_FREE_IF_COPY(val, 0); + PG_FREE_IF_COPY(query, 1); + PG_RETURN_BOOL(false); } chkval.arrb = ARRPTR(val); chkval.arre = chkval.arrb + val->size; chkval.values = STRPTR(val); - chkval.operand = GETOPERAND( query ); - result = execute( - GETQUERY(query), - &chkval, - true, - checkcondition_str - ); - - PG_FREE_IF_COPY(val,0); - PG_FREE_IF_COPY(query,1); - PG_RETURN_BOOL( result ); + chkval.operand = GETOPERAND(query); + result = execute( + GETQUERY(query), + &chkval, + true, + checkcondition_str + ); + + PG_FREE_IF_COPY(val, 0); + PG_FREE_IF_COPY(query, 1); + PG_RETURN_BOOL(result); } /* * find left operand in polish notation view */ static void -findoprnd( ITEM *ptr, int4 *pos ) { +findoprnd(ITEM * ptr, int4 *pos) +{ #ifdef BS_DEBUG - elog(NOTICE, ( ptr[*pos].type == OPR ) ? - "%d %c" : "%d %d ", *pos, ptr[*pos].val ); + elog(NOTICE, (ptr[*pos].type == OPR) ? + "%d %c" : "%d %d ", *pos, ptr[*pos].val); #endif - if ( ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE ) { + if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE) + { ptr[*pos].left = 0; (*pos)++; - } else if ( ptr[*pos].val == (int4)'!' ) { + } + else if (ptr[*pos].val == (int4) '!') + { ptr[*pos].left = 1; (*pos)++; - findoprnd( ptr, pos ); - } else { - ITEM *curitem = &ptr[*pos]; - int4 tmp = *pos; + findoprnd(ptr, pos); + } + else + { + ITEM *curitem = &ptr[*pos]; + int4 tmp = *pos; + (*pos)++; - findoprnd(ptr,pos); + findoprnd(ptr, pos); curitem->left = *pos - tmp; - findoprnd(ptr,pos); + findoprnd(ptr, pos); } } @@ -419,16 +479,20 @@ findoprnd( ITEM *ptr, int4 *pos ) { /* * input */ -static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) ) { - QPRS_STATE state; - int4 i; - QUERYTYPE *query; - int4 commonlen; - ITEM *ptr; - NODE *tmp; - int4 pos=0; +static QUERYTYPE * +queryin(char *buf, void (*pushval) (QPRS_STATE *, int, char *, int)) +{ + QPRS_STATE state; + int4 i; + QUERYTYPE *query; + int4 commonlen; + ITEM *ptr; + NODE *tmp; + int4 pos = 0; + #ifdef BS_DEBUG - char pbuf[16384],*cur; + char pbuf[16384], + *cur; #endif /* init state */ @@ -436,62 +500,64 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) state.state = WAITOPERAND; state.count = 0; state.num = 0; - state.str=NULL; + state.str = NULL; /* init value parser's state */ state.valstate.oprisdelim = true; - state.valstate.len=32; - state.valstate.word = (char*)palloc( state.valstate.len ); + state.valstate.len = 32; + state.valstate.word = (char *) palloc(state.valstate.len); /* init list of operand */ - state.sumlen=0; - state.lenop=64; - state.curop = state.op = (char*)palloc( state.lenop ); + state.sumlen = 0; + state.lenop = 64; + state.curop = state.op = (char *) palloc(state.lenop); *(state.curop) = '\0'; - + /* parse query & make polish notation (postfix, but in reverse order) */ - makepol( &state, pushval ); - pfree( state.valstate.word ); - if (!state.num) - elog( ERROR,"Empty query"); + makepol(&state, pushval); + pfree(state.valstate.word); + if (!state.num) + elog(ERROR, "Empty query"); /* make finish struct */ commonlen = COMPUTESIZE(state.num, state.sumlen); - query = (QUERYTYPE*) palloc( commonlen ); + query = (QUERYTYPE *) palloc(commonlen); query->len = commonlen; query->size = state.num; ptr = GETQUERY(query); /* set item in polish notation */ - for(i=0; i<state.num; i++ ) { - ptr[i].type = state.str->type; + for (i = 0; i < state.num; i++) + { + ptr[i].type = state.str->type; ptr[i].val = state.str->val; - ptr[i].distance = state.str->distance; + ptr[i].distance = state.str->distance; ptr[i].length = state.str->length; tmp = state.str->next; - pfree( state.str ); + pfree(state.str); state.str = tmp; } - /* set user friendly-operand view */ - memcpy( (void*)GETOPERAND(query), (void*)state.op, state.sumlen ); - pfree( state.op ); + /* set user friendly-operand view */ + memcpy((void *) GETOPERAND(query), (void *) state.op, state.sumlen); + pfree(state.op); - /* set left operand's position for every operator */ + /* set left operand's position for every operator */ pos = 0; - findoprnd( ptr, &pos ); + findoprnd(ptr, &pos); #ifdef BS_DEBUG cur = pbuf; *cur = '\0'; - for( i=0;i<query->size;i++ ) { - if ( ptr[i].type == OPR ) + for (i = 0; i < query->size; i++) + { + if (ptr[i].type == OPR) sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); - else - sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); - cur = strchr(cur,'\0'); + else + sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance); + cur = strchr(cur, '\0'); } - elog(NOTICE,"POR: %s", pbuf); + elog(NOTICE, "POR: %s", pbuf); #endif return query; @@ -501,59 +567,66 @@ static QUERYTYPE *queryin(char *buf, void (*pushval)(QPRS_STATE*,int,char*,int) * in without morphology */ Datum -qtxt_in(PG_FUNCTION_ARGS) { - PG_RETURN_POINTER( queryin((char*)PG_GETARG_POINTER(0),pushval_asis) ); +qtxt_in(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(queryin((char *) PG_GETARG_POINTER(0), pushval_asis)); } /* * in with morphology */ Datum -mqtxt_in(PG_FUNCTION_ARGS) { - QUERYTYPE *query; - ITEM* res; - int4 len; -#ifdef BS_DEBUG - ITEM *ptr; - int4 i; - char pbuf[16384],*cur; +mqtxt_in(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query; + ITEM *res; + int4 len; + +#ifdef BS_DEBUG + ITEM *ptr; + int4 i; + char pbuf[16384], + *cur; #endif initmorph(); - query = queryin((char*)PG_GETARG_POINTER(0),pushval_morph); - res = clean_fakeval( GETQUERY(query), &len ); - if ( ! res ) { + query = queryin((char *) PG_GETARG_POINTER(0), pushval_morph); + res = clean_fakeval(GETQUERY(query), &len); + if (!res) + { pfree(query); PG_RETURN_NULL(); } - memcpy( (void*)GETQUERY(query), (void*)res, len*sizeof(ITEM) ); + memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(ITEM)); #ifdef BS_DEBUG cur = pbuf; *cur = '\0'; ptr = GETQUERY(query); - for( i=0;i<len;i++ ) { - if ( ptr[i].type == OPR ) + for (i = 0; i < len; i++) + { + if (ptr[i].type == OPR) sprintf(cur, "%c(%d) ", ptr[i].val, ptr[i].left); - else - sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance ); - cur = strchr(cur,'\0'); + else + sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance); + cur = strchr(cur, '\0'); } - elog(NOTICE,"POR: %s", pbuf); + elog(NOTICE, "POR: %s", pbuf); #endif pfree(res); - PG_RETURN_POINTER( query ); + PG_RETURN_POINTER(query); } /* * out function */ -typedef struct { - ITEM *curpol; - char *buf; - char *cur; - char *op; - int4 buflen; -} INFIX; +typedef struct +{ + ITEM *curpol; + char *buf; + char *cur; + char *op; + int4 buflen; +} INFIX; #define RESIZEBUF(inf,addsize) \ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \ @@ -565,98 +638,117 @@ while( ( inf->cur - inf->buf ) + addsize + 1 >= inf->buflen ) \ } /* - * recursive walk on tree and print it in + * recursive walk on tree and print it in * infix (human-readable) view */ static void -infix(INFIX *in, bool first) { - if ( in->curpol->type == VAL ) { - char *op = in->op + in->curpol->distance; - RESIZEBUF(in, in->curpol->length*2 + 2); - *(in->cur) = '\''; in->cur++; - while( *op ) { - if ( *op == '\'' ) { - *(in->cur) = '\\'; in->cur++; +infix(INFIX * in, bool first) +{ + if (in->curpol->type == VAL) + { + char *op = in->op + in->curpol->distance; + + RESIZEBUF(in, in->curpol->length * 2 + 2); + *(in->cur) = '\''; + in->cur++; + while (*op) + { + if (*op == '\'') + { + *(in->cur) = '\\'; + in->cur++; } *(in->cur) = *op; - op++; in->cur++; - } - *(in->cur) = '\''; in->cur++; + op++; + in->cur++; + } + *(in->cur) = '\''; + in->cur++; *(in->cur) = '\0'; in->curpol++; - } else if ( in->curpol->val == (int4)'!' ) { - bool isopr = false; + } + else if (in->curpol->val == (int4) '!') + { + bool isopr = false; + RESIZEBUF(in, 1); *(in->cur) = '!'; in->cur++; *(in->cur) = '\0'; in->curpol++; - if ( in->curpol->type == OPR ) { + if (in->curpol->type == OPR) + { isopr = true; RESIZEBUF(in, 2); sprintf(in->cur, "( "); - in->cur = strchr( in->cur, '\0' ); - } - infix( in, isopr ); - if ( isopr ) { + in->cur = strchr(in->cur, '\0'); + } + infix(in, isopr); + if (isopr) + { RESIZEBUF(in, 2); sprintf(in->cur, " )"); - in->cur = strchr( in->cur, '\0' ); - } - } else { - int4 op = in->curpol->val; - INFIX nrm; - + in->cur = strchr(in->cur, '\0'); + } + } + else + { + int4 op = in->curpol->val; + INFIX nrm; + in->curpol++; - if ( op == (int4)'|' && ! first) { + if (op == (int4) '|' && !first) + { RESIZEBUF(in, 2); sprintf(in->cur, "( "); - in->cur = strchr( in->cur, '\0' ); + in->cur = strchr(in->cur, '\0'); } nrm.curpol = in->curpol; nrm.op = in->op; nrm.buflen = 16; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); - + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); + /* get right operand */ - infix( &nrm, false ); - + infix(&nrm, false); + /* get & print left operand */ in->curpol = nrm.curpol; - infix( in, false ); + infix(in, false); - /* print operator & right operand*/ - RESIZEBUF(in, 3 + (nrm.cur - nrm.buf) ); + /* print operator & right operand */ + RESIZEBUF(in, 3 + (nrm.cur - nrm.buf)); sprintf(in->cur, " %c %s", op, nrm.buf); - in->cur = strchr( in->cur, '\0' ); - pfree( nrm.buf ); + in->cur = strchr(in->cur, '\0'); + pfree(nrm.buf); - if ( op == (int4)'|' && ! first) { + if (op == (int4) '|' && !first) + { RESIZEBUF(in, 2); sprintf(in->cur, " )"); - in->cur = strchr( in->cur, '\0' ); + in->cur = strchr(in->cur, '\0'); } } } Datum -qtxt_out(PG_FUNCTION_ARGS) { - QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - INFIX nrm; +qtxt_out(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + INFIX nrm; - if ( query->size == 0 ) - elog(ERROR,"Empty"); + if (query->size == 0) + elog(ERROR, "Empty"); nrm.curpol = GETQUERY(query); nrm.buflen = 32; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); *(nrm.cur) = '\0'; nrm.op = GETOPERAND(query); - infix( &nrm, true ); - - PG_FREE_IF_COPY(query,0); - PG_RETURN_POINTER( nrm.buf ); + infix(&nrm, true); + + PG_FREE_IF_COPY(query, 0); + PG_RETURN_POINTER(nrm.buf); } /* @@ -664,38 +756,42 @@ qtxt_out(PG_FUNCTION_ARGS) { * which will be executed in non-leaf pages in index */ Datum -querytree(PG_FUNCTION_ARGS) { - QUERYTYPE *query = (QUERYTYPE*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - INFIX nrm; - text *res; - ITEM *q; - int4 len; +querytree(PG_FUNCTION_ARGS) +{ + QUERYTYPE *query = (QUERYTYPE *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + INFIX nrm; + text *res; + ITEM *q; + int4 len; - if ( query->size == 0 ) - elog(ERROR,"Empty"); + if (query->size == 0) + elog(ERROR, "Empty"); q = clean_NOT(GETQUERY(query), &len); - if ( ! q ) { - res = (text*) palloc( 1 + VARHDRSZ ); + if (!q) + { + res = (text *) palloc(1 + VARHDRSZ); VARATT_SIZEP(res) = 1 + VARHDRSZ; - *((char*)VARDATA(res)) = 'T'; - } else { + *((char *) VARDATA(res)) = 'T'; + } + else + { nrm.curpol = q; nrm.buflen = 32; - nrm.cur = nrm.buf = (char*)palloc( sizeof(char) * nrm.buflen ); + nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen); *(nrm.cur) = '\0'; nrm.op = GETOPERAND(query); - infix( &nrm, true ); + infix(&nrm, true); - res = (text*) palloc( nrm.cur-nrm.buf + VARHDRSZ ); - VARATT_SIZEP(res) = nrm.cur-nrm.buf + VARHDRSZ; - strncpy( VARDATA(res), nrm.buf, nrm.cur-nrm.buf ); + res = (text *) palloc(nrm.cur - nrm.buf + VARHDRSZ); + VARATT_SIZEP(res) = nrm.cur - nrm.buf + VARHDRSZ; + strncpy(VARDATA(res), nrm.buf, nrm.cur - nrm.buf); pfree(q); } - PG_FREE_IF_COPY(query,0); + PG_FREE_IF_COPY(query, 0); - PG_RETURN_POINTER( res ); + PG_RETURN_POINTER(res); } diff --git a/contrib/tsearch/query.h b/contrib/tsearch/query.h index 96117e78c8..a5f8d7deb8 100644 --- a/contrib/tsearch/query.h +++ b/contrib/tsearch/query.h @@ -9,41 +9,43 @@ * item in polish notation with back link * to left operand */ -typedef struct ITEM { - int2 type; - int2 left; - int4 val; +typedef struct ITEM +{ + int2 type; + int2 left; + int4 val; /* user-friendly value */ - uint16 distance; - uint16 length; -} ITEM; + uint16 distance; + uint16 length; +} ITEM; /* *Storage: * (len)(size)(array of ITEM)(array of operand in user-friendly form) */ -typedef struct { - int4 len; - int4 size; - char data[1]; -} QUERYTYPE; +typedef struct +{ + int4 len; + int4 size; + char data[1]; +} QUERYTYPE; #define HDRSIZEQT ( 2*sizeof(int4) ) #define COMPUTESIZE(size,lenofoperand) ( HDRSIZEQT + size * sizeof(ITEM) + lenofoperand ) #define GETQUERY(x) (ITEM*)( (char*)(x)+HDRSIZEQT ) -#define GETOPERAND(x) ( (char*)GETQUERY(x) + ((QUERYTYPE*)x)->size * sizeof(ITEM) ) +#define GETOPERAND(x) ( (char*)GETQUERY(x) + ((QUERYTYPE*)x)->size * sizeof(ITEM) ) #define ISOPERATOR(x) ( (x)=='!' || (x)=='&' || (x)=='|' || (x)=='(' || (x)==')' ) -#define END 0 -#define ERR 1 -#define VAL 2 -#define OPR 3 -#define OPEN 4 -#define CLOSE 5 -#define VALTRUE 6 /* for stop words */ -#define VALFALSE 7 +#define END 0 +#define ERR 1 +#define VAL 2 +#define OPR 3 +#define OPEN 4 +#define CLOSE 5 +#define VALTRUE 6 /* for stop words */ +#define VALFALSE 7 -bool execute( ITEM* curitem, void *checkval, - bool calcnot, bool (*chkcond)(void *checkval, ITEM* val )); +bool execute(ITEM * curitem, void *checkval, + bool calcnot, bool (*chkcond) (void *checkval, ITEM * val)); #endif diff --git a/contrib/tsearch/rewrite.c b/contrib/tsearch/rewrite.c index 590b15e7ca..9ad7a0a86a 100644 --- a/contrib/tsearch/rewrite.c +++ b/contrib/tsearch/rewrite.c @@ -19,52 +19,63 @@ #include "query.h" #include "rewrite.h" -typedef struct NODE { - struct NODE *left; +typedef struct NODE +{ + struct NODE *left; struct NODE *right; - ITEM* valnode; -} NODE; + ITEM *valnode; +} NODE; /* * make query tree from plain view of query */ -static NODE* -maketree(ITEM *in) { - NODE *node = (NODE*)palloc(sizeof(NODE)); +static NODE * +maketree(ITEM * in) +{ + NODE *node = (NODE *) palloc(sizeof(NODE)); + node->valnode = in; node->right = node->left = NULL; - if ( in->type == OPR ) { - node->right = maketree( in + 1 ); - if ( in->val != (int4)'!' ) - node->left = maketree( in + in->left ); + if (in->type == OPR) + { + node->right = maketree(in + 1); + if (in->val != (int4) '!') + node->left = maketree(in + in->left); } return node; } -typedef struct { - ITEM* ptr; - int4 len; - int4 cur; -} PLAINTREE; +typedef struct +{ + ITEM *ptr; + int4 len; + int4 cur; +} PLAINTREE; static void -plainnode(PLAINTREE *state, NODE* node) { - if ( state->cur == state->len ) { +plainnode(PLAINTREE * state, NODE * node) +{ + if (state->cur == state->len) + { state->len *= 2; - state->ptr=(ITEM*)repalloc( (void*)state->ptr, state->len*sizeof(ITEM) ); + state->ptr = (ITEM *) repalloc((void *) state->ptr, state->len * sizeof(ITEM)); } - memcpy( (void*)&(state->ptr[state->cur]), (void*)node->valnode, sizeof(ITEM) ); - if ( node->valnode->type == VAL ) { + memcpy((void *) &(state->ptr[state->cur]), (void *) node->valnode, sizeof(ITEM)); + if (node->valnode->type == VAL) state->cur++; - } else if ( node->valnode->val == (int4)'!' ) { - state->ptr[state->cur].left=1; + else if (node->valnode->val == (int4) '!') + { + state->ptr[state->cur].left = 1; state->cur++; plainnode(state, node->right); - } else { - int4 cur = state->cur; + } + else + { + int4 cur = state->cur; + state->cur++; plainnode(state, node->right); - state->ptr[cur].left = state->cur - cur; + state->ptr[cur].left = state->cur - cur; plainnode(state, node->left); } pfree(node); @@ -73,75 +84,96 @@ plainnode(PLAINTREE *state, NODE* node) { /* * make plain view of tree from 'normal' view of tree */ -static ITEM* -plaintree(NODE *root, int4 *len) { +static ITEM * +plaintree(NODE * root, int4 *len) +{ PLAINTREE pl; - pl.cur=0; - pl.len=16; - if ( root && (root->valnode->type == VAL || root->valnode->type == OPR) ) { - pl.ptr = (ITEM*)palloc( pl.len*sizeof(ITEM) ); + + pl.cur = 0; + pl.len = 16; + if (root && (root->valnode->type == VAL || root->valnode->type == OPR)) + { + pl.ptr = (ITEM *) palloc(pl.len * sizeof(ITEM)); plainnode(&pl, root); - } else { - pl.ptr = NULL; } + else + pl.ptr = NULL; *len = pl.cur; - return pl.ptr; + return pl.ptr; } static void -freetree(NODE *node) { - if ( !node ) return; - if ( node->left ) freetree(node->left); - if ( node->right ) freetree(node->right); - pfree( node ); +freetree(NODE * node) +{ + if (!node) + return; + if (node->left) + freetree(node->left); + if (node->right) + freetree(node->right); + pfree(node); } /* * clean tree for ! operator. - * It's usefull for debug, but in + * It's usefull for debug, but in * other case, such view is used with search in index. * Operator ! always return TRUE */ -static NODE* -clean_NOT_intree( NODE* node ) { - if ( node->valnode->type == VAL ) +static NODE * +clean_NOT_intree(NODE * node) +{ + if (node->valnode->type == VAL) return node; - if ( node->valnode->val == (int4)'!' ) { + if (node->valnode->val == (int4) '!') + { freetree(node); return NULL; } /* operator & or | */ - if ( node->valnode->val == (int4)'|' ) { - if ( (node->left=clean_NOT_intree(node->left)) == NULL || - (node->right=clean_NOT_intree(node->right)) == NULL ) { + if (node->valnode->val == (int4) '|') + { + if ((node->left = clean_NOT_intree(node->left)) == NULL || + (node->right = clean_NOT_intree(node->right)) == NULL) + { freetree(node); return NULL; } - } else { - NODE *res = node; - node->left=clean_NOT_intree(node->left); - node->right=clean_NOT_intree(node->right); - if ( node->left == NULL && node->right == NULL ) { + } + else + { + NODE *res = node; + + node->left = clean_NOT_intree(node->left); + node->right = clean_NOT_intree(node->right); + if (node->left == NULL && node->right == NULL) + { pfree(node); res = NULL; - } else if ( node->left == NULL ) { + } + else if (node->left == NULL) + { res = node->right; pfree(node); - } else if ( node->right == NULL ) { + } + else if (node->right == NULL) + { res = node->left; pfree(node); - } + } return res; } - return node; + return node; } -ITEM* -clean_NOT(ITEM* ptr, int4 *len) { - NODE *root = maketree( ptr ); - return plaintree(clean_NOT_intree(root), len); +ITEM * +clean_NOT(ITEM * ptr, int4 *len) +{ + NODE *root = maketree(ptr); + + return plaintree(clean_NOT_intree(root), len); } #define V_UNKNOWN 0 @@ -149,86 +181,112 @@ clean_NOT(ITEM* ptr, int4 *len) { #define V_FALSE 2 /* - * Clean query tree from values which is always in + * Clean query tree from values which is always in * text (stopword) - */ -static NODE* -clean_fakeval_intree( NODE* node, char *result ) { - char lresult = V_UNKNOWN, rresult = V_UNKNOWN; - if ( node->valnode->type == VAL ) + */ +static NODE * +clean_fakeval_intree(NODE * node, char *result) +{ + char lresult = V_UNKNOWN, + rresult = V_UNKNOWN; + + if (node->valnode->type == VAL) return node; - else if ( node->valnode->type == VALTRUE ) { - pfree( node ); + else if (node->valnode->type == VALTRUE) + { + pfree(node); *result = V_TRUE; return NULL; - } - + } + - if ( node->valnode->val == (int4)'!' ) { - node->right = clean_fakeval_intree( node->right, &rresult ); - if ( ! node->right ) { - *result = ( rresult == V_TRUE ) ? V_FALSE : V_TRUE; + if (node->valnode->val == (int4) '!') + { + node->right = clean_fakeval_intree(node->right, &rresult); + if (!node->right) + { + *result = (rresult == V_TRUE) ? V_FALSE : V_TRUE; freetree(node); return NULL; } - } else if ( node->valnode->val == (int4)'|' ) { - NODE *res = node; - node->left =clean_fakeval_intree(node->left, &lresult); - node->right=clean_fakeval_intree(node->right,&rresult); - if ( lresult == V_TRUE || rresult == V_TRUE ) { + } + else if (node->valnode->val == (int4) '|') + { + NODE *res = node; + + node->left = clean_fakeval_intree(node->left, &lresult); + node->right = clean_fakeval_intree(node->right, &rresult); + if (lresult == V_TRUE || rresult == V_TRUE) + { freetree(node); - *result=V_TRUE; + *result = V_TRUE; return NULL; - } else if ( lresult == V_FALSE && rresult == V_FALSE ) { + } + else if (lresult == V_FALSE && rresult == V_FALSE) + { freetree(node); - *result=V_FALSE; + *result = V_FALSE; return NULL; - } else if ( lresult == V_FALSE ) { + } + else if (lresult == V_FALSE) + { res = node->right; pfree(node); - } else if ( rresult == V_FALSE ) { + } + else if (rresult == V_FALSE) + { res = node->left; pfree(node); } - return res; - } else { - NODE *res = node; - node->left =clean_fakeval_intree(node->left, &lresult); - node->right=clean_fakeval_intree(node->right,&rresult); - if ( lresult == V_FALSE || rresult == V_FALSE ) { + return res; + } + else + { + NODE *res = node; + + node->left = clean_fakeval_intree(node->left, &lresult); + node->right = clean_fakeval_intree(node->right, &rresult); + if (lresult == V_FALSE || rresult == V_FALSE) + { freetree(node); - *result=V_FALSE; + *result = V_FALSE; return NULL; - } else if ( lresult == V_TRUE && rresult == V_TRUE ) { + } + else if (lresult == V_TRUE && rresult == V_TRUE) + { freetree(node); - *result=V_TRUE; + *result = V_TRUE; return NULL; - } else if ( lresult == V_TRUE ) { + } + else if (lresult == V_TRUE) + { res = node->right; pfree(node); - } else if ( rresult == V_TRUE ) { + } + else if (rresult == V_TRUE) + { res = node->left; pfree(node); } - return res; + return res; } - return node; + return node; } -ITEM* -clean_fakeval(ITEM* ptr, int4 *len) { - NODE *root = maketree( ptr ); - char result = V_UNKNOWN; - NODE *resroot; - +ITEM * +clean_fakeval(ITEM * ptr, int4 *len) +{ + NODE *root = maketree(ptr); + char result = V_UNKNOWN; + NODE *resroot; + resroot = clean_fakeval_intree(root, &result); - if ( result != V_UNKNOWN ) { - elog(ERROR,"Your query contained only stopword(s), ignored"); + if (result != V_UNKNOWN) + { + elog(ERROR, "Your query contained only stopword(s), ignored"); *len = 0; return NULL; } - - return plaintree(resroot, len); -} - + return plaintree(resroot, len); +} diff --git a/contrib/tsearch/rewrite.h b/contrib/tsearch/rewrite.h index 863ff9b672..c53e1c6dac 100644 --- a/contrib/tsearch/rewrite.h +++ b/contrib/tsearch/rewrite.h @@ -1,7 +1,6 @@ #ifndef __REWRITE_H__ #define __REWRITE_H__ -ITEM* clean_NOT(ITEM* ptr, int4 *len); -ITEM* clean_fakeval(ITEM* ptr, int4 *len); - +ITEM *clean_NOT(ITEM * ptr, int4 *len); +ITEM *clean_fakeval(ITEM * ptr, int4 *len); #endif diff --git a/contrib/tsearch/txtidx.c b/contrib/tsearch/txtidx.c index e1abd54d3b..6e1fe0edae 100644 --- a/contrib/tsearch/txtidx.c +++ b/contrib/tsearch/txtidx.c @@ -17,9 +17,9 @@ #include "utils/pg_locale.h" -#include <ctype.h> /* tolower */ -#include "txtidx.h" -#include "query.h" +#include <ctype.h> /* tolower */ +#include "txtidx.h" +#include "query.h" #include "deflex.h" #include "parser.h" @@ -27,51 +27,58 @@ #include "morph.h" PG_FUNCTION_INFO_V1(txtidx_in); -Datum txtidx_in(PG_FUNCTION_ARGS); +Datum txtidx_in(PG_FUNCTION_ARGS); + PG_FUNCTION_INFO_V1(txtidx_out); -Datum txtidx_out(PG_FUNCTION_ARGS); +Datum txtidx_out(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(txt2txtidx); -Datum txt2txtidx(PG_FUNCTION_ARGS); +Datum txt2txtidx(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(tsearch); -Datum tsearch(PG_FUNCTION_ARGS); +Datum tsearch(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(txtidxsize); -Datum txtidxsize(PG_FUNCTION_ARGS); +Datum txtidxsize(PG_FUNCTION_ARGS); /* * in/out text index type */ static char *BufferStr; static int -compareentry( const void * a, const void * b ) { - if ( ((WordEntry*)a)->len == ((WordEntry*)b)->len ) { - return strncmp( - &BufferStr[((WordEntry*)a)->pos], - &BufferStr[((WordEntry*)b)->pos], - ((WordEntry*)b)->len ); +compareentry(const void *a, const void *b) +{ + if (((WordEntry *) a)->len == ((WordEntry *) b)->len) + { + return strncmp( + &BufferStr[((WordEntry *) a)->pos], + &BufferStr[((WordEntry *) b)->pos], + ((WordEntry *) b)->len); } - return ( ((WordEntry*)a)->len > ((WordEntry*)b)->len ) ? 1 : -1; + return (((WordEntry *) a)->len > ((WordEntry *) b)->len) ? 1 : -1; } static int -uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) { - WordEntry *ptr, *res; +uniqueentry(WordEntry * a, int4 l, char *buf, int4 *outbuflen) +{ + WordEntry *ptr, + *res; res = a; *outbuflen = res->len; - if ( l == 1 ) + if (l == 1) return l; - ptr = a+1; + ptr = a + 1; BufferStr = buf; - qsort((void*)a, l, sizeof(int4), compareentry ); + qsort((void *) a, l, sizeof(int4), compareentry); *outbuflen = res->len; - while (ptr - a < l) { - if ( ! (ptr->len == res->len && - strncmp(&buf[ ptr->pos ], &buf[ res->pos ],res->len) == 0 ) ) { + while (ptr - a < l) + { + if (!(ptr->len == res->len && + strncmp(&buf[ptr->pos], &buf[res->pos], res->len) == 0)) + { res++; res->len = ptr->len; res->pos = ptr->pos; @@ -81,10 +88,10 @@ uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) { ptr++; } return res + 1 - a; -} +} #define WAITWORD 1 -#define WAITENDWORD 2 +#define WAITENDWORD 2 #define WAITNEXTCHAR 3 #define WAITENDCMPLX 4 @@ -92,81 +99,105 @@ uniqueentry( WordEntry* a, int4 l, char *buf, int4 *outbuflen ) { do { \ if ( state->curpos - state->word == state->len ) \ { \ - int4 clen = state->curpos - state->word; \ - state->len *= 2; \ - state->word = (char*)repalloc( (void*)state->word, state->len ); \ - state->curpos = state->word + clen; \ - } \ + int4 clen = state->curpos - state->word; \ + state->len *= 2; \ + state->word = (char*)repalloc( (void*)state->word, state->len ); \ + state->curpos = state->word + clen; \ + } \ } while (0) int4 -gettoken_txtidx( TI_IN_STATE *state ) { - int4 oldstate = 0; +gettoken_txtidx(TI_IN_STATE * state) +{ + int4 oldstate = 0; + state->curpos = state->word; state->state = WAITWORD; - while( 1 ) { - if ( state->state == WAITWORD ) { - if ( *(state->prsbuf) == '\0' ) { + while (1) + { + if (state->state == WAITWORD) + { + if (*(state->prsbuf) == '\0') return 0; - } else if ( *(state->prsbuf) == '\'' ) { - state->state = WAITENDCMPLX; - } else if ( *(state->prsbuf) == '\\' ) { + else if (*(state->prsbuf) == '\'') + state->state = WAITENDCMPLX; + else if (*(state->prsbuf) == '\\') + { state->state = WAITNEXTCHAR; oldstate = WAITENDWORD; - } else if ( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) { + } + else if (state->oprisdelim && ISOPERATOR(*(state->prsbuf))) elog(ERROR, "Syntax error"); - } else if ( *(state->prsbuf) != ' ' ) { + else if (*(state->prsbuf) != ' ') + { *(state->curpos) = *(state->prsbuf); state->curpos++; state->state = WAITENDWORD; } - } else if ( state->state == WAITNEXTCHAR ) { - if ( *(state->prsbuf) == '\0' ) { - elog(ERROR,"There is no escaped character"); - } else { + } + else if (state->state == WAITNEXTCHAR) + { + if (*(state->prsbuf) == '\0') + elog(ERROR, "There is no escaped character"); + else + { RESIZEPRSBUF; *(state->curpos) = *(state->prsbuf); state->curpos++; state->state = oldstate; } - } else if ( state->state == WAITENDWORD ) { - if ( *(state->prsbuf) == '\\' ) { + } + else if (state->state == WAITENDWORD) + { + if (*(state->prsbuf) == '\\') + { state->state = WAITNEXTCHAR; oldstate = WAITENDWORD; - } else if ( *(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' || - ( state->oprisdelim && ISOPERATOR( *(state->prsbuf) ) ) ) { + } + else if (*(state->prsbuf) == ' ' || *(state->prsbuf) == '\0' || + (state->oprisdelim && ISOPERATOR(*(state->prsbuf)))) + { RESIZEPRSBUF; - if ( state->curpos == state->word ) + if (state->curpos == state->word) elog(ERROR, "Syntax error"); *(state->curpos) = '\0'; return 1; - } else { + } + else + { RESIZEPRSBUF; *(state->curpos) = *(state->prsbuf); state->curpos++; } - } else if ( state->state == WAITENDCMPLX ) { - if ( *(state->prsbuf) == '\'' ) { + } + else if (state->state == WAITENDCMPLX) + { + if (*(state->prsbuf) == '\'') + { RESIZEPRSBUF; *(state->curpos) = '\0'; - if ( state->curpos == state->word ) + if (state->curpos == state->word) elog(ERROR, "Syntax error"); state->prsbuf++; return 1; - } else if ( *(state->prsbuf) == '\\' ) { + } + else if (*(state->prsbuf) == '\\') + { state->state = WAITNEXTCHAR; oldstate = WAITENDCMPLX; - } else if ( *(state->prsbuf) == '\0' ) { - elog(ERROR,"Syntax error"); - } else { + } + else if (*(state->prsbuf) == '\0') + elog(ERROR, "Syntax error"); + else + { RESIZEPRSBUF; *(state->curpos) = *(state->prsbuf); state->curpos++; } - } else { + } + else elog(ERROR, "Inner bug :("); - } state->prsbuf++; } @@ -174,92 +205,111 @@ gettoken_txtidx( TI_IN_STATE *state ) { } Datum -txtidx_in(PG_FUNCTION_ARGS) { - char *buf = (char*)PG_GETARG_POINTER(0); +txtidx_in(PG_FUNCTION_ARGS) +{ + char *buf = (char *) PG_GETARG_POINTER(0); TI_IN_STATE state; - WordEntry *arr; - int4 len=0, totallen = 64; - txtidx *in; - char *tmpbuf, *cur; - int4 i,buflen = 256; + WordEntry *arr; + int4 len = 0, + totallen = 64; + txtidx *in; + char *tmpbuf, + *cur; + int4 i, + buflen = 256; state.prsbuf = buf; - state.len=32; - state.word = (char*)palloc( state.len ); + state.len = 32; + state.word = (char *) palloc(state.len); state.oprisdelim = false; - arr = (WordEntry*)palloc( sizeof(WordEntry) * totallen ); - cur = tmpbuf = (char*)palloc( buflen ); - while( gettoken_txtidx( &state ) ) { - if ( len == totallen ) { + arr = (WordEntry *) palloc(sizeof(WordEntry) * totallen); + cur = tmpbuf = (char *) palloc(buflen); + while (gettoken_txtidx(&state)) + { + if (len == totallen) + { totallen *= 2; - arr = (WordEntry*)repalloc( (void*)arr, sizeof(int4)*totallen ); + arr = (WordEntry *) repalloc((void *) arr, sizeof(int4) * totallen); } - while ( cur-tmpbuf + state.curpos - state.word >= buflen ) { - int4 dist = cur-tmpbuf; + while (cur - tmpbuf + state.curpos - state.word >= buflen) + { + int4 dist = cur - tmpbuf; + buflen *= 2; - tmpbuf = (char*)repalloc( (void*)tmpbuf, buflen ); - cur = tmpbuf+dist; + tmpbuf = (char *) repalloc((void *) tmpbuf, buflen); + cur = tmpbuf + dist; } - if ( state.curpos - state.word > 0xffff ) - elog(ERROR,"Word is too long"); + if (state.curpos - state.word > 0xffff) + elog(ERROR, "Word is too long"); arr[len].len = state.curpos - state.word; - if ( cur - tmpbuf > 0xffff ) - elog(ERROR,"Too long value"); + if (cur - tmpbuf > 0xffff) + elog(ERROR, "Too long value"); arr[len].pos = cur - tmpbuf; - memcpy( (void*)cur, (void*)state.word, arr[len].len ); + memcpy((void *) cur, (void *) state.word, arr[len].len); cur += arr[len].len; len++; } pfree(state.word); - if ( !len ) - elog(ERROR,"Void value"); + if (!len) + elog(ERROR, "Void value"); - len = uniqueentry( arr, len, tmpbuf, &buflen ); - totallen = CALCDATASIZE( len, buflen ); - in = (txtidx*)palloc( totallen ); + len = uniqueentry(arr, len, tmpbuf, &buflen); + totallen = CALCDATASIZE(len, buflen); + in = (txtidx *) palloc(totallen); in->len = totallen; in->size = len; cur = STRPTR(in); - for(i=0;i<len;i++) { - memcpy( (void*)cur, (void*)&tmpbuf[ arr[i].pos ], arr[i].len ); + for (i = 0; i < len; i++) + { + memcpy((void *) cur, (void *) &tmpbuf[arr[i].pos], arr[i].len); arr[i].pos = cur - STRPTR(in); cur += arr[i].len; } pfree(tmpbuf); - memcpy( (void*)ARRPTR(in), (void*)arr, sizeof(int4)*len ); - pfree( arr ); - PG_RETURN_POINTER( in ); + memcpy((void *) ARRPTR(in), (void *) arr, sizeof(int4) * len); + pfree(arr); + PG_RETURN_POINTER(in); } Datum -txtidxsize(PG_FUNCTION_ARGS) { - txtidx *in=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - int4 ret = in->size; - PG_FREE_IF_COPY(in,0); - PG_RETURN_INT32( ret ); +txtidxsize(PG_FUNCTION_ARGS) +{ + txtidx *in = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + int4 ret = in->size; + + PG_FREE_IF_COPY(in, 0); + PG_RETURN_INT32(ret); } Datum -txtidx_out(PG_FUNCTION_ARGS) { - txtidx *out=(txtidx*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - char *outbuf; - int4 i,j,lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size*2 /* '' */ + out->size - 1 /* space */; - WordEntry *ptr = ARRPTR(out); - char *curin, *curout; - - curout = outbuf = (char*) palloc( lenbuf ); - for(i=0;i<out->size;i++) { +txtidx_out(PG_FUNCTION_ARGS) +{ + txtidx *out = (txtidx *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + char *outbuf; + int4 i, + j, + lenbuf = STRSIZE(out) + 1 /* \0 */ + out->size * 2 /* '' */ + out->size - 1 /* space */ ; + WordEntry *ptr = ARRPTR(out); + char *curin, + *curout; + + curout = outbuf = (char *) palloc(lenbuf); + for (i = 0; i < out->size; i++) + { curin = STRPTR(out) + ptr->pos; - if ( i!= 0 ) + if (i != 0) *curout++ = ' '; *curout++ = '\''; j = ptr->len; - while( j-- ) { - if ( *curin == '\'' ) { - int4 pos = curout - outbuf; - outbuf = (char*)repalloc((void*)outbuf, ++lenbuf ); + while (j--) + { + if (*curin == '\'') + { + int4 pos = curout - outbuf; + + outbuf = (char *) repalloc((void *) outbuf, ++lenbuf); curout = outbuf + pos; *curout++ = '\\'; } @@ -268,171 +318,198 @@ txtidx_out(PG_FUNCTION_ARGS) { *curout++ = '\''; ptr++; } - outbuf[ lenbuf-1 ] = '\0'; - PG_FREE_IF_COPY(out,0); - PG_RETURN_POINTER( outbuf ); + outbuf[lenbuf - 1] = '\0'; + PG_FREE_IF_COPY(out, 0); + PG_RETURN_POINTER(outbuf); } -typedef struct { - uint16 len; - char* word; -} WORD; +typedef struct +{ + uint16 len; + char *word; +} WORD; -typedef struct { - WORD *words; - int4 lenwords; - int4 curwords; -} PRSTEXT; +typedef struct +{ + WORD *words; + int4 lenwords; + int4 curwords; +} PRSTEXT; /* * Parse text to lexems */ static void -parsetext( PRSTEXT *prs, char *buf, int4 buflen ) { - int type,lenlemm; - char *ptr,*ptrw; - char *lemm; - - start_parse_str( buf, buflen ); - while( (type=tsearch_yylex()) != 0 ) { - if ( prs->curwords == prs->lenwords ) { +parsetext(PRSTEXT * prs, char *buf, int4 buflen) +{ + int type, + lenlemm; + char *ptr, + *ptrw; + char *lemm; + + start_parse_str(buf, buflen); + while ((type = tsearch_yylex()) != 0) + { + if (prs->curwords == prs->lenwords) + { prs->lenwords *= 2; - prs->words = (WORD*)repalloc( (void*)prs->words, prs->lenwords * sizeof(WORD) ); + prs->words = (WORD *) repalloc((void *) prs->words, prs->lenwords * sizeof(WORD)); } - if ( tokenlen>0xffff ) { + if (tokenlen > 0xffff) + { end_parse(); elog(ERROR, "Word is too long"); } lenlemm = tokenlen; - lemm = lemmatize( token, &lenlemm, type ); - - if ( ! lemm ) + lemm = lemmatize(token, &lenlemm, type); + + if (!lemm) continue; - if ( lemm != token ) { - prs->words[ prs->curwords ].len = lenlemm; - prs->words[ prs->curwords ].word = lemm; - } else { - prs->words[ prs->curwords ].len = lenlemm; - ptrw = prs->words[ prs->curwords ].word = (char*)palloc( lenlemm ); + if (lemm != token) + { + prs->words[prs->curwords].len = lenlemm; + prs->words[prs->curwords].word = lemm; + } + else + { + prs->words[prs->curwords].len = lenlemm; + ptrw = prs->words[prs->curwords].word = (char *) palloc(lenlemm); ptr = token; - while( ptr-token < lenlemm ) { - *ptrw = tolower( (unsigned char) *ptr ); - ptr++; ptrw++; + while (ptr - token < lenlemm) + { + *ptrw = tolower((unsigned char) *ptr); + ptr++; + ptrw++; } } - prs->curwords++; + prs->curwords++; } end_parse(); } static int -compareWORD( const void * a, const void * b ) { - if ( ((WORD*)a)->len == ((WORD*)b)->len ) - return strncmp( - ((WORD*)a)->word, - ((WORD*)b)->word, - ((WORD*)b)->len ); - return ( ((WORD*)a)->len > ((WORD*)b)->len ) ? 1 : -1; +compareWORD(const void *a, const void *b) +{ + if (((WORD *) a)->len == ((WORD *) b)->len) + return strncmp( + ((WORD *) a)->word, + ((WORD *) b)->word, + ((WORD *) b)->len); + return (((WORD *) a)->len > ((WORD *) b)->len) ? 1 : -1; } static int -uniqueWORD( WORD* a, int4 l ) { - WORD *ptr, *res; +uniqueWORD(WORD * a, int4 l) +{ + WORD *ptr, + *res; - if ( l == 1 ) + if (l == 1) return l; res = a; ptr = a + 1; - qsort((void*)a, l, sizeof(WORD), compareWORD ); + qsort((void *) a, l, sizeof(WORD), compareWORD); - while (ptr - a < l) { - if ( ! (ptr->len == res->len && - strncmp(ptr->word, res->word ,res->len) == 0 ) ) { + while (ptr - a < l) + { + if (!(ptr->len == res->len && + strncmp(ptr->word, res->word, res->len) == 0)) + { res++; - res->len = ptr->len; + res->len = ptr->len; res->word = ptr->word; - } else { - pfree(ptr->word); } + else + pfree(ptr->word); ptr++; } return res + 1 - a; -} +} /* * make value of txtidx */ static txtidx * -makevalue( PRSTEXT *prs ) { - int4 i, lenstr=0, totallen; - txtidx *in; - WordEntry *ptr; - char *str,*cur; - - prs->curwords = uniqueWORD( prs->words, prs->curwords ); - for(i=0;i<prs->curwords;i++) +makevalue(PRSTEXT * prs) +{ + int4 i, + lenstr = 0, + totallen; + txtidx *in; + WordEntry *ptr; + char *str, + *cur; + + prs->curwords = uniqueWORD(prs->words, prs->curwords); + for (i = 0; i < prs->curwords; i++) lenstr += prs->words[i].len; - totallen = CALCDATASIZE( prs->curwords, lenstr ); - in = (txtidx*)palloc( totallen ); + totallen = CALCDATASIZE(prs->curwords, lenstr); + in = (txtidx *) palloc(totallen); in->len = totallen; in->size = prs->curwords; ptr = ARRPTR(in); cur = str = STRPTR(in); - for(i=0;i<prs->curwords;i++) { + for (i = 0; i < prs->curwords; i++) + { ptr->len = prs->words[i].len; - if ( cur-str > 0xffff ) - elog(ERROR,"Value is too big"); - ptr->pos = cur-str; + if (cur - str > 0xffff) + elog(ERROR, "Value is too big"); + ptr->pos = cur - str; ptr++; - memcpy( (void*)cur, (void*)prs->words[i].word, prs->words[i].len ); + memcpy((void *) cur, (void *) prs->words[i].word, prs->words[i].len); pfree(prs->words[i].word); - cur += prs->words[i].len; + cur += prs->words[i].len; } pfree(prs->words); return in; } Datum -txt2txtidx(PG_FUNCTION_ARGS) { - text *in = (text*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); - PRSTEXT prs; - txtidx *out = NULL; - - prs.lenwords = 32; - prs.curwords = 0; - prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords); +txt2txtidx(PG_FUNCTION_ARGS) +{ + text *in = (text *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0))); + PRSTEXT prs; + txtidx *out = NULL; + + prs.lenwords = 32; + prs.curwords = 0; + prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords); initmorph(); - parsetext( &prs, VARDATA(in), VARSIZE(in) - VARHDRSZ ); - PG_FREE_IF_COPY(in,0); - - if ( prs.curwords ) { - out = makevalue( &prs ); - PG_RETURN_POINTER( out ); + parsetext(&prs, VARDATA(in), VARSIZE(in) - VARHDRSZ); + PG_FREE_IF_COPY(in, 0); + + if (prs.curwords) + { + out = makevalue(&prs); + PG_RETURN_POINTER(out); } pfree(prs.words); PG_RETURN_NULL(); -} +} /* * Trigger */ Datum -tsearch(PG_FUNCTION_ARGS) { +tsearch(PG_FUNCTION_ARGS) +{ TriggerData *trigdata; Trigger *trigger; - Relation rel; - HeapTuple rettuple = NULL; - int numidxattr,i; - PRSTEXT prs; - Datum datum = (Datum)0; + Relation rel; + HeapTuple rettuple = NULL; + int numidxattr, + i; + PRSTEXT prs; + Datum datum = (Datum) 0; if (!CALLED_AS_TRIGGER(fcinfo)) @@ -448,63 +525,69 @@ tsearch(PG_FUNCTION_ARGS) { rettuple = trigdata->tg_trigtuple; else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event)) rettuple = trigdata->tg_newtuple; - else + else elog(ERROR, "TSearch: Unknown event"); trigger = trigdata->tg_trigger; rel = trigdata->tg_relation; - if ( trigger->tgnargs < 2 ) - elog(ERROR,"TSearch: format tsearch(txtidx_field, text_field1,...)"); + if (trigger->tgnargs < 2) + elog(ERROR, "TSearch: format tsearch(txtidx_field, text_field1,...)"); numidxattr = SPI_fnumber(rel->rd_att, trigger->tgargs[0]); - if ( numidxattr < 0 ) - elog(ERROR,"TSearch: Can not find txtidx_field"); + if (numidxattr < 0) + elog(ERROR, "TSearch: Can not find txtidx_field"); - prs.lenwords = 32; - prs.curwords = 0; - prs.words = (WORD*)palloc(sizeof(WORD)*prs.lenwords); + prs.lenwords = 32; + prs.curwords = 0; + prs.words = (WORD *) palloc(sizeof(WORD) * prs.lenwords); initmorph(); - /* find all words in indexable column */ - for(i=1; i<trigger->tgnargs; i++) { - int4 numattr; - text *txt_toasted, *txt; - bool isnull; - Oid oidtype; + /* find all words in indexable column */ + for (i = 1; i < trigger->tgnargs; i++) + { + int4 numattr; + text *txt_toasted, + *txt; + bool isnull; + Oid oidtype; numattr = SPI_fnumber(rel->rd_att, trigger->tgargs[i]); oidtype = SPI_gettypeid(rel->rd_att, numattr); - if ( numattr<0 || ( ! ( oidtype==TEXTOID || oidtype==VARCHAROID ) ) ) { + if (numattr < 0 || (!(oidtype == TEXTOID || oidtype == VARCHAROID))) + { elog(NOTICE, "TSearch: can not find field '%s'", trigger->tgargs[i]); continue; } - txt_toasted = (text*)DatumGetPointer( SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull ) ); - if ( isnull ) + txt_toasted = (text *) DatumGetPointer(SPI_getbinval(rettuple, rel->rd_att, numattr, &isnull)); + if (isnull) continue; - txt = (text*)DatumGetPointer( PG_DETOAST_DATUM( PointerGetDatum ( txt_toasted ) ) ); + txt = (text *) DatumGetPointer(PG_DETOAST_DATUM(PointerGetDatum(txt_toasted))); - parsetext( &prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ ); - if ( txt != txt_toasted ) + parsetext(&prs, VARDATA(txt), VARSIZE(txt) - VARHDRSZ); + if (txt != txt_toasted) pfree(txt); } /* make txtidx value */ - if (prs.curwords) { - datum = PointerGetDatum( makevalue( &prs ) ); - rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr, - &datum, NULL ); + if (prs.curwords) + { + datum = PointerGetDatum(makevalue(&prs)); + rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr, + &datum, NULL); pfree(DatumGetPointer(datum)); - } else { - char nulls = 'n'; - pfree( prs.words ); - rettuple = SPI_modifytuple( rel, rettuple, 1, &numidxattr, - &datum, &nulls ); } - + else + { + char nulls = 'n'; + + pfree(prs.words); + rettuple = SPI_modifytuple(rel, rettuple, 1, &numidxattr, + &datum, &nulls); + } + if (rettuple == NULL) elog(ERROR, "TSearch: %d returned by SPI_modifytuple", SPI_result); - return PointerGetDatum( rettuple ); + return PointerGetDatum(rettuple); } - diff --git a/contrib/tsearch/txtidx.h b/contrib/tsearch/txtidx.h index 9a586ce518..d33bdf9d6d 100644 --- a/contrib/tsearch/txtidx.h +++ b/contrib/tsearch/txtidx.h @@ -14,33 +14,34 @@ #include "utils/builtins.h" #include "storage/bufpage.h" -typedef struct { - uint16 len; - uint16 pos; -} WordEntry; - -typedef struct { - int4 len; - int4 size; - char data[1]; -} txtidx; - -#define DATAHDRSIZE (sizeof(int4)*2) -#define CALCDATASIZE(x, lenstr) ( x * sizeof(WordEntry) + DATAHDRSIZE + lenstr ) -#define ARRPTR(x) ( (WordEntry*) ( (char*)x + DATAHDRSIZE ) ) -#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) ) -#define STRSIZE(x) ( ((txtidx*)x)->len - DATAHDRSIZE - ( sizeof(WordEntry) * ((txtidx*)x)->size ) ) - -typedef struct { - char *prsbuf; - char *word; - char *curpos; - int4 len; - int4 state; - bool oprisdelim; -} TI_IN_STATE; - -int4 gettoken_txtidx( TI_IN_STATE *state ); - +typedef struct +{ + uint16 len; + uint16 pos; +} WordEntry; + +typedef struct +{ + int4 len; + int4 size; + char data[1]; +} txtidx; + +#define DATAHDRSIZE (sizeof(int4)*2) +#define CALCDATASIZE(x, lenstr) ( x * sizeof(WordEntry) + DATAHDRSIZE + lenstr ) +#define ARRPTR(x) ( (WordEntry*) ( (char*)x + DATAHDRSIZE ) ) +#define STRPTR(x) ( (char*)x + DATAHDRSIZE + ( sizeof(WordEntry) * ((txtidx*)x)->size ) ) +#define STRSIZE(x) ( ((txtidx*)x)->len - DATAHDRSIZE - ( sizeof(WordEntry) * ((txtidx*)x)->size ) ) + +typedef struct +{ + char *prsbuf; + char *word; + char *curpos; + int4 len; + int4 state; + bool oprisdelim; +} TI_IN_STATE; + +int4 gettoken_txtidx(TI_IN_STATE * state); #endif - diff --git a/contrib/userlock/user_locks.h b/contrib/userlock/user_locks.h index 82ecb3b9ea..526e864661 100644 --- a/contrib/userlock/user_locks.h +++ b/contrib/userlock/user_locks.h @@ -8,7 +8,6 @@ int user_write_unlock(unsigned int id1, unsigned int id2); int user_write_lock_oid(Oid oid); int user_write_unlock_oid(Oid oid); int user_unlock_all(void); - #endif /* diff --git a/contrib/xml/pgxml.c b/contrib/xml/pgxml.c index 4728903157..3939250e25 100644 --- a/contrib/xml/pgxml.c +++ b/contrib/xml/pgxml.c @@ -14,32 +14,39 @@ XML_Memory_Handling_Suite mhs; /* passthrough functions (palloc is a macro) */ -static void *pgxml_palloc(size_t size) +static void * +pgxml_palloc(size_t size) { - return palloc(size); + return palloc(size); } -static void *pgxml_repalloc(void *ptr, size_t size) +static void * +pgxml_repalloc(void *ptr, size_t size) { - return repalloc(ptr,size); + return repalloc(ptr, size); } -static void pgxml_pfree(void *ptr) +static void +pgxml_pfree(void *ptr) { - return pfree(ptr); + return pfree(ptr); } -static void pgxml_mhs_init() +static void +pgxml_mhs_init() { - mhs.malloc_fcn = pgxml_palloc; - mhs.realloc_fcn = pgxml_repalloc; - mhs.free_fcn = pgxml_pfree; + mhs.malloc_fcn = pgxml_palloc; + mhs.realloc_fcn = pgxml_repalloc; + mhs.free_fcn = pgxml_pfree; } -static void pgxml_handler_init() +static void +pgxml_handler_init() { - /* This code should set up the relevant handlers from user-supplied - settings. Quite how these settings are made is another matter :) */ + /* + * This code should set up the relevant handlers from user-supplied + * settings. Quite how these settings are made is another matter :) + */ } /* Returns true if document is well-formed */ @@ -49,31 +56,35 @@ PG_FUNCTION_INFO_V1(pgxml_parse); Datum pgxml_parse(PG_FUNCTION_ARGS) { - /* called as pgxml_parse(document) */ - XML_Parser p; - text *t = PG_GETARG_TEXT_P(0); /*document buffer */ - int32 docsize = VARSIZE(t) - VARHDRSZ; - - pgxml_mhs_init(); - - pgxml_handler_init(); - - p = XML_ParserCreate_MM(NULL,&mhs,NULL); - if (! p) { - elog(ERROR, "pgxml: Could not create expat parser"); - PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */ - } - - if (! XML_Parse(p, (char *)VARDATA(t) , docsize, 1)) { - /* elog(NOTICE, "Parse error at line %d:%s", - XML_GetCurrentLineNumber(p), - XML_ErrorString(XML_GetErrorCode(p))); */ - XML_ParserFree(p); - PG_RETURN_BOOL(false); - } - - XML_ParserFree(p); - PG_RETURN_BOOL(true); + /* called as pgxml_parse(document) */ + XML_Parser p; + text *t = PG_GETARG_TEXT_P(0); /* document buffer */ + int32 docsize = VARSIZE(t) - VARHDRSZ; + + pgxml_mhs_init(); + + pgxml_handler_init(); + + p = XML_ParserCreate_MM(NULL, &mhs, NULL); + if (!p) + { + elog(ERROR, "pgxml: Could not create expat parser"); + PG_RETURN_NULL(); /* seems appropriate if we couldn't parse */ + } + + if (!XML_Parse(p, (char *) VARDATA(t), docsize, 1)) + { + /* + * elog(NOTICE, "Parse error at line %d:%s", + * XML_GetCurrentLineNumber(p), + * XML_ErrorString(XML_GetErrorCode(p))); + */ + XML_ParserFree(p); + PG_RETURN_BOOL(false); + } + + XML_ParserFree(p); + PG_RETURN_BOOL(true); } /* XPath handling functions */ @@ -81,83 +92,88 @@ pgxml_parse(PG_FUNCTION_ARGS) /* XPath support here is for a very skeletal kind of XPath! It was easy to program though... */ -/* This first is the core function that builds a result set. The +/* This first is the core function that builds a result set. The actual functions called by the user manipulate that result set in various ways. */ -static XPath_Results *build_xpath_results(text *doc, text *pathstr) +static XPath_Results * +build_xpath_results(text *doc, text *pathstr) { - XPath_Results *xpr; - char *res; - pgxml_udata *udata; - XML_Parser p; - int32 docsize; + XPath_Results *xpr; + char *res; + pgxml_udata *udata; + XML_Parser p; + int32 docsize; - xpr = (XPath_Results *) palloc((sizeof(XPath_Results))); - memset((void *)xpr, 0, sizeof(XPath_Results)); - xpr->rescount=0; + xpr = (XPath_Results *) palloc((sizeof(XPath_Results))); + memset((void *) xpr, 0, sizeof(XPath_Results)); + xpr->rescount = 0; - docsize=VARSIZE(doc)-VARHDRSZ; + docsize = VARSIZE(doc) - VARHDRSZ; - /* res isn't going to be the real return type, it is just a buffer */ + /* res isn't going to be the real return type, it is just a buffer */ - res = (char *) palloc(docsize); - memset((void *)res, 0, docsize); + res = (char *) palloc(docsize); + memset((void *) res, 0, docsize); - xpr->resbuf = res; + xpr->resbuf = res; - udata = (pgxml_udata *) palloc((sizeof(pgxml_udata))); - memset((void *)udata,0,sizeof(pgxml_udata)); + udata = (pgxml_udata *) palloc((sizeof(pgxml_udata))); + memset((void *) udata, 0, sizeof(pgxml_udata)); - udata->currentpath[0]='\0'; - udata->textgrab=0; + udata->currentpath[0] = '\0'; + udata->textgrab = 0; - udata->path= (char *) palloc(VARSIZE(pathstr)); - memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr)-VARHDRSZ); + udata->path = (char *) palloc(VARSIZE(pathstr)); + memcpy(udata->path, VARDATA(pathstr), VARSIZE(pathstr) - VARHDRSZ); - udata->path[VARSIZE(pathstr)-VARHDRSZ]='\0'; + udata->path[VARSIZE(pathstr) - VARHDRSZ] = '\0'; - udata->resptr = res; - udata->reslen = 0; + udata->resptr = res; + udata->reslen = 0; - udata->xpres = xpr; + udata->xpres = xpr; - /* Now fire up the parser */ - pgxml_mhs_init(); + /* Now fire up the parser */ + pgxml_mhs_init(); - p = XML_ParserCreate_MM(NULL,&mhs,NULL); - if (! p) { - elog(ERROR, "pgxml: Could not create expat parser"); - pfree(xpr); - pfree(udata->path); - pfree(udata); - pfree(res); - return NULL; - } - XML_SetUserData(p, (void *)udata); - - /* Set the handlers */ - - XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler); - XML_SetCharacterDataHandler(p, pgxml_charhandler); - - if (! XML_Parse(p, (char *)VARDATA(doc) , docsize, 1)) { - /* elog(NOTICE, "Parse error at line %d:%s", - XML_GetCurrentLineNumber(p), - XML_ErrorString(XML_GetErrorCode(p))); */ - XML_ParserFree(p); - pfree(xpr); - pfree(udata->path); - pfree(udata); - - return NULL; - } + p = XML_ParserCreate_MM(NULL, &mhs, NULL); + if (!p) + { + elog(ERROR, "pgxml: Could not create expat parser"); + pfree(xpr); + pfree(udata->path); + pfree(udata); + pfree(res); + return NULL; + } + XML_SetUserData(p, (void *) udata); + + /* Set the handlers */ + + XML_SetElementHandler(p, pgxml_starthandler, pgxml_endhandler); + XML_SetCharacterDataHandler(p, pgxml_charhandler); + + if (!XML_Parse(p, (char *) VARDATA(doc), docsize, 1)) + { + /* + * elog(NOTICE, "Parse error at line %d:%s", + * XML_GetCurrentLineNumber(p), + * XML_ErrorString(XML_GetErrorCode(p))); + */ + XML_ParserFree(p); + pfree(xpr); + pfree(udata->path); + pfree(udata); + + return NULL; + } - pfree(udata->path); - pfree(udata); - XML_ParserFree(p); - return xpr; + pfree(udata->path); + pfree(udata); + XML_ParserFree(p); + return xpr; } @@ -166,145 +182,166 @@ PG_FUNCTION_INFO_V1(pgxml_xpath); Datum pgxml_xpath(PG_FUNCTION_ARGS) { - /* called as pgxml_xpath(document,pathstr, index) for the moment*/ + /* called as pgxml_xpath(document,pathstr, index) for the moment */ + + XPath_Results *xpresults; + text *restext; - XPath_Results *xpresults; - text *restext; + text *t = PG_GETARG_TEXT_P(0); /* document buffer */ + text *t2 = PG_GETARG_TEXT_P(1); + int32 ind = PG_GETARG_INT32(2) - 1; - text *t = PG_GETARG_TEXT_P(0); /*document buffer */ - text *t2= PG_GETARG_TEXT_P(1); - int32 ind = PG_GETARG_INT32(2) - 1; + xpresults = build_xpath_results(t, t2); - xpresults = build_xpath_results(t,t2); + /* + * This needs to be changed depending on the mechanism for returning + * our set of results. + */ - /* This needs to be changed depending on the mechanism for returning - our set of results. */ + if (xpresults == NULL) /* parse error (not WF or parser failure) */ + PG_RETURN_NULL(); - if (xpresults==NULL) /*parse error (not WF or parser failure) */ - { - PG_RETURN_NULL(); - } + if (ind >= (xpresults->rescount)) + PG_RETURN_NULL(); - if (ind >= (xpresults->rescount)) - { - PG_RETURN_NULL(); - } - - restext = (text *) palloc(xpresults->reslens[ind]+VARHDRSZ); - memcpy(VARDATA(restext),xpresults->results[ind],xpresults->reslens[ind]); + restext = (text *) palloc(xpresults->reslens[ind] + VARHDRSZ); + memcpy(VARDATA(restext), xpresults->results[ind], xpresults->reslens[ind]); - VARATT_SIZEP(restext) = xpresults->reslens[ind]+VARHDRSZ; + VARATT_SIZEP(restext) = xpresults->reslens[ind] + VARHDRSZ; - pfree(xpresults->resbuf); - pfree(xpresults); + pfree(xpresults->resbuf); + pfree(xpresults); - PG_RETURN_TEXT_P(restext); + PG_RETURN_TEXT_P(restext); } -static void pgxml_pathcompare(void *userData) +static void +pgxml_pathcompare(void *userData) { - char *matchpos; - - matchpos=strstr(UD->currentpath, UD->path); - - if (matchpos == NULL) { /* Should we have more logic here ? */ - if (UD->textgrab) { - UD->textgrab=0; - pgxml_finalisegrabbedtext(userData); - } - return; - } - /* OK, we have a match of some sort. Now we need to check that - our match is anchored to the *end* of the string AND - that it is immediately preceded by a '/'*/ - /* This test wouldn't work if strlen (UD->path) overran the length - of the currentpath, but that's not possible because we got a match! */ - - if ((matchpos + strlen(UD->path))[0]=='\0') - { - if ((UD->path)[0]=='/') { - if (matchpos == UD->currentpath) { - UD->textgrab=1; + char *matchpos; + + matchpos = strstr(UD->currentpath, UD->path); + + if (matchpos == NULL) + { /* Should we have more logic here ? */ + if (UD->textgrab) + { + UD->textgrab = 0; + pgxml_finalisegrabbedtext(userData); + } + return; } - } else { - if ((matchpos-1)[0]=='/') { - UD->textgrab=1; + + /* + * OK, we have a match of some sort. Now we need to check that our + * match is anchored to the *end* of the string AND that it is + * immediately preceded by a '/' + */ + + /* + * This test wouldn't work if strlen (UD->path) overran the length of + * the currentpath, but that's not possible because we got a match! + */ + + if ((matchpos + strlen(UD->path))[0] == '\0') + { + if ((UD->path)[0] == '/') + { + if (matchpos == UD->currentpath) + UD->textgrab = 1; + } + else + { + if ((matchpos - 1)[0] == '/') + UD->textgrab = 1; + } } - } - } } -static void pgxml_starthandler(void *userData, const XML_Char *name, - const XML_Char **atts) +static void +pgxml_starthandler(void *userData, const XML_Char * name, + const XML_Char ** atts) { - char sepstr[]="/"; - - if ((strlen(name)+strlen(UD->currentpath))>MAXPATHLENGTH-2) { - elog(NOTICE,"Path too long"); - } else { - strncat(UD->currentpath,sepstr,1); - strcat(UD->currentpath, name); - } - if (UD->textgrab) - { - /* Depending on user preference, should we "reconstitute" - the element into the result text? - */ - } else { - pgxml_pathcompare(userData); - } + char sepstr[] = "/"; + + if ((strlen(name) + strlen(UD->currentpath)) > MAXPATHLENGTH - 2) + elog(NOTICE, "Path too long"); + else + { + strncat(UD->currentpath, sepstr, 1); + strcat(UD->currentpath, name); + } + if (UD->textgrab) + { + /* + * Depending on user preference, should we "reconstitute" the + * element into the result text? + */ + } + else + pgxml_pathcompare(userData); } -static void pgxml_endhandler(void *userData, const XML_Char *name) +static void +pgxml_endhandler(void *userData, const XML_Char * name) { - /* Start by removing the current element off the end of the - currentpath */ - - char *sepptr; - - sepptr=strrchr(UD->currentpath,'/'); - if (sepptr==NULL) { - elog(ERROR,"There's a problem..."); - sepptr=UD->currentpath; - } - if (strcmp(name, sepptr+1) !=0) { - elog(NOTICE,"Wanted [%s], got [%s]",sepptr,name); - /* unmatched entry, so do nothing */ - } else { - sepptr[0]='\0'; /* Chop that element off the end */ - } - - if (UD->textgrab) { - pgxml_pathcompare(userData); - } + /* + * Start by removing the current element off the end of the + * currentpath + */ + + char *sepptr; + + sepptr = strrchr(UD->currentpath, '/'); + if (sepptr == NULL) + { + elog(ERROR, "There's a problem..."); + sepptr = UD->currentpath; + } + if (strcmp(name, sepptr + 1) != 0) + { + elog(NOTICE, "Wanted [%s], got [%s]", sepptr, name); + /* unmatched entry, so do nothing */ + } + else + { + sepptr[0] = '\0'; /* Chop that element off the end */ + } + + if (UD->textgrab) + pgxml_pathcompare(userData); } -static void pgxml_charhandler(void *userData, const XML_Char *s, int len) +static void +pgxml_charhandler(void *userData, const XML_Char * s, int len) { - if (UD->textgrab) { - if (len>0) { - memcpy(UD->resptr,s,len); - UD->resptr += len; - UD->reslen += len; - } - } + if (UD->textgrab) + { + if (len > 0) + { + memcpy(UD->resptr, s, len); + UD->resptr += len; + UD->reslen += len; + } + } } + /* Should I be using PG list types here? */ -static void pgxml_finalisegrabbedtext(void *userData) +static void +pgxml_finalisegrabbedtext(void *userData) { - /* In res/reslen, we have a single result. */ - UD->xpres->results[UD->xpres->rescount]= UD->resptr - UD->reslen; - UD->xpres->reslens[UD->xpres->rescount]= UD->reslen; - UD->reslen=0; - UD->xpres->rescount++; - - /* This effectively concatenates all the results together but we - do know where one ends and the next begins */ + /* In res/reslen, we have a single result. */ + UD->xpres->results[UD->xpres->rescount] = UD->resptr - UD->reslen; + UD->xpres->reslens[UD->xpres->rescount] = UD->reslen; + UD->reslen = 0; + UD->xpres->rescount++; + + /* + * This effectively concatenates all the results together but we do + * know where one ends and the next begins + */ } - - - diff --git a/contrib/xml/pgxml.h b/contrib/xml/pgxml.h index 848264c23d..605031861d 100644 --- a/contrib/xml/pgxml.h +++ b/contrib/xml/pgxml.h @@ -5,12 +5,12 @@ static void *pgxml_repalloc(void *ptr, size_t size); static void pgxml_pfree(void *ptr); static void pgxml_mhs_init(); static void pgxml_handler_init(); -Datum pgxml_parse(PG_FUNCTION_ARGS); -Datum pgxml_xpath(PG_FUNCTION_ARGS); -static void pgxml_starthandler(void *userData, const XML_Char *name, - const XML_Char **atts); -static void pgxml_endhandler(void *userData, const XML_Char *name); -static void pgxml_charhandler(void *userData, const XML_Char *s, int len); +Datum pgxml_parse(PG_FUNCTION_ARGS); +Datum pgxml_xpath(PG_FUNCTION_ARGS); +static void pgxml_starthandler(void *userData, const XML_Char * name, + const XML_Char ** atts); +static void pgxml_endhandler(void *userData, const XML_Char * name); +static void pgxml_charhandler(void *userData, const XML_Char * s, int len); static void pgxml_pathcompare(void *userData); static void pgxml_finalisegrabbedtext(void *userData); @@ -18,43 +18,25 @@ static void pgxml_finalisegrabbedtext(void *userData); #define MAXRESULTS 100 -typedef struct { - int rescount; - char *results[MAXRESULTS]; - int32 reslens[MAXRESULTS]; - char *resbuf; /* pointer to the result buffer for pfree */ -} XPath_Results; +typedef struct +{ + int rescount; + char *results[MAXRESULTS]; + int32 reslens[MAXRESULTS]; + char *resbuf; /* pointer to the result buffer for pfree */ +} XPath_Results; -typedef struct { - char currentpath[MAXPATHLENGTH]; - char *path; - int textgrab; - char *resptr; - int32 reslen; - XPath_Results *xpres; -} pgxml_udata; +typedef struct +{ + char currentpath[MAXPATHLENGTH]; + char *path; + int textgrab; + char *resptr; + int32 reslen; + XPath_Results *xpres; +} pgxml_udata; #define UD ((pgxml_udata *) userData) - - - - - - - - - - - - - - - - - - - - diff --git a/contrib/xml/pgxml_dom.c b/contrib/xml/pgxml_dom.c index b01368a52c..f2f9973b89 100644 --- a/contrib/xml/pgxml_dom.c +++ b/contrib/xml/pgxml_dom.c @@ -15,50 +15,57 @@ static void *pgxml_palloc(size_t size); static void *pgxml_repalloc(void *ptr, size_t size); static void pgxml_pfree(void *ptr); -static char *pgxml_pstrdup(const char* string); +static char *pgxml_pstrdup(const char *string); static void pgxml_parser_init(); -static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc, - xmlChar *toptagname, xmlChar *septagname, +static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset, xmlDocPtr doc, + xmlChar * toptagname, xmlChar * septagname, int format); static xmlChar *pgxml_texttoxmlchar(text *textstring); -Datum pgxml_parse(PG_FUNCTION_ARGS); -Datum pgxml_xpath(PG_FUNCTION_ARGS); +Datum pgxml_parse(PG_FUNCTION_ARGS); +Datum pgxml_xpath(PG_FUNCTION_ARGS); /* memory handling passthrough functions (e.g. palloc, pstrdup are currently macros, and the others might become so...) */ -static void *pgxml_palloc(size_t size) +static void * +pgxml_palloc(size_t size) { - return palloc(size); + return palloc(size); } -static void *pgxml_repalloc(void *ptr, size_t size) +static void * +pgxml_repalloc(void *ptr, size_t size) { - return repalloc(ptr,size); + return repalloc(ptr, size); } -static void pgxml_pfree(void *ptr) +static void +pgxml_pfree(void *ptr) { - return pfree(ptr); + return pfree(ptr); } -static char *pgxml_pstrdup(const char *string) +static char * +pgxml_pstrdup(const char *string) { - return pstrdup(string); + return pstrdup(string); } -static void pgxml_parser_init() +static void +pgxml_parser_init() { - /* This code should also set parser settings from user-supplied - info. Quite how these settings are made is another matter :) */ + /* + * This code should also set parser settings from user-supplied info. + * Quite how these settings are made is another matter :) + */ - xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup); - xmlInitParser(); + xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup); + xmlInitParser(); } @@ -70,86 +77,98 @@ PG_FUNCTION_INFO_V1(pgxml_parse); Datum pgxml_parse(PG_FUNCTION_ARGS) { - /* called as pgxml_parse(document) */ - xmlDocPtr doctree; - text *t = PG_GETARG_TEXT_P(0); /*document buffer */ - int32 docsize = VARSIZE(t) - VARHDRSZ; - - pgxml_parser_init(); - - doctree = xmlParseMemory((char *) VARDATA(t), docsize); - if (doctree == NULL) { - /* xmlCleanupParser(); */ - PG_RETURN_BOOL(false); /* i.e. not well-formed */ - } - /* xmlCleanupParser(); */ - xmlFreeDoc(doctree); - PG_RETURN_BOOL(true); + /* called as pgxml_parse(document) */ + xmlDocPtr doctree; + text *t = PG_GETARG_TEXT_P(0); /* document buffer */ + int32 docsize = VARSIZE(t) - VARHDRSZ; + + pgxml_parser_init(); + + doctree = xmlParseMemory((char *) VARDATA(t), docsize); + if (doctree == NULL) + { + /* xmlCleanupParser(); */ + PG_RETURN_BOOL(false); /* i.e. not well-formed */ + } + /* xmlCleanupParser(); */ + xmlFreeDoc(doctree); + PG_RETURN_BOOL(true); } -static xmlChar -*pgxmlNodeSetToText(xmlNodeSetPtr nodeset, - xmlDocPtr doc, - xmlChar *toptagname, - xmlChar *septagname, - int format) +static xmlChar +* +pgxmlNodeSetToText(xmlNodeSetPtr nodeset, + xmlDocPtr doc, + xmlChar * toptagname, + xmlChar * septagname, + int format) { - /* Function translates a nodeset into a text representation */ - /* iterates over each node in the set and calls xmlNodeDump to write - it to an xmlBuffer -from which an xmlChar * string is returned. */ - /* each representation is surrounded by <tagname> ... </tagname> */ - /* if format==0, add a newline between nodes?? */ - - xmlBufferPtr buf; - xmlChar *result; - int i; - - buf =xmlBufferCreate(); - - if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) { - xmlBufferWriteChar(buf,"<"); - xmlBufferWriteCHAR(buf,toptagname); - xmlBufferWriteChar(buf,">"); - } - if (nodeset != NULL) { - for (i=0; i < nodeset->nodeNr; i++) { - if ((septagname != NULL) && (xmlStrlen(septagname)>0)) { - xmlBufferWriteChar(buf,"<"); - xmlBufferWriteCHAR(buf,septagname); - xmlBufferWriteChar(buf,">"); - } - xmlNodeDump(buf, doc, nodeset->nodeTab[i],1,(format==2)); - - if ((septagname != NULL) && (xmlStrlen(septagname)>0)) { - xmlBufferWriteChar(buf,"</"); - xmlBufferWriteCHAR(buf,septagname); - xmlBufferWriteChar(buf,">"); - } - if (format) { - xmlBufferWriteChar(buf,"\n"); - } - } - } - - if ((toptagname != NULL) && (xmlStrlen(toptagname)>0)) { - xmlBufferWriteChar(buf,"</"); - xmlBufferWriteCHAR(buf,toptagname); - xmlBufferWriteChar(buf,">"); - } - result = xmlStrdup(buf->content); - xmlBufferFree(buf); - return result; + /* Function translates a nodeset into a text representation */ + + /* + * iterates over each node in the set and calls xmlNodeDump to write + * it to an xmlBuffer -from which an xmlChar * string is returned. + */ + /* each representation is surrounded by <tagname> ... </tagname> */ + /* if format==0, add a newline between nodes?? */ + + xmlBufferPtr buf; + xmlChar *result; + int i; + + buf = xmlBufferCreate(); + + if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0)) + { + xmlBufferWriteChar(buf, "<"); + xmlBufferWriteCHAR(buf, toptagname); + xmlBufferWriteChar(buf, ">"); + } + if (nodeset != NULL) + { + for (i = 0; i < nodeset->nodeNr; i++) + { + if ((septagname != NULL) && (xmlStrlen(septagname) > 0)) + { + xmlBufferWriteChar(buf, "<"); + xmlBufferWriteCHAR(buf, septagname); + xmlBufferWriteChar(buf, ">"); + } + xmlNodeDump(buf, doc, nodeset->nodeTab[i], 1, (format == 2)); + + if ((septagname != NULL) && (xmlStrlen(septagname) > 0)) + { + xmlBufferWriteChar(buf, "</"); + xmlBufferWriteCHAR(buf, septagname); + xmlBufferWriteChar(buf, ">"); + } + if (format) + xmlBufferWriteChar(buf, "\n"); + } + } + + if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0)) + { + xmlBufferWriteChar(buf, "</"); + xmlBufferWriteCHAR(buf, toptagname); + xmlBufferWriteChar(buf, ">"); + } + result = xmlStrdup(buf->content); + xmlBufferFree(buf); + return result; } -static xmlChar *pgxml_texttoxmlchar(text *textstring) { - xmlChar *res; - int32 txsize; - - txsize=VARSIZE(textstring)-VARHDRSZ; - res = (xmlChar *) palloc(txsize+1); - memcpy((char *)res, VARDATA(textstring), txsize); - res[txsize]='\0'; - return res; +static xmlChar * +pgxml_texttoxmlchar(text *textstring) +{ + xmlChar *res; + int32 txsize; + + txsize = VARSIZE(textstring) - VARHDRSZ; + res = (xmlChar *) palloc(txsize + 1); + memcpy((char *) res, VARDATA(textstring), txsize); + res[txsize] = '\0'; + return res; } @@ -158,81 +177,86 @@ PG_FUNCTION_INFO_V1(pgxml_xpath); Datum pgxml_xpath(PG_FUNCTION_ARGS) { - xmlDocPtr doctree; - xmlXPathContextPtr ctxt; - xmlXPathObjectPtr res; - xmlChar *xpath, *xpresstr, *toptag, *septag; - xmlXPathCompExprPtr comppath; - - int32 docsize,ressize; - text *t, *xpres; - - t = PG_GETARG_TEXT_P(0); /*document buffer */ - xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */ - toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2)); - septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3)); - - docsize = VARSIZE(t) - VARHDRSZ; - - pgxml_parser_init(); - - doctree = xmlParseMemory((char *) VARDATA(t), docsize); - if (doctree == NULL) { /* not well-formed */ - PG_RETURN_NULL(); - } - - ctxt = xmlXPathNewContext(doctree); - ctxt->node = xmlDocGetRootElement(doctree); - - /* compile the path */ - comppath = xmlXPathCompile(xpath); - if (comppath == NULL) { - elog(NOTICE, "XPath syntax error"); - xmlFreeDoc(doctree); - pfree((void *) xpath); - PG_RETURN_NULL(); - } - - /* Now evaluate the path expression. */ - res = xmlXPathCompiledEval(comppath,ctxt); - xmlXPathFreeCompExpr(comppath); - - if (res==NULL) { - xmlFreeDoc(doctree); - pfree((void *)xpath); - PG_RETURN_NULL(); /* seems appropriate */ - } - /* now we dump this node, ?surrounding by tags? */ - /* To do this, we look first at the type */ - switch(res->type) { - case XPATH_NODESET: - xpresstr = pgxmlNodeSetToText(res->nodesetval, - doctree, - toptag, septag, 0); - break; - case XPATH_STRING: - xpresstr = xmlStrdup(res->stringval); - break; - default: - elog(NOTICE,"Unsupported XQuery result: %d",res->type); - xpresstr = xmlStrdup("<unsupported/>"); - } - - - /* Now convert this result back to text */ - ressize = strlen(xpresstr); - xpres = (text *) palloc(ressize+VARHDRSZ); - memcpy(VARDATA(xpres),xpresstr,ressize); - VARATT_SIZEP(xpres)=ressize + VARHDRSZ; - - /* Free various storage */ - xmlFreeDoc(doctree); - pfree((void *) xpath); - xmlFree(xpresstr); - - PG_RETURN_TEXT_P(xpres); + xmlDocPtr doctree; + xmlXPathContextPtr ctxt; + xmlXPathObjectPtr res; + xmlChar *xpath, + *xpresstr, + *toptag, + *septag; + xmlXPathCompExprPtr comppath; + + int32 docsize, + ressize; + text *t, + *xpres; + + t = PG_GETARG_TEXT_P(0); /* document buffer */ + xpath = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(1)); /* XPath expression */ + toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2)); + septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3)); + + docsize = VARSIZE(t) - VARHDRSZ; + + pgxml_parser_init(); + + doctree = xmlParseMemory((char *) VARDATA(t), docsize); + if (doctree == NULL) + { /* not well-formed */ + PG_RETURN_NULL(); + } + + ctxt = xmlXPathNewContext(doctree); + ctxt->node = xmlDocGetRootElement(doctree); + + /* compile the path */ + comppath = xmlXPathCompile(xpath); + if (comppath == NULL) + { + elog(NOTICE, "XPath syntax error"); + xmlFreeDoc(doctree); + pfree((void *) xpath); + PG_RETURN_NULL(); + } + + /* Now evaluate the path expression. */ + res = xmlXPathCompiledEval(comppath, ctxt); + xmlXPathFreeCompExpr(comppath); + + if (res == NULL) + { + xmlFreeDoc(doctree); + pfree((void *) xpath); + PG_RETURN_NULL(); /* seems appropriate */ + } + /* now we dump this node, ?surrounding by tags? */ + /* To do this, we look first at the type */ + switch (res->type) + { + case XPATH_NODESET: + xpresstr = pgxmlNodeSetToText(res->nodesetval, + doctree, + toptag, septag, 0); + break; + case XPATH_STRING: + xpresstr = xmlStrdup(res->stringval); + break; + default: + elog(NOTICE, "Unsupported XQuery result: %d", res->type); + xpresstr = xmlStrdup("<unsupported/>"); + } + + + /* Now convert this result back to text */ + ressize = strlen(xpresstr); + xpres = (text *) palloc(ressize + VARHDRSZ); + memcpy(VARDATA(xpres), xpresstr, ressize); + VARATT_SIZEP(xpres) = ressize + VARHDRSZ; + + /* Free various storage */ + xmlFreeDoc(doctree); + pfree((void *) xpath); + xmlFree(xpresstr); + + PG_RETURN_TEXT_P(xpres); } - - - - diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c index ef6cedd92d..5b005b3163 100644 --- a/src/backend/access/common/heaptuple.c +++ b/src/backend/access/common/heaptuple.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.73 2001/08/23 23:06:37 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.74 2001/10/25 05:49:20 momjian Exp $ * * NOTES * The old interface functions have been converted to macros @@ -241,7 +241,6 @@ nocachegetattr(HeapTuple tuple, } else { - /* * there's a null somewhere in the tuple */ @@ -347,7 +346,6 @@ nocachegetattr(HeapTuple tuple, (HeapTupleNoNulls(tuple) || !att_isnull(j, bp)) && (HeapTupleAllFixed(tuple) || att[j]->attlen > 0)); j++) { - /* * Fix me when going to a machine with more than a four-byte * word! @@ -546,7 +544,6 @@ heap_deformtuple(HeapTuple tuple, nulls[i] = ' '; } } - #endif /* ---------------- @@ -739,7 +736,7 @@ heap_freetuple(HeapTuple htup) * * This routine forms a HeapTuple by copying the given structure (tuple * data) and adding a generic header. Note that the tuple data is - * presumed to contain no null fields. It is typically only useful + * presumed to contain no null fields. It is typically only useful * for null-free system tables. * ---------------- */ @@ -771,7 +768,7 @@ heap_addheader(int natts, /* max domain index */ td->t_hoff = hoff; td->t_natts = natts; - td->t_infomask = HEAP_XMAX_INVALID; /* XXX sufficient? */ + td->t_infomask = HEAP_XMAX_INVALID; /* XXX sufficient? */ memcpy((char *) td + hoff, structure, structlen); diff --git a/src/backend/access/common/indextuple.c b/src/backend/access/common/indextuple.c index 5c165e2c77..ad6e7cc4e5 100644 --- a/src/backend/access/common/indextuple.c +++ b/src/backend/access/common/indextuple.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.54 2001/03/22 06:16:06 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.55 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -49,7 +49,6 @@ index_formtuple(TupleDesc tupleDescriptor, #ifdef TOAST_INDEX_HACK Datum untoasted_value[INDEX_MAX_KEYS]; bool untoasted_free[INDEX_MAX_KEYS]; - #endif if (numberOfAttributes > INDEX_MAX_KEYS) @@ -338,7 +337,6 @@ nocache_index_getattr(IndexTuple tup, for (; j <= attnum; j++) { - /* * Fix me when going to a machine with more than a four-byte * word! diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c index da95edfc1f..ea10330bf8 100644 --- a/src/backend/access/common/printtup.c +++ b/src/backend/access/common/printtup.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.59 2001/03/22 06:16:06 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.60 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -197,7 +197,6 @@ printtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) continue; if (OidIsValid(thisState->typoutput)) { - /* * If we have a toasted datum, forcibly detoast it here to * avoid memory leakage inside the type's output routine. @@ -306,7 +305,6 @@ debugtup(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) if (getTypeOutputInfo(typeinfo->attrs[i]->atttypid, &typoutput, &typelem, &typisvarlena)) { - /* * If we have a toasted datum, forcibly detoast it here to * avoid memory leakage inside the type's output routine. @@ -401,7 +399,6 @@ printtup_internal(HeapTuple tuple, TupleDesc typeinfo, DestReceiver *self) /* send # of bytes, and opaque data */ if (thisState->typisvarlena) { - /* * If we have a toasted datum, must detoast before sending. */ diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c index 37e895479e..4b9d53df34 100644 --- a/src/backend/access/common/tupdesc.c +++ b/src/backend/access/common/tupdesc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.75 2001/06/25 21:11:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.76 2001/10/25 05:49:20 momjian Exp $ * * NOTES * some of the executor utility code such as "ExecTypeFromTL" should be @@ -238,9 +238,9 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2) Form_pg_attribute attr2 = tupdesc2->attrs[i]; /* - * We do not need to check every single field here: we can disregard - * attrelid, attnum (it was used to place the row in the attrs array) - * and everything derived from the column datatype. + * We do not need to check every single field here: we can + * disregard attrelid, attnum (it was used to place the row in the + * attrs array) and everything derived from the column datatype. */ if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0) return false; @@ -399,7 +399,6 @@ TupleDescInitEntry(TupleDesc desc, 0, 0, 0); if (!HeapTupleIsValid(tuple)) { - /* * here type info does not exist yet so we just fill the attribute * with dummy information and return false. @@ -585,7 +584,6 @@ BuildDescForRelation(List *schema, char *relname) typenameTypeId(typename), atttypmod, attdim, attisset)) { - /* * if TupleDescInitEntry() fails, it means there is no type in * the system catalogs. So now we check if the type name diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c index 4a702fe317..0c4e698f01 100644 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.84 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.85 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -36,26 +36,26 @@ /* group flags ( in gistSplit ) */ #define LEFT_ADDED 0x01 -#define RIGHT_ADDED 0x02 +#define RIGHT_ADDED 0x02 #define BOTH_ADDED ( LEFT_ADDED | RIGHT_ADDED ) /* * This defines only for shorter code, used in gistgetadjusted * and gistadjsubkey only */ -#define FILLITEM(evp, isnullkey, okey, okeyb, rkey, rkeyb) do { \ - if ( isnullkey ) { \ - gistentryinit((evp), rkey, r, (Page) NULL , \ - (OffsetNumber) 0, rkeyb, FALSE); \ - } else { \ - gistentryinit((evp), okey, r, (Page) NULL, \ - (OffsetNumber) 0, okeyb, FALSE); \ - } \ +#define FILLITEM(evp, isnullkey, okey, okeyb, rkey, rkeyb) do { \ + if ( isnullkey ) { \ + gistentryinit((evp), rkey, r, (Page) NULL , \ + (OffsetNumber) 0, rkeyb, FALSE); \ + } else { \ + gistentryinit((evp), okey, r, (Page) NULL, \ + (OffsetNumber) 0, okeyb, FALSE); \ + } \ } while(0) #define FILLEV(isnull1, key1, key1b, isnull2, key2, key2b) do { \ - FILLITEM(*ev0p, isnull1, key1, key1b, key2, key2b); \ - FILLITEM(*ev1p, isnull2, key2, key2b, key1, key1b); \ + FILLITEM(*ev0p, isnull1, key1, key1b, key2, key2b); \ + FILLITEM(*ev1p, isnull2, key2, key2b, key1, key1b); \ } while(0); /* Working state for gistbuild and its callback */ @@ -69,11 +69,11 @@ typedef struct /* non-export function prototypes */ static void gistbuildCallback(Relation index, - HeapTuple htup, - Datum *attdata, - char *nulls, - bool tupleIsAlive, - void *state); + HeapTuple htup, + Datum *attdata, + char *nulls, + bool tupleIsAlive, + void *state); static void gistdoinsert(Relation r, IndexTuple itup, InsertIndexResult *res, @@ -103,14 +103,14 @@ static IndexTuple gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate); -static int gistfindgroup( GISTSTATE *giststate, - GISTENTRY *valvec, GIST_SPLITVEC * spl ); +static int gistfindgroup(GISTSTATE *giststate, + GISTENTRY *valvec, GIST_SPLITVEC *spl); static void gistadjsubkey(Relation r, - IndexTuple *itup, int *len, - GIST_SPLITVEC *v, - GISTSTATE *giststate); -static IndexTuple gistFormTuple( GISTSTATE *giststate, - Relation r, Datum attdata[], int datumsize[], bool isnull[] ); + IndexTuple *itup, int *len, + GIST_SPLITVEC *v, + GISTSTATE *giststate); +static IndexTuple gistFormTuple(GISTSTATE *giststate, + Relation r, Datum attdata[], int datumsize[], bool isnull[]); static IndexTuple *gistSplit(Relation r, Buffer buffer, IndexTuple *itup, @@ -124,6 +124,7 @@ static OffsetNumber gistchoose(Relation r, Page p, IndexTuple it, GISTSTATE *giststate); static void gistdelete(Relation r, ItemPointer tid); + #ifdef GIST_PAGEADDITEM static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t); @@ -132,14 +133,15 @@ static void gistcentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e, Datum k, Relation r, Page pg, OffsetNumber o, int b, bool l, bool isNull); -static void gistDeCompressAtt( GISTSTATE *giststate, Relation r, - IndexTuple tuple, Page p, OffsetNumber o, - GISTENTRY attdata[], bool decompvec[], bool isnull[] ); -static void gistFreeAtt( Relation r, GISTENTRY attdata[], bool decompvec[] ); -static void gistpenalty( GISTSTATE *giststate, int attno, +static void gistDeCompressAtt(GISTSTATE *giststate, Relation r, + IndexTuple tuple, Page p, OffsetNumber o, + GISTENTRY attdata[], bool decompvec[], bool isnull[]); +static void gistFreeAtt(Relation r, GISTENTRY attdata[], bool decompvec[]); +static void gistpenalty(GISTSTATE *giststate, int attno, GISTENTRY *key1, bool isNull1, - GISTENTRY *key2, bool isNull2, - float *penalty ); + GISTENTRY *key2, bool isNull2, + float *penalty); + #undef GISTDEBUG #ifdef GISTDEBUG @@ -182,7 +184,7 @@ gistbuild(PG_FUNCTION_ARGS) /* do the heap scan */ reltuples = IndexBuildHeapScan(heap, index, indexInfo, - gistbuildCallback, (void *) &buildstate); + gistbuildCallback, (void *) &buildstate); /* okay, all heap tuples are indexed */ @@ -208,7 +210,7 @@ gistbuild(PG_FUNCTION_ARGS) UpdateStats(irelid, buildstate.indtuples); } - freeGISTstate( &buildstate.giststate ); + freeGISTstate(&buildstate.giststate); #ifdef GISTDEBUG gist_dumptree(index, 0, GISTP_ROOT, 0); #endif @@ -227,28 +229,31 @@ gistbuildCallback(Relation index, bool tupleIsAlive, void *state) { - GISTBuildState *buildstate = (GISTBuildState *) state; + GISTBuildState *buildstate = (GISTBuildState *) state; IndexTuple itup; bool compvec[INDEX_MAX_KEYS]; GISTENTRY tmpcentry; int i; - /* GiST cannot index tuples with leading NULLs */ - if ( nulls[0] == 'n' ) - return; + /* GiST cannot index tuples with leading NULLs */ + if (nulls[0] == 'n') + return; /* immediately compress keys to normalize */ for (i = 0; i < buildstate->numindexattrs; i++) { - if ( nulls[i]=='n' ) { + if (nulls[i] == 'n') + { attdata[i] = (Datum) 0; compvec[i] = FALSE; - } else { + } + else + { gistcentryinit(&buildstate->giststate, i, &tmpcentry, attdata[i], - (Relation) NULL, (Page) NULL, (OffsetNumber) 0, - -1 /* size is currently bogus */ , TRUE, FALSE); + (Relation) NULL, (Page) NULL, (OffsetNumber) 0, + -1 /* size is currently bogus */ , TRUE, FALSE); if (attdata[i] != tmpcentry.key && - !( isAttByVal(&buildstate->giststate, i))) + !(isAttByVal(&buildstate->giststate, i))) compvec[i] = TRUE; else compvec[i] = FALSE; @@ -262,10 +267,10 @@ gistbuildCallback(Relation index, /* * Since we already have the index relation locked, we call - * gistdoinsert directly. Normal access method calls dispatch - * through gistinsert, which locks the relation for write. This - * is the right thing to do if you're inserting single tups, but - * not when you're initializing the whole index at once. + * gistdoinsert directly. Normal access method calls dispatch through + * gistinsert, which locks the relation for write. This is the right + * thing to do if you're inserting single tups, but not when you're + * initializing the whole index at once. */ gistdoinsert(index, itup, NULL, &buildstate->giststate); @@ -291,6 +296,7 @@ gistinsert(PG_FUNCTION_ARGS) Datum *datum = (Datum *) PG_GETARG_POINTER(1); char *nulls = (char *) PG_GETARG_POINTER(2); ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + #ifdef NOT_USED Relation heapRel = (Relation) PG_GETARG_POINTER(4); #endif @@ -303,29 +309,33 @@ gistinsert(PG_FUNCTION_ARGS) /* * Since GIST is not marked "amconcurrent" in pg_am, caller should - * have acquired exclusive lock on index relation. We need no locking + * have acquired exclusive lock on index relation. We need no locking * here. */ - /* GiST cannot index tuples with leading NULLs */ - if ( nulls[0] == 'n' ) { + /* GiST cannot index tuples with leading NULLs */ + if (nulls[0] == 'n') + { res = NULL; PG_RETURN_POINTER(res); - } + } initGISTstate(&giststate, r); /* immediately compress keys to normalize */ for (i = 0; i < r->rd_att->natts; i++) { - if ( nulls[i]=='n' ) { + if (nulls[i] == 'n') + { datum[i] = (Datum) 0; compvec[i] = FALSE; - } else { + } + else + { gistcentryinit(&giststate, i, &tmpentry, datum[i], - (Relation) NULL, (Page) NULL, (OffsetNumber) 0, - -1 /* size is currently bogus */ , TRUE, FALSE ); - if (datum[i] != tmpentry.key && !( isAttByVal( &giststate, i))) + (Relation) NULL, (Page) NULL, (OffsetNumber) 0, + -1 /* size is currently bogus */ , TRUE, FALSE); + if (datum[i] != tmpentry.key && !(isAttByVal(&giststate, i))) compvec[i] = TRUE; else compvec[i] = FALSE; @@ -342,7 +352,7 @@ gistinsert(PG_FUNCTION_ARGS) if (compvec[i] == TRUE) pfree(DatumGetPointer(datum[i])); pfree(itup); - freeGISTstate( &giststate ); + freeGISTstate(&giststate); PG_RETURN_POINTER(res); } @@ -376,12 +386,12 @@ gistPageAddItem(GISTSTATE *giststate, * offset for insertion */ datum = index_getattr(itup, 1, r->rd_att, &IsNull); - gistdentryinit(giststate, 0,dentry, datum, + gistdentryinit(giststate, 0, dentry, datum, (Relation) 0, (Page) 0, (OffsetNumber) InvalidOffsetNumber, - ATTSIZE( datum, r, 1, IsNull ), + ATTSIZE(datum, r, 1, IsNull), FALSE, IsNull); - gistcentryinit(giststate, 0,&tmpcentry, dentry->key, r, page, + gistcentryinit(giststate, 0, &tmpcentry, dentry->key, r, page, offsetNumber, dentry->bytes, FALSE); *newtup = gist_tuple_replacekey(r, tmpcentry, itup); retval = PageAddItem(page, (Item) *newtup, IndexTupleSize(*newtup), @@ -392,7 +402,7 @@ gistPageAddItem(GISTSTATE *giststate, /* be tidy */ if (DatumGetPointer(tmpcentry.key) != NULL && tmpcentry.key != dentry->key && - tmpcentry.key != datum ) + tmpcentry.key != datum) pfree(DatumGetPointer(tmpcentry.key)); return (retval); } @@ -471,6 +481,7 @@ gistlayerinsert(Relation r, BlockNumber blkno, if (!(ret & SPLITED)) { IndexTuple newtup = gistgetadjusted(r, oldtup, (*itup)[0], giststate); + if (!newtup) { /* not need to update key */ @@ -492,8 +503,10 @@ gistlayerinsert(Relation r, BlockNumber blkno, if (gistnospace(page, (*itup), *len)) { /* no space for insertion */ - IndexTuple *itvec, *newitup; - int tlen,oldlen; + IndexTuple *itvec, + *newitup; + int tlen, + oldlen; ret |= SPLITED; itvec = gistreadbuffer(r, buffer, &tlen); @@ -503,9 +516,9 @@ gistlayerinsert(Relation r, BlockNumber blkno, (opaque->flags & F_LEAF) ? res : NULL); /* res only for * inserting in leaf */ ReleaseBuffer(buffer); - do - pfree( (*itup)[ oldlen-1 ] ); - while ( (--oldlen) > 0 ); + do + pfree((*itup)[oldlen - 1]); + while ((--oldlen) > 0); pfree((*itup)); pfree(itvec); *itup = newitup; @@ -539,7 +552,8 @@ gistlayerinsert(Relation r, BlockNumber blkno, * parent */ IndexTuple newtup = gistunion(r, (*itup), *len, giststate); - ItemPointerSet(&(newtup->t_tid), blkno, 1); + + ItemPointerSet(&(newtup->t_tid), blkno, 1); for (i = 0; i < *len; i++) pfree((*itup)[i]); @@ -560,10 +574,11 @@ gistwritebuffer(Relation r, Page page, IndexTuple *itup, { OffsetNumber l = InvalidOffsetNumber; int i; + #ifdef GIST_PAGEADDITEM GISTENTRY tmpdentry; IndexTuple newtup; - bool IsNull; + bool IsNull; #endif for (i = 0; i < len; i++) { @@ -573,13 +588,13 @@ gistwritebuffer(Relation r, Page page, IndexTuple *itup, off, LP_USED, &tmpdentry, &newtup); off = OffsetNumberNext(off); if (DatumGetPointer(tmpdentry.key) != NULL && - tmpdentry.key != index_getattr(itup[i], 1, r->rd_att, &IsNull)) + tmpdentry.key != index_getattr(itup[i], 1, r->rd_att, &IsNull)) pfree(DatumGetPointer(tmpdentry.key)); if (itup[i] != newtup) pfree(newtup); #else l = PageAddItem(page, (Item) itup[i], IndexTupleSize(itup[i]), - off, LP_USED); + off, LP_USED); if (l == InvalidOffsetNumber) elog(ERROR, "gist: failed to add index item to %s", RelationGetRelationName(r)); @@ -618,7 +633,7 @@ gistreadbuffer(Relation r, Buffer buffer, int *len /* out */ ) *len = maxoff; itvec = palloc(sizeof(IndexTuple) * maxoff); for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) - itvec[i-1] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); + itvec[i - 1] = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); return itvec; } @@ -639,74 +654,85 @@ gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen) * return union of itup vector */ static IndexTuple -gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) { +gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) +{ Datum attr[INDEX_MAX_KEYS]; - bool whatfree[INDEX_MAX_KEYS]; + bool whatfree[INDEX_MAX_KEYS]; char isnull[INDEX_MAX_KEYS]; bytea *evec; Datum datum; int datumsize, - i,j; + i, + j; GISTENTRY centry[INDEX_MAX_KEYS]; - bool *needfree; - IndexTuple newtup; - bool IsNull; - int reallen; + bool *needfree; + IndexTuple newtup; + bool IsNull; + int reallen; - needfree = (bool *) palloc((( len==1 ) ? 2 : len ) * sizeof(bool)); - evec = (bytea *) palloc((( len==1 ) ? 2 : len ) * sizeof(GISTENTRY) + VARHDRSZ); + needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool)); + evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ); - for (j = 0; j < r->rd_att->natts; j++) { - reallen=0; - for (i = 0; i < len; i++) { - datum = index_getattr(itvec[i], j+1, giststate->tupdesc, &IsNull); - if ( IsNull ) continue; + for (j = 0; j < r->rd_att->natts; j++) + { + reallen = 0; + for (i = 0; i < len; i++) + { + datum = index_getattr(itvec[i], j + 1, giststate->tupdesc, &IsNull); + if (IsNull) + continue; gistdentryinit(giststate, j, &((GISTENTRY *) VARDATA(evec))[reallen], datum, - (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, - ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull); - if ( (!isAttByVal(giststate,j)) && - ((GISTENTRY *) VARDATA(evec))[reallen].key != datum ) + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull); + if ((!isAttByVal(giststate, j)) && + ((GISTENTRY *) VARDATA(evec))[reallen].key != datum) needfree[reallen] = TRUE; else needfree[reallen] = FALSE; reallen++; } - if ( reallen == 0 ) { + if (reallen == 0) + { attr[j] = (Datum) 0; isnull[j] = 'n'; whatfree[j] = FALSE; - } else { - if ( reallen == 1 ) { + } + else + { + if (reallen == 1) + { VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ; - gistentryinit(((GISTENTRY *) VARDATA(evec))[1], - ((GISTENTRY *) VARDATA(evec))[0].key, r, (Page) NULL, - (OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE); + gistentryinit(((GISTENTRY *) VARDATA(evec))[1], + ((GISTENTRY *) VARDATA(evec))[0].key, r, (Page) NULL, + (OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE); - } else { - VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ; } + else + VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ; datum = FunctionCall2(&giststate->unionFn[j], - PointerGetDatum(evec), - PointerGetDatum(&datumsize)); - + PointerGetDatum(evec), + PointerGetDatum(&datumsize)); + for (i = 0; i < reallen; i++) - if ( needfree[i] ) + if (needfree[i]) pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key)); gistcentryinit(giststate, j, ¢ry[j], datum, - (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, - datumsize, FALSE, FALSE); + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + datumsize, FALSE, FALSE); isnull[j] = ' '; - attr[j] = centry[j].key; - if ( !isAttByVal( giststate, j ) ) { + attr[j] = centry[j].key; + if (!isAttByVal(giststate, j)) + { whatfree[j] = TRUE; - if ( centry[j].key != datum ) + if (centry[j].key != datum) pfree(DatumGetPointer(datum)); - } else + } + else whatfree[j] = FALSE; } } @@ -716,7 +742,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) { newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull); for (j = 0; j < r->rd_att->natts; j++) - if ( whatfree[j] ) + if (whatfree[j]) pfree(DatumGetPointer(attr[j])); return newtup; @@ -732,7 +758,8 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis bytea *evec; Datum datum; int datumsize; - bool result, neednew = false; + bool result, + neednew = false; char isnull[INDEX_MAX_KEYS], whatfree[INDEX_MAX_KEYS]; Datum attr[INDEX_MAX_KEYS]; @@ -744,104 +771,125 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis bool olddec[INDEX_MAX_KEYS], adddec[INDEX_MAX_KEYS]; bool oldisnull[INDEX_MAX_KEYS], - addisnull[INDEX_MAX_KEYS]; + addisnull[INDEX_MAX_KEYS]; IndexTuple newtup = NULL; - int j; + int j; evec = (bytea *) palloc(2 * sizeof(GISTENTRY) + VARHDRSZ); VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ; ev0p = &((GISTENTRY *) VARDATA(evec))[0]; ev1p = &((GISTENTRY *) VARDATA(evec))[1]; - - gistDeCompressAtt( giststate, r, oldtup, (Page) NULL, - (OffsetNumber) 0, oldatt, olddec, oldisnull); - gistDeCompressAtt( giststate, r, addtup, (Page) NULL, - (OffsetNumber) 0, addatt, adddec, addisnull); + gistDeCompressAtt(giststate, r, oldtup, (Page) NULL, + (OffsetNumber) 0, oldatt, olddec, oldisnull); + + gistDeCompressAtt(giststate, r, addtup, (Page) NULL, + (OffsetNumber) 0, addatt, adddec, addisnull); + - - for( j=0; j<r->rd_att->natts; j++ ) { - if ( oldisnull[j] && addisnull[j] ) { + for (j = 0; j < r->rd_att->natts; j++) + { + if (oldisnull[j] && addisnull[j]) + { isnull[j] = 'n'; attr[j] = (Datum) 0; whatfree[j] = FALSE; - } else { + } + else + { FILLEV( - oldisnull[j], oldatt[j].key, oldatt[j].bytes, - addisnull[j], addatt[j].key, addatt[j].bytes - ); - + oldisnull[j], oldatt[j].key, oldatt[j].bytes, + addisnull[j], addatt[j].key, addatt[j].bytes + ); + datum = FunctionCall2(&giststate->unionFn[j], - PointerGetDatum(evec), - PointerGetDatum(&datumsize)); + PointerGetDatum(evec), + PointerGetDatum(&datumsize)); - if ( oldisnull[j] || addisnull[j] ) { - if ( oldisnull[j] ) + if (oldisnull[j] || addisnull[j]) + { + if (oldisnull[j]) neednew = true; - } else { + } + else + { FunctionCall3(&giststate->equalFn[j], - ev0p->key, - datum, - PointerGetDatum(&result)); - - if ( !result ) + ev0p->key, + datum, + PointerGetDatum(&result)); + + if (!result) neednew = true; } - if ( olddec[j] ) pfree( DatumGetPointer(oldatt[j].key) ); - if ( adddec[j] ) pfree( DatumGetPointer(addatt[j].key) ); + if (olddec[j]) + pfree(DatumGetPointer(oldatt[j].key)); + if (adddec[j]) + pfree(DatumGetPointer(addatt[j].key)); gistcentryinit(giststate, j, ¢ry[j], datum, - (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, - datumsize, FALSE, FALSE); - + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + datumsize, FALSE, FALSE); + isnull[j] = ' '; - attr[j] = centry[j].key; - if ( (!isAttByVal( giststate, j ) ) ) { + attr[j] = centry[j].key; + if ((!isAttByVal(giststate, j))) + { whatfree[j] = TRUE; - if ( centry[j].key != datum ) + if (centry[j].key != datum) pfree(DatumGetPointer(datum)); - } else + } + else whatfree[j] = FALSE; } - } + } pfree(evec); - if (neednew) { + if (neednew) + { /* need to update key */ newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull); newtup->t_tid = oldtup->t_tid; } - + for (j = 0; j < r->rd_att->natts; j++) - if ( whatfree[j] ) + if (whatfree[j]) pfree(DatumGetPointer(attr[j])); return newtup; } static void -gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC * spl ) { - int i,j,lr; +gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITVEC *spl) +{ + int i, + j, + lr; Datum *attr; - bool *needfree, IsNull; - int len, *attrsize; - OffsetNumber *entries; - bytea *evec; + bool *needfree, + IsNull; + int len, + *attrsize; + OffsetNumber *entries; + bytea *evec; Datum datum; - int datumsize; - int reallen; - bool *isnull; + int datumsize; + int reallen; + bool *isnull; - for(lr=0;lr<=1;lr++) { - if ( lr ) { + for (lr = 0; lr <= 1; lr++) + { + if (lr) + { attrsize = spl->spl_lattrsize; attr = spl->spl_lattr; len = spl->spl_nleft; entries = spl->spl_left; isnull = spl->spl_lisnull; - } else { + } + else + { attrsize = spl->spl_rattrsize; attr = spl->spl_rattr; len = spl->spl_nright; @@ -849,58 +897,64 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT isnull = spl->spl_risnull; } - needfree = (bool *) palloc( (( len==1 ) ? 2 : len ) * sizeof(bool)); - evec = (bytea *) palloc( (( len==1 ) ? 2 : len ) * sizeof(GISTENTRY) + VARHDRSZ); - for (j = 1; j < r->rd_att->natts; j++) { + needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool)); + evec = (bytea *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + VARHDRSZ); + for (j = 1; j < r->rd_att->natts; j++) + { reallen = 0; - for (i = 0; i < len; i++) { - if ( spl->spl_idgrp[ entries[i] ] ) + for (i = 0; i < len; i++) + { + if (spl->spl_idgrp[entries[i]]) continue; - datum = index_getattr(itvec[ entries[i]-1 ], j+1, + datum = index_getattr(itvec[entries[i] - 1], j + 1, giststate->tupdesc, &IsNull); - if ( IsNull ) + if (IsNull) continue; gistdentryinit(giststate, j, &((GISTENTRY *) VARDATA(evec))[reallen], datum, (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, - ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull); - if ( (!isAttByVal( giststate, j )) && - ((GISTENTRY *) VARDATA(evec))[reallen].key != datum ) + ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull); + if ((!isAttByVal(giststate, j)) && + ((GISTENTRY *) VARDATA(evec))[reallen].key != datum) needfree[reallen] = TRUE; else needfree[reallen] = FALSE; reallen++; - - } - if ( reallen == 0 ) + + } + if (reallen == 0) { datum = (Datum) 0; datumsize = 0; isnull[j] = true; - } else { + } + else + { /* - * ((GISTENTRY *) VARDATA(evec))[0].bytes may be not defined, - * so form union with itself + * ((GISTENTRY *) VARDATA(evec))[0].bytes may be not + * defined, so form union with itself */ - if ( reallen == 1 ) { + if (reallen == 1) + { VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ; - memcpy( (void*) &((GISTENTRY *) VARDATA(evec))[1], - (void*) &((GISTENTRY *) VARDATA(evec))[0], - sizeof( GISTENTRY ) ); - } else + memcpy((void *) &((GISTENTRY *) VARDATA(evec))[1], + (void *) &((GISTENTRY *) VARDATA(evec))[0], + sizeof(GISTENTRY)); + } + else VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ; datum = FunctionCall2(&giststate->unionFn[j], - PointerGetDatum(evec), - PointerGetDatum(&datumsize)); + PointerGetDatum(evec), + PointerGetDatum(&datumsize)); isnull[j] = false; - } + } for (i = 0; i < reallen; i++) - if ( needfree[i] ) + if (needfree[i]) pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key)); - + attr[j] = datum; attrsize[j] = datumsize; } @@ -910,51 +964,63 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT } /* - * find group in vector with equial value + * find group in vector with equial value */ static int -gistfindgroup( GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC * spl ) { - int i,j,len; - int curid = 1; - bool result; - - /* - * first key is always not null (see gistinsert), - * so we may not check for nulls - */ - - for(i=0; i<spl->spl_nleft; i++) { - if ( spl->spl_idgrp[ spl->spl_left[i] ]) continue; +gistfindgroup(GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC *spl) +{ + int i, + j, + len; + int curid = 1; + bool result; + + /* + * first key is always not null (see gistinsert), so we may not check + * for nulls + */ + + for (i = 0; i < spl->spl_nleft; i++) + { + if (spl->spl_idgrp[spl->spl_left[i]]) + continue; len = 0; /* find all equal value in right part */ - for(j=0; j < spl->spl_nright; j++) { - if ( spl->spl_idgrp[ spl->spl_right[j] ]) continue; + for (j = 0; j < spl->spl_nright; j++) + { + if (spl->spl_idgrp[spl->spl_right[j]]) + continue; FunctionCall3(&giststate->equalFn[0], - valvec[ spl->spl_left[i] ].key, - valvec[ spl->spl_right[j] ].key, + valvec[spl->spl_left[i]].key, + valvec[spl->spl_right[j]].key, PointerGetDatum(&result)); - if ( result ) { - spl->spl_idgrp[ spl->spl_right[j] ] = curid; + if (result) + { + spl->spl_idgrp[spl->spl_right[j]] = curid; len++; } } /* find all other equal value in left part */ - if ( len ) { - /* add current val to list of equial values*/ - spl->spl_idgrp[ spl->spl_left[i] ]=curid; + if (len) + { + /* add current val to list of equial values */ + spl->spl_idgrp[spl->spl_left[i]] = curid; /* searching .. */ - for(j=i+1; j < spl->spl_nleft; j++) { - if ( spl->spl_idgrp[ spl->spl_left[j] ]) continue; + for (j = i + 1; j < spl->spl_nleft; j++) + { + if (spl->spl_idgrp[spl->spl_left[j]]) + continue; FunctionCall3(&giststate->equalFn[0], - valvec[ spl->spl_left[i] ].key, - valvec[ spl->spl_left[j] ].key, + valvec[spl->spl_left[i]].key, + valvec[spl->spl_left[j]].key, PointerGetDatum(&result)); - if ( result ) { - spl->spl_idgrp[ spl->spl_left[j] ] = curid; + if (result) + { + spl->spl_idgrp[spl->spl_left[j]] = curid; len++; } } - spl->spl_ngrp[curid] = len+1; + spl->spl_ngrp[curid] = len + 1; curid++; } } @@ -968,40 +1034,50 @@ gistfindgroup( GISTSTATE *giststate, GISTENTRY *valvec, GIST_SPLITVEC * spl ) { */ static void gistadjsubkey(Relation r, - IndexTuple *itup, /* contains compressed entry */ - int *len, - GIST_SPLITVEC *v, - GISTSTATE *giststate - ) { - int curlen; - OffsetNumber *curwpos; - bool decfree[INDEX_MAX_KEYS]; - GISTENTRY entry,identry[INDEX_MAX_KEYS], *ev0p, *ev1p; - float lpenalty, rpenalty; - bytea *evec; - int datumsize; - bool isnull[INDEX_MAX_KEYS]; - int i,j; + IndexTuple *itup, /* contains compressed entry */ + int *len, + GIST_SPLITVEC *v, + GISTSTATE *giststate +) +{ + int curlen; + OffsetNumber *curwpos; + bool decfree[INDEX_MAX_KEYS]; + GISTENTRY entry, + identry[INDEX_MAX_KEYS], + *ev0p, + *ev1p; + float lpenalty, + rpenalty; + bytea *evec; + int datumsize; + bool isnull[INDEX_MAX_KEYS]; + int i, + j; Datum datum; /* clear vectors */ curlen = v->spl_nleft; curwpos = v->spl_left; - for( i=0; i<v->spl_nleft;i++ ) - if ( v->spl_idgrp[ v->spl_left[i] ] == 0 ) { + for (i = 0; i < v->spl_nleft; i++) + if (v->spl_idgrp[v->spl_left[i]] == 0) + { *curwpos = v->spl_left[i]; curwpos++; - } else + } + else curlen--; v->spl_nleft = curlen; curlen = v->spl_nright; curwpos = v->spl_right; - for( i=0; i<v->spl_nright;i++ ) - if ( v->spl_idgrp[ v->spl_right[i] ] == 0 ) { + for (i = 0; i < v->spl_nright; i++) + if (v->spl_idgrp[v->spl_right[i]] == 0) + { *curwpos = v->spl_right[i]; curwpos++; - } else + } + else curlen--; v->spl_nright = curlen; @@ -1011,82 +1087,98 @@ gistadjsubkey(Relation r, ev1p = &((GISTENTRY *) VARDATA(evec))[1]; /* add equivalent tuple */ - for(i = 0; i< *len; i++) { - if ( v->spl_idgrp[ i+1 ]==0 ) /* already inserted */ + for (i = 0; i < *len; i++) + { + if (v->spl_idgrp[i + 1] == 0) /* already inserted */ continue; - gistDeCompressAtt( giststate, r, itup[i], (Page) NULL, (OffsetNumber) 0, - identry, decfree, isnull); + gistDeCompressAtt(giststate, r, itup[i], (Page) NULL, (OffsetNumber) 0, + identry, decfree, isnull); - v->spl_ngrp[ v->spl_idgrp[ i+1 ] ]--; - if ( v->spl_ngrp[ v->spl_idgrp[ i+1 ] ] == 0 && - (v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] & BOTH_ADDED) != BOTH_ADDED ) { + v->spl_ngrp[v->spl_idgrp[i + 1]]--; + if (v->spl_ngrp[v->spl_idgrp[i + 1]] == 0 && + (v->spl_grpflag[v->spl_idgrp[i + 1]] & BOTH_ADDED) != BOTH_ADDED) + { /* force last in group */ rpenalty = 1.0; - lpenalty = ( v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] & LEFT_ADDED ) ? 2.0 : 0.0; - } else { - /*where?*/ - for( j=1; j<r->rd_att->natts; j++ ) { - gistentryinit(entry,v->spl_lattr[j], r, (Page) NULL, - (OffsetNumber) 0, v->spl_lattrsize[j], FALSE); - gistpenalty( giststate, j, &entry, v->spl_lisnull[j], - &identry[j], isnull[j], &lpenalty); - - gistentryinit(entry,v->spl_rattr[j], r, (Page) NULL, - (OffsetNumber) 0, v->spl_rattrsize[j], FALSE); - gistpenalty( giststate, j, &entry, v->spl_risnull[j], - &identry[j], isnull[j], &rpenalty); - - if ( lpenalty != rpenalty ) + lpenalty = (v->spl_grpflag[v->spl_idgrp[i + 1]] & LEFT_ADDED) ? 2.0 : 0.0; + } + else + { + /* where? */ + for (j = 1; j < r->rd_att->natts; j++) + { + gistentryinit(entry, v->spl_lattr[j], r, (Page) NULL, + (OffsetNumber) 0, v->spl_lattrsize[j], FALSE); + gistpenalty(giststate, j, &entry, v->spl_lisnull[j], + &identry[j], isnull[j], &lpenalty); + + gistentryinit(entry, v->spl_rattr[j], r, (Page) NULL, + (OffsetNumber) 0, v->spl_rattrsize[j], FALSE); + gistpenalty(giststate, j, &entry, v->spl_risnull[j], + &identry[j], isnull[j], &rpenalty); + + if (lpenalty != rpenalty) break; } } /* add */ - if ( lpenalty < rpenalty ) { - v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] |= LEFT_ADDED; - v->spl_left[ v->spl_nleft ] = i+1; + if (lpenalty < rpenalty) + { + v->spl_grpflag[v->spl_idgrp[i + 1]] |= LEFT_ADDED; + v->spl_left[v->spl_nleft] = i + 1; v->spl_nleft++; - for( j=1; j<r->rd_att->natts; j++ ) { - if ( isnull[j] && v->spl_lisnull[j] ) { + for (j = 1; j < r->rd_att->natts; j++) + { + if (isnull[j] && v->spl_lisnull[j]) + { v->spl_lattr[j] = (Datum) 0; v->spl_lattrsize[j] = 0; - } else { + } + else + { FILLEV( - v->spl_lisnull[j], v->spl_lattr[j], v->spl_lattrsize[j], - isnull[j], identry[j].key, identry[j].bytes - ); + v->spl_lisnull[j], v->spl_lattr[j], v->spl_lattrsize[j], + isnull[j], identry[j].key, identry[j].bytes + ); datum = FunctionCall2(&giststate->unionFn[j], - PointerGetDatum(evec), - PointerGetDatum(&datumsize)); + PointerGetDatum(evec), + PointerGetDatum(&datumsize)); - if ( (!isAttByVal( giststate, j )) && !v->spl_lisnull[j] ) - pfree( DatumGetPointer(v->spl_lattr[j]) ); + if ((!isAttByVal(giststate, j)) && !v->spl_lisnull[j]) + pfree(DatumGetPointer(v->spl_lattr[j])); v->spl_lattr[j] = datum; v->spl_lattrsize[j] = datumsize; v->spl_lisnull[j] = false; } } - } else { - v->spl_grpflag[ v->spl_idgrp[ i+1 ] ] |= RIGHT_ADDED; - v->spl_right[ v->spl_nright ] = i+1; + } + else + { + v->spl_grpflag[v->spl_idgrp[i + 1]] |= RIGHT_ADDED; + v->spl_right[v->spl_nright] = i + 1; v->spl_nright++; - for( j=1; j<r->rd_att->natts; j++ ) { - if ( isnull[j] && v->spl_risnull[j] ) { + for (j = 1; j < r->rd_att->natts; j++) + { + if (isnull[j] && v->spl_risnull[j]) + { v->spl_rattr[j] = (Datum) 0; v->spl_rattrsize[j] = 0; - } else { + } + else + { FILLEV( - v->spl_risnull[j], v->spl_rattr[j], v->spl_rattrsize[j], - isnull[j], identry[j].key, identry[j].bytes - ); + v->spl_risnull[j], v->spl_rattr[j], v->spl_rattrsize[j], + isnull[j], identry[j].key, identry[j].bytes + ); datum = FunctionCall2(&giststate->unionFn[j], - PointerGetDatum(evec), - PointerGetDatum(&datumsize)); + PointerGetDatum(evec), + PointerGetDatum(&datumsize)); - if ( (!isAttByVal( giststate, j)) && !v->spl_risnull[j] ) - pfree( DatumGetPointer(v->spl_rattr[j]) ); + if ((!isAttByVal(giststate, j)) && !v->spl_risnull[j]) + pfree(DatumGetPointer(v->spl_rattr[j])); v->spl_rattr[j] = datum; v->spl_rattrsize[j] = datumsize; @@ -1094,8 +1186,8 @@ gistadjsubkey(Relation r, } } - } - gistFreeAtt( r, identry, decfree ); + } + gistFreeAtt(r, identry, decfree); } pfree(evec); } @@ -1125,11 +1217,12 @@ gistSplit(Relation r, GIST_SPLITVEC v; bytea *entryvec; bool *decompvec; - int i,j, + int i, + j, nlen; - int MaxGrpId = 1; + int MaxGrpId = 1; Datum datum; - bool IsNull; + bool IsNull; p = (Page) BufferGetPage(buffer); opaque = (GISTPageOpaque) PageGetSpecialPointer(p); @@ -1168,57 +1261,62 @@ gistSplit(Relation r, for (i = 1; i <= *len; i++) { datum = index_getattr(itup[i - 1], 1, giststate->tupdesc, &IsNull); - gistdentryinit(giststate, 0,&((GISTENTRY *) VARDATA(entryvec))[i], - datum, r, p, i, - ATTSIZE( datum, giststate->tupdesc, 1, IsNull ), FALSE, IsNull); - if ( (!isAttByVal(giststate,0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum ) + gistdentryinit(giststate, 0, &((GISTENTRY *) VARDATA(entryvec))[i], + datum, r, p, i, + ATTSIZE(datum, giststate->tupdesc, 1, IsNull), FALSE, IsNull); + if ((!isAttByVal(giststate, 0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum) decompvec[i] = TRUE; else decompvec[i] = FALSE; } - /* now let the user-defined picksplit function set up the split vector; - in entryvec have no null value!! */ + /* + * now let the user-defined picksplit function set up the split + * vector; in entryvec have no null value!! + */ FunctionCall2(&giststate->picksplitFn[0], PointerGetDatum(entryvec), PointerGetDatum(&v)); - /* compatibility with old code */ - if ( v.spl_left[ v.spl_nleft-1 ] == InvalidOffsetNumber ) - v.spl_left[ v.spl_nleft-1 ] = (OffsetNumber)*len; - if ( v.spl_right[ v.spl_nright-1 ] == InvalidOffsetNumber ) - v.spl_right[ v.spl_nright-1 ] = (OffsetNumber)*len; - - v.spl_lattr[0] = v.spl_ldatum; + /* compatibility with old code */ + if (v.spl_left[v.spl_nleft - 1] == InvalidOffsetNumber) + v.spl_left[v.spl_nleft - 1] = (OffsetNumber) *len; + if (v.spl_right[v.spl_nright - 1] == InvalidOffsetNumber) + v.spl_right[v.spl_nright - 1] = (OffsetNumber) *len; + + v.spl_lattr[0] = v.spl_ldatum; v.spl_rattr[0] = v.spl_rdatum; v.spl_lisnull[0] = false; v.spl_risnull[0] = false; - /* if index is multikey, then we must to try get smaller - * bounding box for subkey(s) - */ - if ( r->rd_att->natts > 1 ) { - v.spl_idgrp = (int*) palloc( sizeof(int) * (*len + 1) ); - MemSet((void*)v.spl_idgrp, 0, sizeof(int) * (*len + 1) ); - v.spl_grpflag = (char*) palloc( sizeof(char) * (*len + 1) ); - MemSet((void*)v.spl_grpflag, 0, sizeof(char) * (*len + 1) ); - v.spl_ngrp = (int*) palloc( sizeof(int) * (*len + 1) ); + /* + * if index is multikey, then we must to try get smaller bounding box + * for subkey(s) + */ + if (r->rd_att->natts > 1) + { + v.spl_idgrp = (int *) palloc(sizeof(int) * (*len + 1)); + MemSet((void *) v.spl_idgrp, 0, sizeof(int) * (*len + 1)); + v.spl_grpflag = (char *) palloc(sizeof(char) * (*len + 1)); + MemSet((void *) v.spl_grpflag, 0, sizeof(char) * (*len + 1)); + v.spl_ngrp = (int *) palloc(sizeof(int) * (*len + 1)); - MaxGrpId = gistfindgroup( giststate, (GISTENTRY *) VARDATA(entryvec), &v ); + MaxGrpId = gistfindgroup(giststate, (GISTENTRY *) VARDATA(entryvec), &v); /* form union of sub keys for each page (l,p) */ - gistunionsubkey( r, giststate, itup, &v ); + gistunionsubkey(r, giststate, itup, &v); - /* if possible, we insert equivalent tuples - * with control by penalty for a subkey(s) - */ - if ( MaxGrpId > 1 ) - gistadjsubkey( r,itup,len, &v, giststate ); + /* + * if possible, we insert equivalent tuples with control by + * penalty for a subkey(s) + */ + if (MaxGrpId > 1) + gistadjsubkey(r, itup, len, &v, giststate); - pfree( v.spl_idgrp ); - pfree( v.spl_grpflag ); - pfree( v.spl_ngrp ); - } + pfree(v.spl_idgrp); + pfree(v.spl_grpflag); + pfree(v.spl_ngrp); + } /* clean up the entry vector: its keys need to be deleted, too */ for (i = 1; i <= *len; i++) @@ -1231,11 +1329,11 @@ gistSplit(Relation r, lvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nleft); rvectup = (IndexTuple *) palloc(sizeof(IndexTuple) * v.spl_nright); - for(i=0; i<v.spl_nleft;i++) - lvectup[i] = itup[ v.spl_left[i] - 1 ]; + for (i = 0; i < v.spl_nleft; i++) + lvectup[i] = itup[v.spl_left[i] - 1]; - for(i=0; i<v.spl_nright;i++) - rvectup[i] = itup[ v.spl_right[i] - 1 ]; + for (i = 0; i < v.spl_nright; i++) + rvectup[i] = itup[v.spl_right[i] - 1]; /* write on disk (may be need another split) */ @@ -1245,9 +1343,9 @@ gistSplit(Relation r, newtup = gistSplit(r, rightbuf, rvectup, &nlen, giststate, (res && rvectup[nlen - 1] == itup[*len - 1]) ? res : NULL); ReleaseBuffer(rightbuf); - for( j=1; j<r->rd_att->natts; j++ ) - if ( (!isAttByVal(giststate,j)) && !v.spl_risnull[j] ) - pfree( DatumGetPointer(v.spl_rattr[j]) ); + for (j = 1; j < r->rd_att->natts; j++) + if ((!isAttByVal(giststate, j)) && !v.spl_risnull[j]) + pfree(DatumGetPointer(v.spl_rattr[j])); } else { @@ -1261,7 +1359,7 @@ gistSplit(Relation r, nlen = 1; newtup = (IndexTuple *) palloc(sizeof(IndexTuple) * 1); - newtup[0] = gistFormTuple( giststate, r, v.spl_rattr, v.spl_rattrsize, v.spl_risnull ); + newtup[0] = gistFormTuple(giststate, r, v.spl_rattr, v.spl_rattrsize, v.spl_risnull); ItemPointerSet(&(newtup[0]->t_tid), rbknum, 1); } @@ -1275,9 +1373,9 @@ gistSplit(Relation r, (res && lvectup[llen - 1] == itup[*len - 1]) ? res : NULL); ReleaseBuffer(leftbuf); - for( j=1; j<r->rd_att->natts; j++ ) - if ( (!isAttByVal(giststate,j)) && !v.spl_lisnull[j] ) - pfree( DatumGetPointer(v.spl_lattr[j]) ); + for (j = 1; j < r->rd_att->natts; j++) + if ((!isAttByVal(giststate, j)) && !v.spl_lisnull[j]) + pfree(DatumGetPointer(v.spl_lattr[j])); newtup = gistjoinvector(newtup, &nlen, lntup, llen); pfree(lntup); @@ -1297,7 +1395,7 @@ gistSplit(Relation r, nlen += 1; newtup = (IndexTuple *) repalloc((void *) newtup, sizeof(IndexTuple) * nlen); - newtup[nlen - 1] = gistFormTuple( giststate, r, v.spl_lattr, v.spl_lattrsize, v.spl_lisnull ); + newtup[nlen - 1] = gistFormTuple(giststate, r, v.spl_lattr, v.spl_lattrsize, v.spl_lisnull); ItemPointerSet(&(newtup[nlen - 1]->t_tid), lbknum, 1); } @@ -1359,47 +1457,56 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */ Datum datum; float usize; OffsetNumber which; - float sum_grow, which_grow[INDEX_MAX_KEYS]; + float sum_grow, + which_grow[INDEX_MAX_KEYS]; GISTENTRY entry, identry[INDEX_MAX_KEYS]; - bool IsNull, decompvec[INDEX_MAX_KEYS], isnull[INDEX_MAX_KEYS]; - int j; + bool IsNull, + decompvec[INDEX_MAX_KEYS], + isnull[INDEX_MAX_KEYS]; + int j; maxoff = PageGetMaxOffsetNumber(p); *which_grow = -1.0; which = -1; - sum_grow=1; - gistDeCompressAtt( giststate, r, - it, (Page) NULL, (OffsetNumber) 0, - identry, decompvec, isnull ); + sum_grow = 1; + gistDeCompressAtt(giststate, r, + it, (Page) NULL, (OffsetNumber) 0, + identry, decompvec, isnull); for (i = FirstOffsetNumber; i <= maxoff && sum_grow; i = OffsetNumberNext(i)) { - IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); - sum_grow=0; - for (j=0; j<r->rd_att->natts; j++) { - datum = index_getattr(itup, j+1, giststate->tupdesc, &IsNull); - gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull); - gistpenalty( giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize); - - if ( (!isAttByVal(giststate,j)) && entry.key != datum) + IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i)); + + sum_grow = 0; + for (j = 0; j < r->rd_att->natts; j++) + { + datum = index_getattr(itup, j + 1, giststate->tupdesc, &IsNull); + gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull); + gistpenalty(giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize); + + if ((!isAttByVal(giststate, j)) && entry.key != datum) pfree(DatumGetPointer(entry.key)); - if ( which_grow[j]<0 || usize < which_grow[j] ) { + if (which_grow[j] < 0 || usize < which_grow[j]) + { which = i; which_grow[j] = usize; - if ( j<r->rd_att->natts-1 && i==FirstOffsetNumber ) which_grow[j+1]=-1; - sum_grow += which_grow[j]; - } else if ( which_grow[j] == usize ) { + if (j < r->rd_att->natts - 1 && i == FirstOffsetNumber) + which_grow[j + 1] = -1; + sum_grow += which_grow[j]; + } + else if (which_grow[j] == usize) sum_grow += usize; - } else { - sum_grow=1; + else + { + sum_grow = 1; break; } } } - gistFreeAtt( r, identry, decompvec ); + gistFreeAtt(r, identry, decompvec); return which; } @@ -1434,7 +1541,7 @@ gistdelete(Relation r, ItemPointer tid) /* * Since GIST is not marked "amconcurrent" in pg_am, caller should - * have acquired exclusive lock on index relation. We need no locking + * have acquired exclusive lock on index relation. We need no locking * here. */ @@ -1468,7 +1575,7 @@ gistbulkdelete(PG_FUNCTION_ARGS) IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1); void *callback_state = (void *) PG_GETARG_POINTER(2); IndexBulkDeleteResult *result; - BlockNumber num_pages; + BlockNumber num_pages; double tuples_removed; double num_index_tuples; RetrieveIndexResult res; @@ -1479,7 +1586,7 @@ gistbulkdelete(PG_FUNCTION_ARGS) /* * Since GIST is not marked "amconcurrent" in pg_am, caller should - * have acquired exclusive lock on index relation. We need no locking + * have acquired exclusive lock on index relation. We need no locking * here. */ @@ -1542,7 +1649,7 @@ gistbulkdelete(PG_FUNCTION_ARGS) void initGISTstate(GISTSTATE *giststate, Relation index) { - int i; + int i; if (index->rd_att->natts > INDEX_MAX_KEYS) elog(ERROR, "initGISTstate: numberOfAttributes %d > %d", @@ -1553,31 +1660,32 @@ initGISTstate(GISTSTATE *giststate, Relation index) for (i = 0; i < index->rd_att->natts; i++) { fmgr_info_copy(&(giststate->consistentFn[i]), - index_getprocinfo(index, i+1, GIST_CONSISTENT_PROC), + index_getprocinfo(index, i + 1, GIST_CONSISTENT_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->unionFn[i]), - index_getprocinfo(index, i+1, GIST_UNION_PROC), + index_getprocinfo(index, i + 1, GIST_UNION_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->compressFn[i]), - index_getprocinfo(index, i+1, GIST_COMPRESS_PROC), + index_getprocinfo(index, i + 1, GIST_COMPRESS_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->decompressFn[i]), - index_getprocinfo(index, i+1, GIST_DECOMPRESS_PROC), + index_getprocinfo(index, i + 1, GIST_DECOMPRESS_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->penaltyFn[i]), - index_getprocinfo(index, i+1, GIST_PENALTY_PROC), + index_getprocinfo(index, i + 1, GIST_PENALTY_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->picksplitFn[i]), - index_getprocinfo(index, i+1, GIST_PICKSPLIT_PROC), + index_getprocinfo(index, i + 1, GIST_PICKSPLIT_PROC), CurrentMemoryContext); fmgr_info_copy(&(giststate->equalFn[i]), - index_getprocinfo(index, i+1, GIST_EQUAL_PROC), + index_getprocinfo(index, i + 1, GIST_EQUAL_PROC), CurrentMemoryContext); } } void -freeGISTstate(GISTSTATE *giststate) { +freeGISTstate(GISTSTATE *giststate) +{ /* no work */ } @@ -1592,13 +1700,14 @@ freeGISTstate(GISTSTATE *giststate) { static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t) { - bool IsNull; - Datum datum = index_getattr(t, 1, r->rd_att, &IsNull); + bool IsNull; + Datum datum = index_getattr(t, 1, r->rd_att, &IsNull); /* * If new entry fits in index tuple, copy it in. To avoid worrying - * about null-value bitmask, pass it off to the general index_formtuple - * routine if either the previous or new value is NULL. + * about null-value bitmask, pass it off to the general + * index_formtuple routine if either the previous or new value is + * NULL. */ if (!IsNull && DatumGetPointer(entry.key) != NULL && (Size) entry.bytes <= ATTSIZE(datum, r, 1, IsNull)) @@ -1638,7 +1747,7 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e, Datum k, Relation r, Page pg, OffsetNumber o, int b, bool l, bool isNull) { - if ( b && ! isNull ) + if (b && !isNull) { GISTENTRY *dep; @@ -1655,9 +1764,7 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e, } } else - { gistentryinit(*e, (Datum) 0, r, pg, o, 0, l); - } } @@ -1686,92 +1793,103 @@ gistcentryinit(GISTSTATE *giststate, int nkey, } } else - { gistentryinit(*e, (Datum) 0, r, pg, o, 0, l); - } } static IndexTuple -gistFormTuple( GISTSTATE *giststate, Relation r, - Datum attdata[], int datumsize[], bool isnull[] ) +gistFormTuple(GISTSTATE *giststate, Relation r, + Datum attdata[], int datumsize[], bool isnull[]) { IndexTuple tup; - char isnullchar[INDEX_MAX_KEYS]; - bool whatfree[INDEX_MAX_KEYS]; - GISTENTRY centry[INDEX_MAX_KEYS]; - Datum compatt[INDEX_MAX_KEYS]; - int j; - - for (j = 0; j < r->rd_att->natts; j++) { - if ( isnull[j] ) { + char isnullchar[INDEX_MAX_KEYS]; + bool whatfree[INDEX_MAX_KEYS]; + GISTENTRY centry[INDEX_MAX_KEYS]; + Datum compatt[INDEX_MAX_KEYS]; + int j; + + for (j = 0; j < r->rd_att->natts; j++) + { + if (isnull[j]) + { isnullchar[j] = 'n'; compatt[j] = (Datum) 0; whatfree[j] = FALSE; - } else { + } + else + { gistcentryinit(giststate, j, ¢ry[j], attdata[j], - (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, - datumsize[j], FALSE, FALSE); + (Relation) NULL, (Page) NULL, (OffsetNumber) NULL, + datumsize[j], FALSE, FALSE); isnullchar[j] = ' '; compatt[j] = centry[j].key; - if ( !isAttByVal(giststate,j) ) { + if (!isAttByVal(giststate, j)) + { whatfree[j] = TRUE; - if ( centry[j].key != attdata[j] ) + if (centry[j].key != attdata[j]) pfree(DatumGetPointer(attdata[j])); - } else + } + else whatfree[j] = FALSE; } } tup = (IndexTuple) index_formtuple(giststate->tupdesc, compatt, isnullchar); for (j = 0; j < r->rd_att->natts; j++) - if ( whatfree[j] ) pfree(DatumGetPointer(compatt[j])); + if (whatfree[j]) + pfree(DatumGetPointer(compatt[j])); - return tup; -} + return tup; +} static void -gistDeCompressAtt( GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p, - OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[] ) { - int i; - Datum datum; +gistDeCompressAtt(GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p, + OffsetNumber o, GISTENTRY attdata[], bool decompvec[], bool isnull[]) +{ + int i; + Datum datum; - for(i=0; i < r->rd_att->natts; i++ ) { - datum = index_getattr(tuple, i+1, giststate->tupdesc, &isnull[i]); + for (i = 0; i < r->rd_att->natts; i++) + { + datum = index_getattr(tuple, i + 1, giststate->tupdesc, &isnull[i]); gistdentryinit(giststate, i, &attdata[i], - datum, r, p, o, - ATTSIZE( datum, giststate->tupdesc, i+1, isnull[i] ), FALSE, isnull[i]); - if ( isAttByVal(giststate,i) ) + datum, r, p, o, + ATTSIZE(datum, giststate->tupdesc, i + 1, isnull[i]), FALSE, isnull[i]); + if (isAttByVal(giststate, i)) decompvec[i] = FALSE; - else { - if (attdata[i].key == datum || isnull[i] ) + else + { + if (attdata[i].key == datum || isnull[i]) decompvec[i] = FALSE; else decompvec[i] = TRUE; } } -} +} static void -gistFreeAtt( Relation r, GISTENTRY attdata[], bool decompvec[] ) { - int i; - for(i=0; i < r->rd_att->natts; i++ ) - if ( decompvec[i] ) - pfree( DatumGetPointer(attdata[i].key) ); +gistFreeAtt(Relation r, GISTENTRY attdata[], bool decompvec[]) +{ + int i; + + for (i = 0; i < r->rd_att->natts; i++) + if (decompvec[i]) + pfree(DatumGetPointer(attdata[i].key)); } static void -gistpenalty( GISTSTATE *giststate, int attno, - GISTENTRY *key1, bool isNull1, - GISTENTRY *key2, bool isNull2, float *penalty ){ - if ( giststate->penaltyFn[attno].fn_strict && ( isNull1 || isNull2 ) ) - *penalty=0.0; - else +gistpenalty(GISTSTATE *giststate, int attno, + GISTENTRY *key1, bool isNull1, + GISTENTRY *key2, bool isNull2, float *penalty) +{ + if (giststate->penaltyFn[attno].fn_strict && (isNull1 || isNull2)) + *penalty = 0.0; + else FunctionCall3(&giststate->penaltyFn[attno], - PointerGetDatum(key1), - PointerGetDatum(key2), - PointerGetDatum(penalty)); + PointerGetDatum(key1), + PointerGetDatum(key2), + PointerGetDatum(penalty)); } - + #ifdef GISTDEBUG static void gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff) @@ -1816,7 +1934,6 @@ gist_dumptree(Relation r, int level, BlockNumber blk, OffsetNumber coff) ReleaseBuffer(buffer); pfree(pred); } - #endif /* defined GISTDEBUG */ void diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index be2d749845..ed92258e62 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.30 2001/08/22 18:24:26 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.31 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -251,7 +251,7 @@ gistindex_keytest(IndexTuple tuple, if (key[0].sk_flags & SK_ISNULL) return false; */ - gistdentryinit(giststate, key[0].sk_attno-1, &de, + gistdentryinit(giststate, key[0].sk_attno - 1, &de, datum, r, p, offset, IndexTupleSize(tuple) - sizeof(IndexTupleData), FALSE, isNull); @@ -271,9 +271,9 @@ gistindex_keytest(IndexTuple tuple, ObjectIdGetDatum(key[0].sk_procedure)); } - if ( de.key != datum && ! isAttByVal( giststate, key[0].sk_attno-1 ) ) - if ( DatumGetPointer(de.key) != NULL ) - pfree( DatumGetPointer(de.key) ); + if (de.key != datum && !isAttByVal(giststate, key[0].sk_attno - 1)) + if (DatumGetPointer(de.key) != NULL) + pfree(DatumGetPointer(de.key)); if (DatumGetBool(test) == !!(key[0].sk_flags & SK_NEGATE)) return false; diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c index 2b65321b03..8623b8f643 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.39 2001/08/22 18:24:26 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.40 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -112,7 +112,7 @@ gistrescan(PG_FUNCTION_ARGS) s->keyData[i].sk_procedure = RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno, s->keyData[i].sk_procedure); - s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1]; + s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1]; } } else @@ -137,13 +137,13 @@ gistrescan(PG_FUNCTION_ARGS) /*---------- * s->keyData[i].sk_procedure = - * index_getprocid(s->relation, 1, GIST_CONSISTENT_PROC); + * index_getprocid(s->relation, 1, GIST_CONSISTENT_PROC); *---------- */ s->keyData[i].sk_procedure = RelationGetGISTStrategy(s->relation, s->keyData[i].sk_attno, s->keyData[i].sk_procedure); - s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno-1]; + s->keyData[i].sk_func = p->giststate->consistentFn[s->keyData[i].sk_attno - 1]; } } @@ -234,8 +234,8 @@ gistendscan(PG_FUNCTION_ARGS) { gistfreestack(p->s_stack); gistfreestack(p->s_markstk); - if ( p->giststate != NULL ) - freeGISTstate( p->giststate ); + if (p->giststate != NULL) + freeGISTstate(p->giststate); pfree(s->opaque); } @@ -383,7 +383,6 @@ adjustiptr(IndexScanDesc s, } else { - /* * remember that we're before the current * tuple diff --git a/src/backend/access/gist/giststrat.c b/src/backend/access/gist/giststrat.c index e0bae48a3c..db38191d6a 100644 --- a/src/backend/access/gist/giststrat.c +++ b/src/backend/access/gist/giststrat.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/Attic/giststrat.c,v 1.18 2001/10/25 05:49:20 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -121,5 +121,4 @@ RelationInvokeGISTStrategy(Relation r, return (RelationInvokeStrategy(r, &GISTEvaluationData, attnum, s, left, right)); } - #endif diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c index 9b0e6cf28e..177f3648f4 100644 --- a/src/backend/access/hash/hash.c +++ b/src/backend/access/hash/hash.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.52 2001/07/15 22:48:15 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.53 2001/10/25 05:49:20 momjian Exp $ * * NOTES * This file contains only the public interface routines. @@ -37,11 +37,11 @@ typedef struct } HashBuildState; static void hashbuildCallback(Relation index, - HeapTuple htup, - Datum *attdata, - char *nulls, - bool tupleIsAlive, - void *state); + HeapTuple htup, + Datum *attdata, + char *nulls, + bool tupleIsAlive, + void *state); /* @@ -80,7 +80,7 @@ hashbuild(PG_FUNCTION_ARGS) /* do the heap scan */ reltuples = IndexBuildHeapScan(heap, index, indexInfo, - hashbuildCallback, (void *) &buildstate); + hashbuildCallback, (void *) &buildstate); /* all done */ BuildingHash = false; @@ -121,7 +121,7 @@ hashbuildCallback(Relation index, bool tupleIsAlive, void *state) { - HashBuildState *buildstate = (HashBuildState *) state; + HashBuildState *buildstate = (HashBuildState *) state; IndexTuple itup; HashItem hitem; InsertIndexResult res; @@ -164,6 +164,7 @@ hashinsert(PG_FUNCTION_ARGS) Datum *datum = (Datum *) PG_GETARG_POINTER(1); char *nulls = (char *) PG_GETARG_POINTER(2); ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + #ifdef NOT_USED Relation heapRel = (Relation) PG_GETARG_POINTER(4); #endif @@ -176,14 +177,13 @@ hashinsert(PG_FUNCTION_ARGS) itup->t_tid = *ht_ctid; /* - * If the single index key is null, we don't insert it into the - * index. Hash tables support scans on '='. Relational algebra - * says that A = B returns null if either A or B is null. This - * means that no qualification used in an index scan could ever - * return true on a null attribute. It also means that indices - * can't be used by ISNULL or NOTNULL scans, but that's an - * artifact of the strategy map architecture chosen in 1986, not - * of the way nulls are handled here. + * If the single index key is null, we don't insert it into the index. + * Hash tables support scans on '='. Relational algebra says that A = + * B returns null if either A or B is null. This means that no + * qualification used in an index scan could ever return true on a + * null attribute. It also means that indices can't be used by ISNULL + * or NOTNULL scans, but that's an artifact of the strategy map + * architecture chosen in 1986, not of the way nulls are handled here. */ if (IndexTupleHasNulls(itup)) { @@ -262,7 +262,6 @@ hashrescan(PG_FUNCTION_ARGS) #ifdef NOT_USED /* XXX surely it's wrong to ignore this? */ bool fromEnd = PG_GETARG_BOOL(1); - #endif ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2); ItemPointer iptr; @@ -412,7 +411,7 @@ hashbulkdelete(PG_FUNCTION_ARGS) IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1); void *callback_state = (void *) PG_GETARG_POINTER(2); IndexBulkDeleteResult *result; - BlockNumber num_pages; + BlockNumber num_pages; double tuples_removed; double num_index_tuples; RetrieveIndexResult res; diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c index 5439dce214..2f99e7426d 100644 --- a/src/backend/access/hash/hashinsert.c +++ b/src/backend/access/hash/hashinsert.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.22 2001/03/07 21:20:26 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.23 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -133,13 +133,11 @@ _hash_insertonpg(Relation rel, while (PageGetFreeSpace(page) < itemsz) { - /* * no space on this page; check for an overflow page */ if (BlockNumberIsValid(pageopaque->hasho_nextblkno)) { - /* * ovfl page exists; go get it. if it doesn't have room, * we'll find out next pass through the loop test above. @@ -152,7 +150,6 @@ _hash_insertonpg(Relation rel, } else { - /* * we're at the end of the bucket chain and we haven't found a * page with enough room. allocate a new overflow page. @@ -184,7 +181,6 @@ _hash_insertonpg(Relation rel, if (res != NULL) { - /* * Increment the number of keys in the table. We switch lock * access type just for a moment to allow greater accessibility to diff --git a/src/backend/access/hash/hashovfl.c b/src/backend/access/hash/hashovfl.c index c9fb065dbd..e41c1bd0a3 100644 --- a/src/backend/access/hash/hashovfl.c +++ b/src/backend/access/hash/hashovfl.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.30 2001/07/15 22:48:15 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.31 2001/10/25 05:49:21 momjian Exp $ * * NOTES * Overflow pages look like ordinary relation pages. @@ -208,7 +208,6 @@ _hash_getovfladdr(Relation rel, Buffer *metabufp) } else { - /* * Free_bit addresses the last used bit. Bump it to address the * first available bit. diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c index b8c520e3c0..0fff5a11e6 100644 --- a/src/backend/access/hash/hashpage.c +++ b/src/backend/access/hash/hashpage.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.32 2001/07/15 22:48:15 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.33 2001/10/25 05:49:21 momjian Exp $ * * NOTES * Postgres hash pages look like ordinary relation pages. The opaque @@ -50,7 +50,7 @@ static void _hash_splitpage(Relation rel, Buffer metabuf, Bucket obucket, Bucket * system catalogs anyway. * * Note that our page locks are actual lockmanager locks, not buffer - * locks (as are used by btree, for example). This is a good idea because + * locks (as are used by btree, for example). This is a good idea because * the algorithms are not deadlock-free, and we'd better be able to detect * and recover from deadlocks. * @@ -325,7 +325,7 @@ _hash_setpagelock(Relation rel, { switch (access) { - case HASH_WRITE: + case HASH_WRITE: LockPage(rel, blkno, ExclusiveLock); break; case HASH_READ: @@ -349,7 +349,7 @@ _hash_unsetpagelock(Relation rel, { switch (access) { - case HASH_WRITE: + case HASH_WRITE: UnlockPage(rel, blkno, ExclusiveLock); break; case HASH_READ: @@ -369,7 +369,7 @@ _hash_unsetpagelock(Relation rel, * It is safe to delete an item after acquiring a regular WRITE lock on * the page, because no other backend can hold a READ lock on the page, * and that means no other backend currently has an indexscan stopped on - * any item of the item being deleted. Our own backend might have such + * any item of the item being deleted. Our own backend might have such * an indexscan (in fact *will*, since that's how VACUUM found the item * in the first place), but _hash_adjscans will fix the scan position. */ @@ -532,7 +532,6 @@ _hash_splitpage(Relation rel, _hash_relbuf(rel, obuf, HASH_WRITE); if (!BlockNumberIsValid(oblkno)) { - /* * the old bucket is completely empty; of course, the new * bucket will be as well, but since it's a base bucket page @@ -559,7 +558,6 @@ _hash_splitpage(Relation rel, omaxoffnum = PageGetMaxOffsetNumber(opage); for (;;) { - /* * at each iteration through this loop, each of these variables * should be up-to-date: obuf opage oopaque ooffnum omaxoffnum @@ -572,7 +570,6 @@ _hash_splitpage(Relation rel, oblkno = oopaque->hasho_nextblkno; if (BlockNumberIsValid(oblkno)) { - /* * we ran out of tuples on this particular page, but we * have more overflow pages; re-init values. @@ -594,7 +591,6 @@ _hash_splitpage(Relation rel, } else { - /* * we're at the end of the bucket chain, so now we're * really done with everything. before quitting, call @@ -618,7 +614,6 @@ _hash_splitpage(Relation rel, if (bucket == nbucket) { - /* * insert the tuple into the new bucket. if it doesn't fit on * the current page in the new bucket, we must allocate a new @@ -695,7 +690,6 @@ _hash_splitpage(Relation rel, } else { - /* * the tuple stays on this page. we didn't move anything, so * we didn't delete anything and therefore we don't have to diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c index 27ca030118..6ea643dcaf 100644 --- a/src/backend/access/hash/hashsearch.c +++ b/src/backend/access/hash/hashsearch.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.26 2001/03/23 04:49:51 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.27 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -36,7 +36,6 @@ _hash_search(Relation rel, if (scankey == (ScanKey) NULL || (keyDatum = scankey[0].sk_argument) == (Datum) NULL) { - /* * If the scankey argument is NULL, all tuples will satisfy the * scan so we start the scan at the first bucket (bucket 0). diff --git a/src/backend/access/hash/hashstrat.c b/src/backend/access/hash/hashstrat.c index fc5df2372d..a765c2e2b1 100644 --- a/src/backend/access/hash/hashstrat.c +++ b/src/backend/access/hash/hashstrat.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.18 2001/05/30 19:53:40 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.19 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -46,7 +46,6 @@ static StrategyEvaluationData HTEvaluationData = { (StrategyTransformMap) HTNegateCommute, HTEvaluationExpressions }; - #endif /* ---------------------------------------------------------------- @@ -68,7 +67,6 @@ _hash_getstrat(Relation rel, return strat; } - #endif #ifdef NOT_USED @@ -82,5 +80,4 @@ _hash_invokestrat(Relation rel, return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat, left, right)); } - #endif diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index c64a19faa6..f73ca50285 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.125 2001/08/23 23:06:37 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.126 2001/10/25 05:49:21 momjian Exp $ * * * INTERFACE ROUTINES @@ -116,8 +116,8 @@ heapgettup(Relation relation, { ItemId lpp; Page dp; - BlockNumber page; - BlockNumber pages; + BlockNumber page; + BlockNumber pages; int lines; OffsetNumber lineoff; int linesleft; @@ -350,7 +350,7 @@ heapgettup(Relation relation, /* * return NULL if we've exhausted all the pages */ - if ((dir < 0) ? (page == 0) : (page+1 >= pages)) + if ((dir < 0) ? (page == 0) : (page + 1 >= pages)) { if (BufferIsValid(*buffer)) ReleaseBuffer(*buffer); @@ -429,9 +429,8 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, ( (Datum) NULL ) - ); + ); } - #endif /* defined(DISABLE_COMPLEX_MACRO) */ @@ -1045,12 +1044,13 @@ heap_insert(Relation relation, HeapTuple tup) if (relation->rd_rel->relhasoids) { /* - * If the object id of this tuple has already been assigned, trust the - * caller. There are a couple of ways this can happen. At initial db - * creation, the backend program sets oids for tuples. When we define - * an index, we set the oid. Finally, in the future, we may allow - * users to set their own object ids in order to support a persistent - * object store (objects need to contain pointers to one another). + * If the object id of this tuple has already been assigned, trust + * the caller. There are a couple of ways this can happen. At + * initial db creation, the backend program sets oids for tuples. + * When we define an index, we set the oid. Finally, in the + * future, we may allow users to set their own object ids in order + * to support a persistent object store (objects need to contain + * pointers to one another). */ if (!OidIsValid(tup->t_data->t_oid)) tup->t_data->t_oid = newoid(); @@ -1478,21 +1478,22 @@ l2: } /* - * Now, do we need a new page for the tuple, or not? This is a bit - * tricky since someone else could have added tuples to the page - * while we weren't looking. We have to recheck the available space - * after reacquiring the buffer lock. But don't bother to do that - * if the former amount of free space is still not enough; it's - * unlikely there's more free now than before. + * Now, do we need a new page for the tuple, or not? This is a + * bit tricky since someone else could have added tuples to the + * page while we weren't looking. We have to recheck the + * available space after reacquiring the buffer lock. But don't + * bother to do that if the former amount of free space is still + * not enough; it's unlikely there's more free now than before. * * What's more, if we need to get a new page, we will need to acquire - * buffer locks on both old and new pages. To avoid deadlock against - * some other backend trying to get the same two locks in the other - * order, we must be consistent about the order we get the locks in. - * We use the rule "lock the lower-numbered page of the relation - * first". To implement this, we must do RelationGetBufferForTuple - * while not holding the lock on the old page, and we must rely on it - * to get the locks on both pages in the correct order. + * buffer locks on both old and new pages. To avoid deadlock + * against some other backend trying to get the same two locks in + * the other order, we must be consistent about the order we get + * the locks in. We use the rule "lock the lower-numbered page of + * the relation first". To implement this, we must do + * RelationGetBufferForTuple while not holding the lock on the old + * page, and we must rely on it to get the locks on both pages in + * the correct order. */ if (newtupsize > pagefree) { @@ -1510,8 +1511,8 @@ l2: { /* * Rats, it doesn't fit anymore. We must now unlock and - * relock to avoid deadlock. Fortunately, this path should - * seldom be taken. + * relock to avoid deadlock. Fortunately, this path + * should seldom be taken. */ LockBuffer(buffer, BUFFER_LOCK_UNLOCK); newbuf = RelationGetBufferForTuple(relation, newtup->t_len, @@ -1534,9 +1535,9 @@ l2: pgstat_count_heap_update(&relation->pgstat_info); /* - * At this point newbuf and buffer are both pinned and locked, - * and newbuf has enough space for the new tuple. If they are - * the same buffer, only one pin is held. + * At this point newbuf and buffer are both pinned and locked, and + * newbuf has enough space for the new tuple. If they are the same + * buffer, only one pin is held. */ /* NO ELOG(ERROR) from here till changes are logged */ @@ -1865,12 +1866,14 @@ log_heap_update(Relation reln, Buffer oldbuf, ItemPointerData from, * Note: xlhdr is declared to have adequate size and correct alignment * for an xl_heap_header. However the two tids, if present at all, * will be packed in with no wasted space after the xl_heap_header; - * they aren't necessarily aligned as implied by this struct declaration. + * they aren't necessarily aligned as implied by this struct + * declaration. */ - struct { - xl_heap_header hdr; - TransactionId tid1; - TransactionId tid2; + struct + { + xl_heap_header hdr; + TransactionId tid1; + TransactionId tid2; } xlhdr; int hsize = SizeOfHeapHeader; xl_heap_update xlrec; @@ -1972,7 +1975,7 @@ heap_xlog_clean(bool redo, XLogRecPtr lsn, XLogRecord *record) if (record->xl_len > SizeOfHeapClean) { - OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)]; + OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)]; OffsetNumber *unused = unbuf; char *unend; ItemId lp; @@ -2084,9 +2087,10 @@ heap_xlog_insert(bool redo, XLogRecPtr lsn, XLogRecord *record) if (redo) { - struct { + struct + { HeapTupleHeaderData hdr; - char data[MaxTupleSize]; + char data[MaxTupleSize]; } tbuf; HeapTupleHeader htup; xl_heap_header xlhdr; @@ -2251,9 +2255,10 @@ newsame:; if (redo) { - struct { + struct + { HeapTupleHeaderData hdr; - char data[MaxTupleSize]; + char data[MaxTupleSize]; } tbuf; xl_heap_header xlhdr; int hsize; diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c index 81a559b37e..44ecb3c8c7 100644 --- a/src/backend/access/heap/hio.c +++ b/src/backend/access/heap/hio.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Id: hio.c,v 1.42 2001/07/13 22:52:58 tgl Exp $ + * $Id: hio.c,v 1.43 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -83,7 +83,7 @@ RelationPutHeapTuple(Relation relation, * NOTE: it is unlikely, but not quite impossible, for otherBuffer to be the * same buffer we select for insertion of the new tuple (this could only * happen if space is freed in that page after heap_update finds there's not - * enough there). In that case, the page will be pinned and locked only once. + * enough there). In that case, the page will be pinned and locked only once. * * Note that we use LockPage(rel, 0) to lock relation for extension. * We can do this as long as in all other places we use page-level locking @@ -115,17 +115,19 @@ RelationGetBufferForTuple(Relation relation, Size len, if (otherBuffer != InvalidBuffer) otherBlock = BufferGetBlockNumber(otherBuffer); else - otherBlock = InvalidBlockNumber; /* just to keep compiler quiet */ + otherBlock = InvalidBlockNumber; /* just to keep compiler + * quiet */ /* * We first try to put the tuple on the same page we last inserted a * tuple on, as cached in the relcache entry. If that doesn't work, - * we ask the shared Free Space Map to locate a suitable page. Since + * we ask the shared Free Space Map to locate a suitable page. Since * the FSM's info might be out of date, we have to be prepared to loop * around and retry multiple times. (To insure this isn't an infinite - * loop, we must update the FSM with the correct amount of free space on - * each page that proves not to be suitable.) If the FSM has no record of - * a page with enough free space, we give up and extend the relation. + * loop, we must update the FSM with the correct amount of free space + * on each page that proves not to be suitable.) If the FSM has no + * record of a page with enough free space, we give up and extend the + * relation. */ targetBlock = relation->rd_targblock; @@ -137,6 +139,7 @@ RelationGetBufferForTuple(Relation relation, Size len, * target. */ targetBlock = GetPageWithFreeSpace(&relation->rd_node, len); + /* * If the FSM knows nothing of the rel, try the last page before * we give up and extend. This avoids one-tuple-per-page syndrome @@ -144,7 +147,7 @@ RelationGetBufferForTuple(Relation relation, Size len, */ if (targetBlock == InvalidBlockNumber) { - BlockNumber nblocks = RelationGetNumberOfBlocks(relation); + BlockNumber nblocks = RelationGetNumberOfBlocks(relation); if (nblocks > 0) targetBlock = nblocks - 1; @@ -154,9 +157,9 @@ RelationGetBufferForTuple(Relation relation, Size len, while (targetBlock != InvalidBlockNumber) { /* - * Read and exclusive-lock the target block, as well as the - * other block if one was given, taking suitable care with - * lock ordering and the possibility they are the same block. + * Read and exclusive-lock the target block, as well as the other + * block if one was given, taking suitable care with lock ordering + * and the possibility they are the same block. */ if (otherBuffer == InvalidBuffer) { @@ -184,9 +187,10 @@ RelationGetBufferForTuple(Relation relation, Size len, LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE); LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE); } + /* - * Now we can check to see if there's enough free space here. - * If so, we're done. + * Now we can check to see if there's enough free space here. If + * so, we're done. */ pageHeader = (Page) BufferGetPage(buffer); pageFreeSpace = PageGetFreeSpace(pageHeader); @@ -196,22 +200,22 @@ RelationGetBufferForTuple(Relation relation, Size len, relation->rd_targblock = targetBlock; return buffer; } + /* - * Not enough space, so we must give up our page locks and - * pin (if any) and prepare to look elsewhere. We don't care - * which order we unlock the two buffers in, so this can be - * slightly simpler than the code above. + * Not enough space, so we must give up our page locks and pin (if + * any) and prepare to look elsewhere. We don't care which order + * we unlock the two buffers in, so this can be slightly simpler + * than the code above. */ LockBuffer(buffer, BUFFER_LOCK_UNLOCK); if (otherBuffer == InvalidBuffer) - { ReleaseBuffer(buffer); - } else if (otherBlock != targetBlock) { LockBuffer(otherBuffer, BUFFER_LOCK_UNLOCK); ReleaseBuffer(buffer); } + /* * Update FSM as to condition of this page, and ask for another * page to try. @@ -225,9 +229,9 @@ RelationGetBufferForTuple(Relation relation, Size len, /* * Have to extend the relation. * - * We have to use a lock to ensure no one else is extending the - * rel at the same time, else we will both try to initialize the - * same new page. + * We have to use a lock to ensure no one else is extending the rel at + * the same time, else we will both try to initialize the same new + * page. */ if (!relation->rd_myxactonly) LockPage(relation, 0, ExclusiveLock); @@ -236,20 +240,21 @@ RelationGetBufferForTuple(Relation relation, Size len, * XXX This does an lseek - rather expensive - but at the moment it is * the only way to accurately determine how many blocks are in a * relation. Is it worth keeping an accurate file length in shared - * memory someplace, rather than relying on the kernel to do it for us? + * memory someplace, rather than relying on the kernel to do it for + * us? */ buffer = ReadBuffer(relation, P_NEW); /* - * Release the file-extension lock; it's now OK for someone else - * to extend the relation some more. + * Release the file-extension lock; it's now OK for someone else to + * extend the relation some more. */ if (!relation->rd_myxactonly) UnlockPage(relation, 0, ExclusiveLock); /* - * We can be certain that locking the otherBuffer first is OK, - * since it must have a lower page number. + * We can be certain that locking the otherBuffer first is OK, since + * it must have a lower page number. */ if (otherBuffer != InvalidBuffer) LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE); @@ -273,7 +278,7 @@ RelationGetBufferForTuple(Relation relation, Size len, * * XXX should we enter the new page into the free space map immediately, * or just keep it for this backend's exclusive use in the short run - * (until VACUUM sees it)? Seems to depend on whether you expect the + * (until VACUUM sees it)? Seems to depend on whether you expect the * current backend to make more insertions or not, which is probably a * good bet most of the time. So for now, don't add it to FSM yet. */ diff --git a/src/backend/access/heap/stats.c b/src/backend/access/heap/stats.c index 6dabf49e34..6f5dfbea14 100644 --- a/src/backend/access/heap/stats.c +++ b/src/backend/access/heap/stats.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.24 2001/03/22 06:16:07 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.25 2001/10/25 05:49:21 momjian Exp $ * * NOTES * initam should be moved someplace else. @@ -164,7 +164,6 @@ ResetHeapAccessStatistics() time(&stats->local_reset_timestamp); time(&stats->last_request_timestamp); } - #endif #ifdef NOT_USED @@ -200,7 +199,6 @@ GetHeapAccessStatistics() return stats; } - #endif #ifdef NOT_USED @@ -211,7 +209,6 @@ GetHeapAccessStatistics() void PrintHeapAccessStatistics(HeapAccessStatistics stats) { - /* * return nothing if stats aren't valid */ @@ -302,7 +299,6 @@ PrintHeapAccessStatistics(HeapAccessStatistics stats) printf("\n"); } - #endif #ifdef NOT_USED @@ -317,7 +313,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats) if (stats != NULL) pfree(stats); } - #endif /* ---------------------------------------------------------------- @@ -331,7 +326,6 @@ PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats) void initam(void) { - /* * initialize heap statistics. */ diff --git a/src/backend/access/heap/tuptoaster.c b/src/backend/access/heap/tuptoaster.c index dd881ca5f0..5ddefde8c7 100644 --- a/src/backend/access/heap/tuptoaster.c +++ b/src/backend/access/heap/tuptoaster.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.24 2001/08/10 18:57:33 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/heap/tuptoaster.c,v 1.25 2001/10/25 05:49:21 momjian Exp $ * * * INTERFACE ROUTINES @@ -74,14 +74,13 @@ heap_tuple_toast_attrs(Relation rel, HeapTuple newtup, HeapTuple oldtup) * external storage (possibly still in compressed format). * ---------- */ -varattrib * +varattrib * heap_tuple_fetch_attr(varattrib *attr) { varattrib *result; if (VARATT_IS_EXTERNAL(attr)) { - /* * This is an external stored plain value */ @@ -89,7 +88,6 @@ heap_tuple_fetch_attr(varattrib *attr) } else { - /* * This is a plain value inside of the main tuple - why am I * called? @@ -108,7 +106,7 @@ heap_tuple_fetch_attr(varattrib *attr) * or external storage. * ---------- */ -varattrib * +varattrib * heap_tuple_untoast_attr(varattrib *attr) { varattrib *result; @@ -135,7 +133,6 @@ heap_tuple_untoast_attr(varattrib *attr) } else { - /* * This is an external stored plain value */ @@ -144,7 +141,6 @@ heap_tuple_untoast_attr(varattrib *attr) } else if (VARATT_IS_COMPRESSED(attr)) { - /* * This is a compressed value inside of the main tuple */ @@ -181,8 +177,8 @@ toast_raw_datum_size(Datum value) if (VARATT_IS_COMPRESSED(attr)) { /* - * va_rawsize shows the original data size, whether the datum - * is external or not. + * va_rawsize shows the original data size, whether the datum is + * external or not. */ result = attr->va_content.va_compressed.va_rawsize + VARHDRSZ; } @@ -301,7 +297,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) if (oldtup != NULL) { - /* * For UPDATE get the old and new values of this attribute */ @@ -324,7 +319,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) old_value->va_content.va_external.va_toastrelid != new_value->va_content.va_external.va_toastrelid) { - /* * The old external store value isn't needed any more * after the update @@ -334,7 +328,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) } else { - /* * This attribute isn't changed by this update so we * reuse the original reference to the old value in @@ -348,7 +341,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) } else { - /* * For INSERT simply get the new value */ @@ -372,7 +364,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) */ if (att[i]->attlen == -1) { - /* * If the table's attribute says PLAIN always, force it so. */ @@ -400,7 +391,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) } else { - /* * Not a variable size attribute, plain storage always */ @@ -475,7 +465,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) } else { - /* * incompressible data, ignore on subsequent compression * passes @@ -588,7 +577,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup) } else { - /* * incompressible data, ignore on subsequent compression * passes @@ -776,9 +764,10 @@ toast_save_datum(Relation rel, Datum value) Datum t_values[3]; char t_nulls[3]; varattrib *result; - struct { - struct varlena hdr; - char data[TOAST_MAX_CHUNK_SIZE]; + struct + { + struct varlena hdr; + char data[TOAST_MAX_CHUNK_SIZE]; } chunk_data; int32 chunk_size; int32 chunk_seq = 0; @@ -851,12 +840,12 @@ toast_save_datum(Relation rel, Datum value) heap_insert(toastrel, toasttup); /* - * Create the index entry. We cheat a little here by not using + * Create the index entry. We cheat a little here by not using * FormIndexDatum: this relies on the knowledge that the index * columns are the same as the initial columns of the table. * - * Note also that there had better not be any user-created index - * on the TOAST table, since we don't bother to update anything else. + * Note also that there had better not be any user-created index on + * the TOAST table, since we don't bother to update anything else. */ idxres = index_insert(toastidx, t_values, t_nulls, &(toasttup->t_self), @@ -916,8 +905,8 @@ toast_delete_datum(Relation rel, Datum value) toastidx = index_open(toastrel->rd_rel->reltoastidxid); /* - * Setup a scan key to fetch from the index by va_valueid - * (we don't particularly care whether we see them in sequence or not) + * Setup a scan key to fetch from the index by va_valueid (we don't + * particularly care whether we see them in sequence or not) */ ScanKeyEntryInitialize(&toastkey, (bits16) 0, @@ -1096,5 +1085,4 @@ toast_fetch_datum(varattrib *attr) return result; } - #endif /* TUPLE_TOASTER_ACTIVE */ diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c index 1115fb828b..b03690257c 100644 --- a/src/backend/access/index/genam.c +++ b/src/backend/access/index/genam.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.28 2001/06/22 19:16:21 wieck Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.29 2001/10/25 05:49:21 momjian Exp $ * * NOTES * many of the old access method routines have been turned into @@ -240,5 +240,4 @@ IndexScanRestorePosition(IndexScanDesc scan) scan->flags = 0x0; /* XXX should have a symbolic name */ } - #endif diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index 2a1d3294dd..8e1d5b8733 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.53 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.54 2001/10/25 05:49:21 momjian Exp $ * * INTERFACE ROUTINES * index_open - open an index relation by relationId @@ -241,9 +241,9 @@ index_beginscan(Relation relation, pgstat_initstats(&scan->xs_pgstat_info, relation); /* - * We want to look up the amgettuple procedure just once per scan, - * not once per index_getnext call. So do it here and save - * the fmgr info result in the scan descriptor. + * We want to look up the amgettuple procedure just once per scan, not + * once per index_getnext call. So do it here and save the fmgr info + * result in the scan descriptor. */ GET_SCAN_PROCEDURE(beginscan, amgettuple); fmgr_info(procedure, &scan->fn_getnext); @@ -342,8 +342,8 @@ index_getnext(IndexScanDesc scan, pgstat_count_index_scan(&scan->xs_pgstat_info); /* - * have the am's gettuple proc do all the work. - * index_beginscan already set up fn_getnext. + * have the am's gettuple proc do all the work. index_beginscan + * already set up fn_getnext. */ result = (RetrieveIndexResult) DatumGetPointer(FunctionCall2(&scan->fn_getnext, @@ -378,8 +378,8 @@ index_bulk_delete(Relation relation, result = (IndexBulkDeleteResult *) DatumGetPointer(OidFunctionCall3(procedure, PointerGetDatum(relation), - PointerGetDatum((Pointer) callback), - PointerGetDatum(callback_state))); + PointerGetDatum((Pointer) callback), + PointerGetDatum(callback_state))); return result; } diff --git a/src/backend/access/index/istrat.c b/src/backend/access/index/istrat.c index 568581fc18..88d1757e4c 100644 --- a/src/backend/access/index/istrat.c +++ b/src/backend/access/index/istrat.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.53 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.54 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -120,9 +120,9 @@ StrategyOperatorIsValid(StrategyOperator operator, StrategyNumber maxStrategy) { return (bool) - (PointerIsValid(operator) && - StrategyNumberIsInBounds(operator->strategy, maxStrategy) && - !(operator->flags & ~(SK_NEGATE | SK_COMMUTE))); + (PointerIsValid(operator) && + StrategyNumberIsInBounds(operator->strategy, maxStrategy) && + !(operator->flags & ~(SK_NEGATE | SK_COMMUTE))); } /* ---------------- @@ -196,7 +196,6 @@ StrategyEvaluationIsValid(StrategyEvaluation evaluation) } return true; } - #endif #ifdef NOT_USED @@ -255,7 +254,6 @@ StrategyTermEvaluate(StrategyTerm term, return result; } - #endif /* ---------------- @@ -453,7 +451,6 @@ RelationInvokeStrategy(Relation relation, /* not reached, just to make compiler happy */ return FALSE; } - #endif /* ---------------- @@ -552,7 +549,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy, { for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++) { - Oid opclass = operatorClassObjectId[attIndex]; + Oid opclass = operatorClassObjectId[attIndex]; RegProcedure *loc; StrategyNumber support; @@ -562,7 +559,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy, { tuple = SearchSysCache(AMPROCNUM, ObjectIdGetDatum(opclass), - Int16GetDatum(support+1), + Int16GetDatum(support + 1), 0, 0); if (HeapTupleIsValid(tuple)) { @@ -581,7 +578,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy, /* Now load the strategy information for the index operators */ for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++) { - Oid opclass = operatorClassObjectId[attIndex]; + Oid opclass = operatorClassObjectId[attIndex]; StrategyMap map; StrategyNumber strategy; @@ -591,7 +588,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy, for (strategy = 1; strategy <= maxStrategyNumber; strategy++) { - ScanKey mapentry = StrategyMapGetScanKeyEntry(map, strategy); + ScanKey mapentry = StrategyMapGetScanKeyEntry(map, strategy); tuple = SearchSysCache(AMOPSTRATEGY, ObjectIdGetDatum(opclass), @@ -643,5 +640,4 @@ IndexStrategyDisplay(IndexStrategy indexStrategy, } } } - #endif /* defined(ISTRATDEBUG) */ diff --git a/src/backend/access/nbtree/nbtcompare.c b/src/backend/access/nbtree/nbtcompare.c index b1affe2018..a4ba587053 100644 --- a/src/backend/access/nbtree/nbtcompare.c +++ b/src/backend/access/nbtree/nbtcompare.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.42 2001/05/03 19:00:36 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.43 2001/10/25 05:49:21 momjian Exp $ * * NOTES * @@ -25,7 +25,7 @@ * NOTE: although any negative int32 is acceptable for reporting "<", * and any positive int32 is acceptable for reporting ">", routines * that work on 32-bit or wider datatypes can't just return "a - b". - * That could overflow and give the wrong answer. Also, one should not + * That could overflow and give the wrong answer. Also, one should not * return INT_MIN to report "<", since some callers will negate the result. * * NOTE: it is critical that the comparison function impose a total order diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c index bc250cd48e..1d3a7e82ab 100644 --- a/src/backend/access/nbtree/nbtinsert.c +++ b/src/backend/access/nbtree/nbtinsert.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.86 2001/09/29 23:49:51 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.87 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -1100,7 +1100,7 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright, * If we are not on the leaf level, we will be able to discard the key * data from the first item that winds up on the right page. */ - if (! state->is_leaf) + if (!state->is_leaf) rightfree += (int) firstrightitemsz - (int) (MAXALIGN(sizeof(BTItemData)) + sizeof(ItemIdData)); @@ -1115,7 +1115,8 @@ _bt_checksplitloc(FindSplitData *state, OffsetNumber firstright, { /* * On a rightmost page, try to equalize right free space with - * twice the left free space. See comments for _bt_findsplitloc. + * twice the left free space. See comments for + * _bt_findsplitloc. */ delta = (2 * leftfree) - rightfree; } @@ -1618,7 +1619,6 @@ _bt_fixlevel(Relation rel, Buffer buf, BlockNumber limit) for (;;) { - /* * Read up to 2 more child pages and look for pointers to them in * *saved* parent page diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c index 376274c562..2e6eb20cd4 100644 --- a/src/backend/access/nbtree/nbtpage.c +++ b/src/backend/access/nbtree/nbtpage.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.53 2001/07/15 22:48:16 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.54 2001/10/25 05:49:21 momjian Exp $ * * NOTES * Postgres btree pages look like ordinary relation pages. The opaque @@ -153,7 +153,6 @@ _bt_getroot(Relation rel, int access) */ if (metad->btm_root == P_NONE) { - /* * Get, initialize, write, and leave a lock of the appropriate * type on the new root page. Since this is the first page in @@ -209,7 +208,6 @@ _bt_getroot(Relation rel, int access) } else { - /* * Metadata initialized by someone else. In order to * guarantee no deadlocks, we have to release the metadata @@ -237,7 +235,6 @@ _bt_getroot(Relation rel, int access) if (!P_ISROOT(rootopaque)) { - /* * It happened, but if root page splitter failed to create new * root page then we'll go in loop trying to call _bt_getroot @@ -402,7 +399,6 @@ _bt_wrtnorelbuf(Relation rel, Buffer buf) void _bt_pageinit(Page page, Size size) { - /* * Cargo_cult programming -- don't really need this to be zero, but * creating new pages is an infrequent occurrence and it makes me feel diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index b142645624..e49f06b1c3 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -12,7 +12,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.82 2001/07/15 22:48:16 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.83 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -37,6 +37,7 @@ typedef struct bool haveDead; Relation heapRel; BTSpool *spool; + /* * spool2 is needed only when the index is an unique index. Dead * tuples are put into spool2 instead of spool in order to avoid @@ -58,11 +59,11 @@ bool FixBTree = true; static void _bt_restscan(IndexScanDesc scan); static void btbuildCallback(Relation index, - HeapTuple htup, - Datum *attdata, - char *nulls, - bool tupleIsAlive, - void *state); + HeapTuple htup, + Datum *attdata, + char *nulls, + bool tupleIsAlive, + void *state); /* @@ -134,6 +135,7 @@ btbuild(PG_FUNCTION_ARGS) if (buildstate.usefast) { buildstate.spool = _bt_spoolinit(index, indexInfo->ii_Unique); + /* * Different from spool, the uniqueness isn't checked for spool2. */ @@ -214,7 +216,7 @@ btbuildCallback(Relation index, bool tupleIsAlive, void *state) { - BTBuildState *buildstate = (BTBuildState *) state; + BTBuildState *buildstate = (BTBuildState *) state; IndexTuple itup; BTItem btitem; InsertIndexResult res; @@ -226,9 +228,9 @@ btbuildCallback(Relation index, btitem = _bt_formitem(itup); /* - * if we are doing bottom-up btree build, we insert the index into - * a spool file for subsequent processing. otherwise, we insert - * into the btree. + * if we are doing bottom-up btree build, we insert the index into a + * spool file for subsequent processing. otherwise, we insert into + * the btree. */ if (buildstate->usefast) { @@ -305,7 +307,6 @@ btgettuple(PG_FUNCTION_ARGS) if (ItemPointerIsValid(&(scan->currentItemData))) { - /* * Restore scan position using heap TID returned by previous call * to btgettuple(). _bt_restscan() re-grabs the read lock on the @@ -321,7 +322,7 @@ btgettuple(PG_FUNCTION_ARGS) * Save heap TID to use it in _bt_restscan. Then release the read * lock on the buffer so that we aren't blocking other backends. * - * NOTE: we do keep the pin on the buffer! This is essential to ensure + * NOTE: we do keep the pin on the buffer! This is essential to ensure * that someone else doesn't delete the index entry we are stopped on. */ if (res) @@ -362,7 +363,6 @@ btrescan(PG_FUNCTION_ARGS) #ifdef NOT_USED /* XXX surely it's wrong to ignore this? */ bool fromEnd = PG_GETARG_BOOL(1); - #endif ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2); ItemPointer iptr; @@ -547,7 +547,7 @@ btbulkdelete(PG_FUNCTION_ARGS) IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1); void *callback_state = (void *) PG_GETARG_POINTER(2); IndexBulkDeleteResult *result; - BlockNumber num_pages; + BlockNumber num_pages; double tuples_removed; double num_index_tuples; RetrieveIndexResult res; @@ -559,15 +559,16 @@ btbulkdelete(PG_FUNCTION_ARGS) num_index_tuples = 0; /* - * We use a standard IndexScanDesc scan object, but to speed up the loop, - * we skip most of the wrapper layers of index_getnext and instead call - * _bt_step directly. This implies holding buffer lock on a target page - * throughout the loop over the page's tuples. Initially, we have a read - * lock acquired by _bt_step when we stepped onto the page. If we find - * a tuple we need to delete, we trade in the read lock for an exclusive - * write lock; after that, we hold the write lock until we step off the - * page (fortunately, _bt_relbuf doesn't care which kind of lock it's - * releasing). This should minimize the amount of work needed per page. + * We use a standard IndexScanDesc scan object, but to speed up the + * loop, we skip most of the wrapper layers of index_getnext and + * instead call _bt_step directly. This implies holding buffer lock + * on a target page throughout the loop over the page's tuples. + * Initially, we have a read lock acquired by _bt_step when we stepped + * onto the page. If we find a tuple we need to delete, we trade in + * the read lock for an exclusive write lock; after that, we hold the + * write lock until we step off the page (fortunately, _bt_relbuf + * doesn't care which kind of lock it's releasing). This should + * minimize the amount of work needed per page. */ scan = index_beginscan(rel, false, 0, (ScanKey) NULL); so = (BTScanOpaque) scan->opaque; @@ -579,7 +580,7 @@ btbulkdelete(PG_FUNCTION_ARGS) if (res != NULL) { Buffer buf; - BlockNumber lockedBlock = InvalidBlockNumber; + BlockNumber lockedBlock = InvalidBlockNumber; pfree(res); /* we have the buffer pinned and locked */ @@ -589,11 +590,11 @@ btbulkdelete(PG_FUNCTION_ARGS) do { Page page; - BlockNumber blkno; + BlockNumber blkno; OffsetNumber offnum; BTItem btitem; IndexTuple itup; - ItemPointer htup; + ItemPointer htup; /* current is the next index tuple */ blkno = ItemPointerGetBlockNumber(current); @@ -607,9 +608,10 @@ btbulkdelete(PG_FUNCTION_ARGS) { /* * If this is first deletion on this page, trade in read - * lock for a really-exclusive write lock. Then, step back - * one and re-examine the item, because someone else might - * have inserted an item while we weren't holding the lock! + * lock for a really-exclusive write lock. Then, step + * back one and re-examine the item, because someone else + * might have inserted an item while we weren't holding + * the lock! */ if (blkno != lockedBlock) { @@ -632,8 +634,8 @@ btbulkdelete(PG_FUNCTION_ARGS) * We need to back up the scan one item so that the next * cycle will re-examine the same offnum on this page. * - * For now, just hack the current-item index. Will need - * to be smarter when deletion includes removal of empty + * For now, just hack the current-item index. Will need to + * be smarter when deletion includes removal of empty * index pages. */ current->ip_posid--; diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c index 86ff810845..c1a82f2b85 100644 --- a/src/backend/access/nbtree/nbtsearch.c +++ b/src/backend/access/nbtree/nbtsearch.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.68 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.69 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -589,10 +589,10 @@ _bt_first(IndexScanDesc scan, ScanDirection dir) /* * At this point we are positioned at the first item >= scan key, or - * possibly at the end of a page on which all the existing items are - * greater than the scan key and we know that everything on later pages - * is less than or equal to scan key. - * + * possibly at the end of a page on which all the existing items are + * greater than the scan key and we know that everything on later + * pages is less than or equal to scan key. + * * We could step forward in the latter case, but that'd be a waste of * time if we want to scan backwards. So, it's now time to examine * the scan strategy to find the exact place to start the scan. diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c index 2aca6bf7cf..4b327bff45 100644 --- a/src/backend/access/nbtree/nbtsort.c +++ b/src/backend/access/nbtree/nbtsort.c @@ -35,7 +35,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.60 2001/03/22 03:59:15 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsort.c,v 1.61 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -108,7 +108,7 @@ static void _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2); /* * create and initialize a spool structure */ -BTSpool * +BTSpool * _bt_spoolinit(Relation index, bool isunique) { BTSpool *btspool = (BTSpool *) palloc(sizeof(BTSpool)); @@ -354,7 +354,6 @@ _bt_buildadd(Relation index, BTPageState *state, BTItem bti) if (pgspc < btisz || pgspc < state->btps_full) { - /* * Item won't fit on this page, or we feel the page is full enough * already. Finish off the page and write it out. @@ -544,7 +543,6 @@ _bt_load(Relation index, BTSpool *btspool, BTSpool *btspool2) if (merge) { - /* * Another BTSpool for dead tuples exists. Now we have to merge * btspool and btspool2. diff --git a/src/backend/access/nbtree/nbtstrat.c b/src/backend/access/nbtree/nbtstrat.c index 4045496979..533af33681 100644 --- a/src/backend/access/nbtree/nbtstrat.c +++ b/src/backend/access/nbtree/nbtstrat.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.14 2001/05/30 19:53:40 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtstrat.c,v 1.15 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -134,5 +134,4 @@ _bt_invokestrat(Relation rel, return (RelationInvokeStrategy(rel, &BTEvaluationData, attno, strat, left, right)); } - #endif diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c index 86d2e3cf8f..55c4c32300 100644 --- a/src/backend/access/nbtree/nbtutils.c +++ b/src/backend/access/nbtree/nbtutils.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.46 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.47 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -221,7 +221,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so) /* We can short-circuit most of the work if there's just one key */ if (numberOfKeys == 1) { - /* * We don't use indices for 'A is null' and 'A is not null' * currently and 'A < = > <> NULL' will always fail - so qual is @@ -317,7 +316,6 @@ _bt_orderkeys(Relation relation, BTScanOpaque so) } else { - /* * No "=" for this key, so we're done with required keys */ diff --git a/src/backend/access/rtree/rtree.c b/src/backend/access/rtree/rtree.c index 42878248b0..0e8305bdfb 100644 --- a/src/backend/access/rtree/rtree.c +++ b/src/backend/access/rtree/rtree.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.65 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.66 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -58,9 +58,9 @@ typedef struct SPLITVEC /* for sorting tuples by cost, for picking split */ typedef struct SPLITCOST { - OffsetNumber offset_number; - float cost_differential; - bool choose_left; + OffsetNumber offset_number; + float cost_differential; + bool choose_left; } SPLITCOST; typedef struct RTSTATE @@ -79,11 +79,11 @@ typedef struct /* non-export function prototypes */ static void rtbuildCallback(Relation index, - HeapTuple htup, - Datum *attdata, - char *nulls, - bool tupleIsAlive, - void *state); + HeapTuple htup, + Datum *attdata, + char *nulls, + bool tupleIsAlive, + void *state); static InsertIndexResult rtdoinsert(Relation r, IndexTuple itup, RTSTATE *rtstate); static void rttighten(Relation r, RTSTACK *stk, Datum datum, int att_size, @@ -100,7 +100,7 @@ static OffsetNumber choose(Relation r, Page p, IndexTuple it, RTSTATE *rtstate); static int nospace(Page p, IndexTuple it); static void initRtstate(RTSTATE *rtstate, Relation index); -static int qsort_comp_splitcost(const void *a, const void *b); +static int qsort_comp_splitcost(const void *a, const void *b); /* @@ -178,7 +178,7 @@ rtbuildCallback(Relation index, bool tupleIsAlive, void *state) { - RTBuildState *buildstate = (RTBuildState *) state; + RTBuildState *buildstate = (RTBuildState *) state; IndexTuple itup; InsertIndexResult res; @@ -194,11 +194,11 @@ rtbuildCallback(Relation index, } /* - * Since we already have the index relation locked, we call - * rtdoinsert directly. Normal access method calls dispatch - * through rtinsert, which locks the relation for write. This is - * the right thing to do if you're inserting single tups, but not - * when you're initializing the whole index at once. + * Since we already have the index relation locked, we call rtdoinsert + * directly. Normal access method calls dispatch through rtinsert, + * which locks the relation for write. This is the right thing to do + * if you're inserting single tups, but not when you're initializing + * the whole index at once. */ res = rtdoinsert(index, itup, &buildstate->rtState); @@ -223,6 +223,7 @@ rtinsert(PG_FUNCTION_ARGS) Datum *datum = (Datum *) PG_GETARG_POINTER(1); char *nulls = (char *) PG_GETARG_POINTER(2); ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + #ifdef NOT_USED Relation heapRel = (Relation) PG_GETARG_POINTER(4); #endif @@ -249,7 +250,7 @@ rtinsert(PG_FUNCTION_ARGS) /* * Since rtree is not marked "amconcurrent" in pg_am, caller should - * have acquired exclusive lock on index relation. We need no locking + * have acquired exclusive lock on index relation. We need no locking * here. */ @@ -376,9 +377,8 @@ rttighten(Relation r, PointerGetDatum(&newd_size)); /* - * If newd_size == 0 we have degenerate rectangles, so we - * don't know if there was any change, so we have to - * assume there was. + * If newd_size == 0 we have degenerate rectangles, so we don't know + * if there was any change, so we have to assume there was. */ if ((newd_size == 0) || (newd_size != old_size)) { @@ -386,7 +386,6 @@ rttighten(Relation r, if (td->attrs[0]->attlen < 0) { - /* * This is an internal page, so 'oldud' had better be a union * (constant-length) key, too. (See comment below.) @@ -500,10 +499,10 @@ rtdosplit(Relation r, res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData)); /* - * spl_left contains a list of the offset numbers of the - * tuples that will go to the left page. For each offset - * number, get the tuple item, then add the item to the - * left page. Similarly for the right side. + * spl_left contains a list of the offset numbers of the tuples that + * will go to the left page. For each offset number, get the tuple + * item, then add the item to the left page. Similarly for the right + * side. */ /* fill left node */ @@ -527,7 +526,7 @@ rtdosplit(Relation r, if (i == newitemoff) ItemPointerSet(&(res->pointerData), lbknum, leftoff); - spl_left++; /* advance in left split vector */ + spl_left++; /* advance in left split vector */ } /* fill right node */ @@ -551,7 +550,7 @@ rtdosplit(Relation r, if (i == newitemoff) ItemPointerSet(&(res->pointerData), rbknum, rightoff); - spl_right++; /* advance in right split vector */ + spl_right++; /* advance in right split vector */ } /* Make sure we consumed all of the split vectors, and release 'em */ @@ -764,9 +763,10 @@ rtpicksplit(Relation r, right_avail_space; int total_num_tuples, num_tuples_without_seeds, - max_after_split; /* in Guttman's lingo, (M - m) */ - float diff; /* diff between cost of putting tuple left or right */ - SPLITCOST *cost_vector; + max_after_split; /* in Guttman's lingo, (M - m) */ + float diff; /* diff between cost of putting tuple left + * or right */ + SPLITCOST *cost_vector; int n; /* @@ -852,7 +852,6 @@ rtpicksplit(Relation r, if (firsttime) { - /* * There is no possible split except to put the new item on its * own page. Since we still have to compute the union rectangles, @@ -885,25 +884,25 @@ rtpicksplit(Relation r, /* * Now split up the regions between the two seeds. * - * The cost_vector array will contain hints for determining where - * each tuple should go. Each record in the array will contain - * a boolean, choose_left, that indicates which node the tuple - * prefers to be on, and the absolute difference in cost between - * putting the tuple in its favored node and in the other node. + * The cost_vector array will contain hints for determining where each + * tuple should go. Each record in the array will contain a boolean, + * choose_left, that indicates which node the tuple prefers to be on, + * and the absolute difference in cost between putting the tuple in + * its favored node and in the other node. * * Later, we will sort the cost_vector in descending order by cost - * difference, and consider the tuples in that order for - * placement. That way, the tuples that *really* want to be in - * one node or the other get to choose first, and the tuples that - * don't really care choose last. + * difference, and consider the tuples in that order for placement. + * That way, the tuples that *really* want to be in one node or the + * other get to choose first, and the tuples that don't really care + * choose last. * - * First, build the cost_vector array. The new index tuple will - * also be handled in this loop, and represented in the array, - * with i==newitemoff. + * First, build the cost_vector array. The new index tuple will also be + * handled in this loop, and represented in the array, with + * i==newitemoff. * - * In the case of variable size tuples it is possible that we only - * have the two seeds and no other tuples, in which case we don't - * do any of this cost_vector stuff. + * In the case of variable size tuples it is possible that we only have + * the two seeds and no other tuples, in which case we don't do any of + * this cost_vector stuff. */ /* to keep compiler quiet */ @@ -943,21 +942,21 @@ rtpicksplit(Relation r, } /* - * Sort the array. The function qsort_comp_splitcost is - * set up "backwards", to provided descending order. + * Sort the array. The function qsort_comp_splitcost is set up + * "backwards", to provided descending order. */ qsort(cost_vector, num_tuples_without_seeds, sizeof(SPLITCOST), &qsort_comp_splitcost); } /* - * Now make the final decisions about where each tuple will go, - * and build the vectors to return in the SPLITVEC record. + * Now make the final decisions about where each tuple will go, and + * build the vectors to return in the SPLITVEC record. * - * The cost_vector array contains (descriptions of) all the - * tuples, in the order that we want to consider them, so we - * we just iterate through it and place each tuple in left - * or right nodes, according to the criteria described below. + * The cost_vector array contains (descriptions of) all the tuples, in + * the order that we want to consider them, so we we just iterate + * through it and place each tuple in left or right nodes, according + * to the criteria described below. */ left = v->spl_left; @@ -965,9 +964,9 @@ rtpicksplit(Relation r, right = v->spl_right; v->spl_nright = 0; - /* Place the seeds first. - * left avail space, left union, right avail space, and right - * union have already been adjusted for the seeds. + /* + * Place the seeds first. left avail space, left union, right avail + * space, and right union have already been adjusted for the seeds. */ *left++ = seed_1; @@ -983,8 +982,8 @@ rtpicksplit(Relation r, choose_left; /* - * We need to figure out which page needs the least - * enlargement in order to store the item. + * We need to figure out which page needs the least enlargement in + * order to store the item. */ i = cost_vector[n].offset_number; @@ -1019,22 +1018,22 @@ rtpicksplit(Relation r, * the new item.) * * Guttman's algorithm actually has two factors to consider (in - * order): 1. if one node has so many tuples already assigned to + * order): 1. if one node has so many tuples already assigned to * it that the other needs all the rest in order to satisfy the - * condition that neither node has fewer than m tuples, then - * that is decisive; 2. otherwise, choose the page that shows - * the smaller enlargement of its union area. + * condition that neither node has fewer than m tuples, then that + * is decisive; 2. otherwise, choose the page that shows the + * smaller enlargement of its union area. * - * I have chosen m = M/2, where M is the maximum number of - * tuples on a page. (Actually, this is only strictly - * true for fixed size tuples. For variable size tuples, - * there still might have to be only one tuple on a page, - * if it is really big. But even with variable size - * tuples we still try to get m as close as possible to M/2.) + * I have chosen m = M/2, where M is the maximum number of tuples on + * a page. (Actually, this is only strictly true for fixed size + * tuples. For variable size tuples, there still might have to be + * only one tuple on a page, if it is really big. But even with + * variable size tuples we still try to get m as close as possible + * to M/2.) * - * The question of which page shows the smaller enlargement of - * its union area has already been answered, and the answer - * stored in the choose_left field of the SPLITCOST record. + * The question of which page shows the smaller enlargement of its + * union area has already been answered, and the answer stored in + * the choose_left field of the SPLITCOST record. */ left_feasible = (left_avail_space >= item_1_sz && ((left_avail_space - item_1_sz) >= newitemsz || @@ -1045,10 +1044,10 @@ rtpicksplit(Relation r, if (left_feasible && right_feasible) { /* - * Both feasible, use Guttman's algorithm. - * First check the m condition described above, and if - * that doesn't apply, choose the page with the smaller - * enlargement of its union area. + * Both feasible, use Guttman's algorithm. First check the m + * condition described above, and if that doesn't apply, + * choose the page with the smaller enlargement of its union + * area. */ if (v->spl_nleft > max_after_split) choose_left = false; @@ -1064,7 +1063,7 @@ rtpicksplit(Relation r, else { elog(ERROR, "rtpicksplit: failed to find a workable page split"); - choose_left = false;/* keep compiler quiet */ + choose_left = false; /* keep compiler quiet */ } if (choose_left) @@ -1090,9 +1089,7 @@ rtpicksplit(Relation r, } if (num_tuples_without_seeds > 0) - { pfree(cost_vector); - } *left = *right = InvalidOffsetNumber; /* add ending sentinels */ @@ -1189,7 +1186,7 @@ rtbulkdelete(PG_FUNCTION_ARGS) IndexBulkDeleteCallback callback = (IndexBulkDeleteCallback) PG_GETARG_POINTER(1); void *callback_state = (void *) PG_GETARG_POINTER(2); IndexBulkDeleteResult *result; - BlockNumber num_pages; + BlockNumber num_pages; double tuples_removed; double num_index_tuples; RetrieveIndexResult res; @@ -1200,7 +1197,7 @@ rtbulkdelete(PG_FUNCTION_ARGS) /* * Since rtree is not marked "amconcurrent" in pg_am, caller should - * have acquired exclusive lock on index relation. We need no locking + * have acquired exclusive lock on index relation. We need no locking * here. */ @@ -1279,9 +1276,10 @@ initRtstate(RTSTATE *rtstate, Relation index) static int qsort_comp_splitcost(const void *a, const void *b) { - float diff = - ((SPLITCOST *)a)->cost_differential - - ((SPLITCOST *)b)->cost_differential; + float diff = + ((SPLITCOST *) a)->cost_differential - + ((SPLITCOST *) b)->cost_differential; + if (diff < 0) return 1; else if (diff > 0) @@ -1342,7 +1340,6 @@ _rtdump(Relation r) ReleaseBuffer(buf); } } - #endif /* defined RTDEBUG */ void diff --git a/src/backend/access/rtree/rtscan.c b/src/backend/access/rtree/rtscan.c index 1311cfdc29..c6883fd041 100644 --- a/src/backend/access/rtree/rtscan.c +++ b/src/backend/access/rtree/rtscan.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.38 2001/07/15 22:48:16 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.39 2001/10/25 05:49:21 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -380,7 +380,6 @@ adjustiptr(IndexScanDesc s, } else { - /* * remember that we're before the current * tuple diff --git a/src/backend/access/rtree/rtstrat.c b/src/backend/access/rtree/rtstrat.c index 74ee6a39a4..41de4a4e3e 100644 --- a/src/backend/access/rtree/rtstrat.c +++ b/src/backend/access/rtree/rtstrat.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.17 2001/05/30 19:53:40 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.18 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -163,7 +163,7 @@ static StrategyExpression RTEvaluationExpressions[RTNStrategies] = { NULL, /* express overlap */ NULL, /* express overright */ NULL, /* express right */ - (StrategyExpression) RTEqualExpressionData, /* express same */ + (StrategyExpression) RTEqualExpressionData, /* express same */ NULL, /* express contains */ NULL /* express contained-by */ }; @@ -221,7 +221,6 @@ RelationInvokeRTStrategy(Relation r, return (RelationInvokeStrategy(r, &RTEvaluationData, attnum, s, left, right)); } - #endif RegProcedure diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c index cd83da93ea..1436b32aa1 100644 --- a/src/backend/access/transam/clog.c +++ b/src/backend/access/transam/clog.c @@ -13,7 +13,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.4 2001/09/29 04:02:21 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.5 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -33,7 +33,7 @@ /* * Defines for CLOG page and segment sizes. A page is the same BLCKSZ - * as is used everywhere else in Postgres. The CLOG segment size can be + * as is used everywhere else in Postgres. The CLOG segment size can be * chosen somewhat arbitrarily; we make it 1 million transactions by default, * or 256Kb. * @@ -48,15 +48,15 @@ /* We need two bits per xact, so four xacts fit in a byte */ #define CLOG_BITS_PER_XACT 2 -#define CLOG_XACTS_PER_BYTE 4 -#define CLOG_XACTS_PER_PAGE (CLOG_BLCKSZ * CLOG_XACTS_PER_BYTE) +#define CLOG_XACTS_PER_BYTE 4 +#define CLOG_XACTS_PER_PAGE (CLOG_BLCKSZ * CLOG_XACTS_PER_BYTE) #define CLOG_XACT_BITMASK ((1 << CLOG_BITS_PER_XACT) - 1) #define CLOG_XACTS_PER_SEGMENT 0x100000 #define CLOG_PAGES_PER_SEGMENT (CLOG_XACTS_PER_SEGMENT / CLOG_XACTS_PER_PAGE) #define TransactionIdToPage(xid) ((xid) / (TransactionId) CLOG_XACTS_PER_PAGE) -#define TransactionIdToPgIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) +#define TransactionIdToPgIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE) #define TransactionIdToByte(xid) (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE) #define TransactionIdToBIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE) @@ -101,15 +101,15 @@ * the control lock. * * As with the regular buffer manager, it is possible for another process - * to re-dirty a page that is currently being written out. This is handled + * to re-dirty a page that is currently being written out. This is handled * by setting the page's state from WRITE_IN_PROGRESS to DIRTY. The writing * process must notice this and not mark the page CLEAN when it's done. * * XLOG interactions: this module generates an XLOG record whenever a new - * CLOG page is initialized to zeroes. Other writes of CLOG come from + * CLOG page is initialized to zeroes. Other writes of CLOG come from * recording of transaction commit or abort in xact.c, which generates its * own XLOG records for these events and will re-perform the status update - * on redo; so we need make no additional XLOG entry here. Also, the XLOG + * on redo; so we need make no additional XLOG entry here. Also, the XLOG * is guaranteed flushed through the XLOG commit record before we are called * to log a commit, so the WAL rule "write xlog before data" is satisfied * automatically for commits, and we don't really care for aborts. Therefore, @@ -120,11 +120,13 @@ typedef enum { - CLOG_PAGE_EMPTY, /* CLOG buffer is not in use */ - CLOG_PAGE_READ_IN_PROGRESS, /* CLOG page is being read in */ - CLOG_PAGE_CLEAN, /* CLOG page is valid and not dirty */ - CLOG_PAGE_DIRTY, /* CLOG page is valid but needs write */ - CLOG_PAGE_WRITE_IN_PROGRESS /* CLOG page is being written out in */ + CLOG_PAGE_EMPTY,/* CLOG buffer is not in use */ + CLOG_PAGE_READ_IN_PROGRESS, /* CLOG page is being read + * in */ + CLOG_PAGE_CLEAN,/* CLOG page is valid and not dirty */ + CLOG_PAGE_DIRTY,/* CLOG page is valid but needs write */ + CLOG_PAGE_WRITE_IN_PROGRESS /* CLOG page is being + * written out in */ } ClogPageStatus; /* @@ -134,14 +136,15 @@ typedef struct ClogCtlData { /* * Info for each buffer slot. Page number is undefined when status is - * EMPTY. lru_count is essentially the number of operations since last - * use of this page; the page with highest lru_count is the best candidate - * to replace. + * EMPTY. lru_count is essentially the number of operations since + * last use of this page; the page with highest lru_count is the best + * candidate to replace. */ char *page_buffer[NUM_CLOG_BUFFERS]; - ClogPageStatus page_status[NUM_CLOG_BUFFERS]; + ClogPageStatus page_status[NUM_CLOG_BUFFERS]; int page_number[NUM_CLOG_BUFFERS]; - unsigned int page_lru_count[NUM_CLOG_BUFFERS]; + unsigned int page_lru_count[NUM_CLOG_BUFFERS]; + /* * latest_page_number is the page number of the current end of the * CLOG; this is not critical data, since we use it only to avoid @@ -157,7 +160,7 @@ static ClogCtlData *ClogCtl = NULL; * The value is automatically inherited by backends via fork, and * doesn't need to be in shared memory. */ -static LWLockId ClogBufferLocks[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */ +static LWLockId ClogBufferLocks[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */ /* * ClogDir is set during CLOGShmemInit and does not change thereafter. @@ -166,7 +169,7 @@ static LWLockId ClogBufferLocks[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */ */ static char ClogDir[MAXPGPATH]; -#define ClogFileName(path, seg) \ +#define ClogFileName(path, seg) \ snprintf(path, MAXPGPATH, "%s/%04X", ClogDir, seg) /* @@ -430,7 +433,7 @@ ReadCLOGPage(int pageno) LWLockAcquire(CLogControlLock, LW_EXCLUSIVE); Assert(ClogCtl->page_number[slotno] == pageno && - ClogCtl->page_status[slotno] == CLOG_PAGE_READ_IN_PROGRESS); + ClogCtl->page_status[slotno] == CLOG_PAGE_READ_IN_PROGRESS); ClogCtl->page_status[slotno] = CLOG_PAGE_CLEAN; @@ -447,7 +450,7 @@ ReadCLOGPage(int pageno) * * NOTE: only one write attempt is made here. Hence, it is possible that * the page is still dirty at exit (if someone else re-dirtied it during - * the write). However, we *do* attempt a fresh write even if the page + * the write). However, we *do* attempt a fresh write even if the page * is already being written; this is for checkpoints. * * Control lock must be held at entry, and will be held at exit. @@ -455,7 +458,7 @@ ReadCLOGPage(int pageno) static void WriteCLOGPage(int slotno) { - int pageno; + int pageno; /* Do nothing if page does not need writing */ if (ClogCtl->page_status[slotno] != CLOG_PAGE_DIRTY && @@ -489,11 +492,12 @@ WriteCLOGPage(int slotno) * update on this page will mark it dirty again. NB: we are assuming * that read/write of the page status field is atomic, since we change * the state while not holding control lock. However, we cannot set - * this state any sooner, or we'd possibly fool a previous writer - * into thinking he's successfully dumped the page when he hasn't. - * (Scenario: other writer starts, page is redirtied, we come along and - * set WRITE_IN_PROGRESS again, other writer completes and sets CLEAN - * because redirty info has been lost, then we think it's clean too.) + * this state any sooner, or we'd possibly fool a previous writer into + * thinking he's successfully dumped the page when he hasn't. + * (Scenario: other writer starts, page is redirtied, we come along + * and set WRITE_IN_PROGRESS again, other writer completes and sets + * CLEAN because redirty info has been lost, then we think it's clean + * too.) */ ClogCtl->page_status[slotno] = CLOG_PAGE_WRITE_IN_PROGRESS; @@ -523,7 +527,7 @@ WriteCLOGPage(int slotno) static void CLOGPhysicalReadPage(int pageno, int slotno) { - int segno = pageno / CLOG_PAGES_PER_SEGMENT; + int segno = pageno / CLOG_PAGES_PER_SEGMENT; int rpageno = pageno % CLOG_PAGES_PER_SEGMENT; int offset = rpageno * CLOG_BLCKSZ; char path[MAXPGPATH]; @@ -533,9 +537,9 @@ CLOGPhysicalReadPage(int pageno, int slotno) /* * In a crash-and-restart situation, it's possible for us to receive - * commands to set the commit status of transactions whose bits are - * in already-truncated segments of the commit log (see notes in - * CLOGPhysicalWritePage). Hence, if we are InRecovery, allow the + * commands to set the commit status of transactions whose bits are in + * already-truncated segments of the commit log (see notes in + * CLOGPhysicalWritePage). Hence, if we are InRecovery, allow the * case where the file doesn't exist, and return zeroes instead. */ fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR); @@ -569,7 +573,7 @@ CLOGPhysicalReadPage(int pageno, int slotno) static void CLOGPhysicalWritePage(int pageno, int slotno) { - int segno = pageno / CLOG_PAGES_PER_SEGMENT; + int segno = pageno / CLOG_PAGES_PER_SEGMENT; int rpageno = pageno % CLOG_PAGES_PER_SEGMENT; int offset = rpageno * CLOG_BLCKSZ; char path[MAXPGPATH]; @@ -578,16 +582,17 @@ CLOGPhysicalWritePage(int pageno, int slotno) ClogFileName(path, segno); /* - * If the file doesn't already exist, we should create it. It is possible - * for this to need to happen when writing a page that's not first in - * its segment; we assume the OS can cope with that. (Note: it might seem - * that it'd be okay to create files only when ZeroCLOGPage is called for - * the first page of a segment. However, if after a crash and restart - * the REDO logic elects to replay the log from a checkpoint before the - * latest one, then it's possible that we will get commands to set - * transaction status of transactions that have already been truncated - * from the commit log. Easiest way to deal with that is to accept - * references to nonexistent files here and in CLOGPhysicalReadPage.) + * If the file doesn't already exist, we should create it. It is + * possible for this to need to happen when writing a page that's not + * first in its segment; we assume the OS can cope with that. (Note: + * it might seem that it'd be okay to create files only when + * ZeroCLOGPage is called for the first page of a segment. However, + * if after a crash and restart the REDO logic elects to replay the + * log from a checkpoint before the latest one, then it's possible + * that we will get commands to set transaction status of transactions + * that have already been truncated from the commit log. Easiest way + * to deal with that is to accept references to nonexistent files here + * and in CLOGPhysicalReadPage.) */ fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR); if (fd < 0) @@ -649,16 +654,15 @@ SelectLRUCLOGPage(int pageno) } /* - * If we find any EMPTY slot, just select that one. - * Else locate the least-recently-used slot that isn't the - * latest CLOG page. + * If we find any EMPTY slot, just select that one. Else locate + * the least-recently-used slot that isn't the latest CLOG page. */ for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) { if (ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY) return slotno; if (ClogCtl->page_lru_count[slotno] > bestcount && - ClogCtl->page_number[slotno] != ClogCtl->latest_page_number) + ClogCtl->page_number[slotno] != ClogCtl->latest_page_number) { bestslot = slotno; bestcount = ClogCtl->page_lru_count[slotno]; @@ -672,10 +676,10 @@ SelectLRUCLOGPage(int pageno) return bestslot; /* - * We need to do I/O. Normal case is that we have to write it out, - * but it's possible in the worst case to have selected a read-busy - * page. In that case we use ReadCLOGPage to wait for the read to - * complete. + * We need to do I/O. Normal case is that we have to write it + * out, but it's possible in the worst case to have selected a + * read-busy page. In that case we use ReadCLOGPage to wait for + * the read to complete. */ if (ClogCtl->page_status[bestslot] == CLOG_PAGE_READ_IN_PROGRESS) (void) ReadCLOGPage(ClogCtl->page_number[bestslot]); @@ -683,9 +687,9 @@ SelectLRUCLOGPage(int pageno) WriteCLOGPage(bestslot); /* - * Now loop back and try again. This is the easiest way of dealing - * with corner cases such as the victim page being re-dirtied while - * we wrote it. + * Now loop back and try again. This is the easiest way of + * dealing with corner cases such as the victim page being + * re-dirtied while we wrote it. */ } } @@ -736,6 +740,7 @@ CheckPointCLOG(void) for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) { WriteCLOGPage(slotno); + /* * We cannot assert that the slot is clean now, since another * process might have re-dirtied it already. That's okay. @@ -782,13 +787,13 @@ ExtendCLOG(TransactionId newestXact) * Remove all CLOG segments before the one holding the passed transaction ID * * When this is called, we know that the database logically contains no - * reference to transaction IDs older than oldestXact. However, we must + * reference to transaction IDs older than oldestXact. However, we must * not truncate the CLOG until we have performed a checkpoint, to ensure * that no such references remain on disk either; else a crash just after * the truncation might leave us with a problem. Since CLOG segments hold * a large number of transactions, the opportunity to actually remove a * segment is fairly rare, and so it seems best not to do the checkpoint - * unless we have confirmed that there is a removable segment. Therefore + * unless we have confirmed that there is a removable segment. Therefore * we issue the checkpoint command here, not in higher-level code as might * seem cleaner. */ @@ -813,15 +818,16 @@ TruncateCLOG(TransactionId oldestXact) /* * Scan CLOG shared memory and remove any pages preceding the cutoff * page, to ensure we won't rewrite them later. (Any dirty pages - * should have been flushed already during the checkpoint, we're - * just being extra careful here.) + * should have been flushed already during the checkpoint, we're just + * being extra careful here.) */ LWLockAcquire(CLogControlLock, LW_EXCLUSIVE); restart:; + /* - * While we are holding the lock, make an important safety check: - * the planned cutoff point must be <= the current CLOG endpoint page. + * While we are holding the lock, make an important safety check: the + * planned cutoff point must be <= the current CLOG endpoint page. * Otherwise we have already wrapped around, and proceeding with the * truncation would risk removing the current CLOG segment. */ @@ -838,6 +844,7 @@ restart:; continue; if (!CLOGPagePrecedes(ClogCtl->page_number[slotno], cutoffPage)) continue; + /* * If page is CLEAN, just change state to EMPTY (expected case). */ @@ -846,6 +853,7 @@ restart:; ClogCtl->page_status[slotno] = CLOG_PAGE_EMPTY; continue; } + /* * Hmm, we have (or may have) I/O operations acting on the page, * so we've got to wait for them to finish and then start again. @@ -928,9 +936,11 @@ CLOGPagePrecedes(int page1, int page2) TransactionId xid1; TransactionId xid2; - xid1 = (TransactionId) page1 * CLOG_XACTS_PER_PAGE; + xid1 = (TransactionId) page1 *CLOG_XACTS_PER_PAGE; + xid1 += FirstNormalTransactionId; - xid2 = (TransactionId) page2 * CLOG_XACTS_PER_PAGE; + xid2 = (TransactionId) page2 *CLOG_XACTS_PER_PAGE; + xid2 += FirstNormalTransactionId; return TransactionIdPrecedes(xid1, xid2); @@ -966,8 +976,8 @@ clog_redo(XLogRecPtr lsn, XLogRecord *record) if (info == CLOG_ZEROPAGE) { - int pageno; - int slotno; + int pageno; + int slotno; memcpy(&pageno, XLogRecGetData(record), sizeof(int)); @@ -993,7 +1003,7 @@ clog_desc(char *buf, uint8 xl_info, char *rec) if (info == CLOG_ZEROPAGE) { - int pageno; + int pageno; memcpy(&pageno, rec, sizeof(int)); sprintf(buf + strlen(buf), "zeropage: %d", pageno); diff --git a/src/backend/access/transam/transam.c b/src/backend/access/transam/transam.c index 2a73c045b7..bb94fc27a1 100644 --- a/src/backend/access/transam/transam.c +++ b/src/backend/access/transam/transam.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.48 2001/08/26 16:55:59 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.49 2001/10/25 05:49:22 momjian Exp $ * * NOTES * This file contains the high level access-method interface to the @@ -32,7 +32,7 @@ static void TransactionLogUpdate(TransactionId transactionId, * ---------------- */ static TransactionId cachedTestXid = InvalidTransactionId; -static XidStatus cachedTestXidStatus; +static XidStatus cachedTestXidStatus; /* ---------------------------------------------------------------- @@ -56,8 +56,8 @@ TransactionLogTest(TransactionId transactionId, /* transaction id to test */ XidStatus xidstatus; /* recorded status of xid */ /* - * Before going to the commit log manager, check our single item cache to - * see if we didn't just check the transaction status a moment ago. + * Before going to the commit log manager, check our single item cache + * to see if we didn't just check the transaction status a moment ago. */ if (TransactionIdEquals(transactionId, cachedTestXid)) return (status == cachedTestXidStatus); @@ -65,7 +65,7 @@ TransactionLogTest(TransactionId transactionId, /* transaction id to test */ /* * Also, check to see if the transaction ID is a permanent one. */ - if (! TransactionIdIsNormal(transactionId)) + if (!TransactionIdIsNormal(transactionId)) { if (TransactionIdEquals(transactionId, BootstrapTransactionId)) return (status == TRANSACTION_STATUS_COMMITTED); @@ -77,18 +77,18 @@ TransactionLogTest(TransactionId transactionId, /* transaction id to test */ /* * Get the status. */ - xidstatus = TransactionIdGetStatus(transactionId); - - /* - * DO NOT cache status for unfinished transactions! - */ - if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS) - { - TransactionIdStore(transactionId, &cachedTestXid); - cachedTestXidStatus = xidstatus; - } - - return (status == xidstatus); + xidstatus = TransactionIdGetStatus(transactionId); + + /* + * DO NOT cache status for unfinished transactions! + */ + if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS) + { + TransactionIdStore(transactionId, &cachedTestXid); + cachedTestXidStatus = xidstatus; + } + + return (status == xidstatus); } /* -------------------------------- @@ -197,7 +197,7 @@ TransactionIdIsInProgress(TransactionId transactionId) return TransactionLogTest(transactionId, TRANSACTION_STATUS_IN_PROGRESS); } -#endif /* NOT_USED */ +#endif /* NOT_USED */ /* -------------------------------- * TransactionId Commit @@ -246,7 +246,7 @@ TransactionIdPrecedes(TransactionId id1, TransactionId id2) { /* * If either ID is a permanent XID then we can just do unsigned - * comparison. If both are normal, do a modulo-2^31 comparison. + * comparison. If both are normal, do a modulo-2^31 comparison. */ int32 diff; diff --git a/src/backend/access/transam/varsup.c b/src/backend/access/transam/varsup.c index 048080a180..5a56f47e06 100644 --- a/src/backend/access/transam/varsup.c +++ b/src/backend/access/transam/varsup.c @@ -6,7 +6,7 @@ * Copyright (c) 2000, PostgreSQL Global Development Group * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.46 2001/09/29 04:02:21 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.47 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -32,7 +32,7 @@ VariableCache ShmemVariableCache = NULL; TransactionId GetNewTransactionId(void) { - TransactionId xid; + TransactionId xid; /* * During bootstrap initialization, we return the special bootstrap @@ -48,32 +48,32 @@ GetNewTransactionId(void) TransactionIdAdvance(ShmemVariableCache->nextXid); /* - * If we have just allocated the first XID of a new page of the - * commit log, zero out that commit-log page before returning. - * We must do this while holding XidGenLock, else another xact could - * acquire and commit a later XID before we zero the page. Fortunately, - * a page of the commit log holds 32K or more transactions, so we don't - * have to do this very often. + * If we have just allocated the first XID of a new page of the commit + * log, zero out that commit-log page before returning. We must do + * this while holding XidGenLock, else another xact could acquire and + * commit a later XID before we zero the page. Fortunately, a page of + * the commit log holds 32K or more transactions, so we don't have to + * do this very often. */ ExtendCLOG(xid); /* - * Must set MyProc->xid before releasing XidGenLock. This ensures that - * when GetSnapshotData calls ReadNewTransactionId, all active XIDs - * before the returned value of nextXid are already present in the shared - * PROC array. Else we have a race condition. + * Must set MyProc->xid before releasing XidGenLock. This ensures + * that when GetSnapshotData calls ReadNewTransactionId, all active + * XIDs before the returned value of nextXid are already present in + * the shared PROC array. Else we have a race condition. * * XXX by storing xid into MyProc without acquiring SInvalLock, we are * relying on fetch/store of an xid to be atomic, else other backends - * might see a partially-set xid here. But holding both locks at once - * would be a nasty concurrency hit (and in fact could cause a deadlock - * against GetSnapshotData). So for now, assume atomicity. Note that - * readers of PROC xid field should be careful to fetch the value only - * once, rather than assume they can read it multiple times and get the - * same answer each time. + * might see a partially-set xid here. But holding both locks at once + * would be a nasty concurrency hit (and in fact could cause a + * deadlock against GetSnapshotData). So for now, assume atomicity. + * Note that readers of PROC xid field should be careful to fetch the + * value only once, rather than assume they can read it multiple times + * and get the same answer each time. * - * A solution to the atomic-store problem would be to give each PROC - * its own spinlock used only for fetching/storing that PROC's xid. + * A solution to the atomic-store problem would be to give each PROC its + * own spinlock used only for fetching/storing that PROC's xid. * (SInvalLock would then mean primarily that PROCs couldn't be added/ * removed while holding the lock.) */ @@ -91,7 +91,7 @@ GetNewTransactionId(void) TransactionId ReadNewTransactionId(void) { - TransactionId xid; + TransactionId xid; /* * During bootstrap initialization, we return the special bootstrap @@ -117,16 +117,16 @@ static Oid lastSeenOid = InvalidOid; Oid GetNewObjectId(void) { - Oid result; + Oid result; LWLockAcquire(OidGenLock, LW_EXCLUSIVE); /* * Check for wraparound of the OID counter. We *must* not return 0 * (InvalidOid); and as long as we have to check that, it seems a good - * idea to skip over everything below BootstrapObjectIdData too. (This - * basically just reduces the odds of OID collision right after a wrap - * occurs.) Note we are relying on unsigned comparison here. + * idea to skip over everything below BootstrapObjectIdData too. + * (This basically just reduces the odds of OID collision right after + * a wrap occurs.) Note we are relying on unsigned comparison here. */ if (ShmemVariableCache->nextOid < ((Oid) BootstrapObjectIdData)) { diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index cf9791a8e8..f4dc01adfd 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.112 2001/10/18 17:30:03 thomas Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.113 2001/10/25 05:49:22 momjian Exp $ * * NOTES * Transaction aborts can now occur two ways: @@ -300,7 +300,6 @@ IsTransactionState(void) */ return false; } - #endif /* -------------------------------- @@ -476,7 +475,6 @@ AtStart_Cache(void) static void AtStart_Locks(void) { - /* * at present, it is unknown to me what belongs here -cim 3/18/90 * @@ -492,7 +490,6 @@ AtStart_Locks(void) static void AtStart_Memory(void) { - /* * We shouldn't have any transaction contexts already. */ @@ -717,8 +714,8 @@ RecordTransactionAbort(void) recptr = XLogInsert(RM_XACT_ID, XLOG_XACT_ABORT, &rdata); /* - * There's no need for XLogFlush here, since the default assumption - * would be that we aborted, anyway. + * There's no need for XLogFlush here, since the default + * assumption would be that we aborted, anyway. */ /* Mark the transaction aborted in clog */ @@ -756,7 +753,6 @@ AtAbort_Cache(void) static void AtAbort_Locks(void) { - /* * XXX What if ProcReleaseLocks() fails? (race condition?) * @@ -773,7 +769,6 @@ AtAbort_Locks(void) static void AtAbort_Memory(void) { - /* * Make sure we are in a valid context (not a child of * TransactionCommandContext...). Note that it is possible for this @@ -807,7 +802,6 @@ AtAbort_Memory(void) static void AtCleanup_Memory(void) { - /* * Now that we're "out" of a transaction, have the system allocate * things in the top memory context instead of per-transaction @@ -909,7 +903,6 @@ CurrentXactInProgress(void) { return CurrentTransactionState->state == TRANS_INPROGRESS; } - #endif /* -------------------------------- @@ -965,12 +958,11 @@ CommitTransaction(void) * this must be done _before_ releasing locks we hold and _after_ * RecordTransactionCommit. * - * LWLockAcquire(SInvalLock) is required: UPDATE with xid 0 is blocked - * by xid 1' UPDATE, xid 1 is doing commit while xid 2 gets snapshot - - * if xid 2' GetSnapshotData sees xid 1 as running then it must see - * xid 0 as running as well or it will see two tuple versions - one - * deleted by xid 1 and one inserted by xid 0. See notes in - * GetSnapshotData. + * LWLockAcquire(SInvalLock) is required: UPDATE with xid 0 is blocked by + * xid 1' UPDATE, xid 1 is doing commit while xid 2 gets snapshot - if + * xid 2' GetSnapshotData sees xid 1 as running then it must see xid 0 + * as running as well or it will see two tuple versions - one deleted + * by xid 1 and one inserted by xid 0. See notes in GetSnapshotData. */ if (MyProc != (PROC *) NULL) { @@ -1002,7 +994,7 @@ CommitTransaction(void) AtCommit_Memory(); AtEOXact_Files(); - SharedBufferChanged = false;/* safest place to do it */ + SharedBufferChanged = false; /* safest place to do it */ /* Count transaction commit in statistics collector */ pgstat_count_xact_commit(); @@ -1032,8 +1024,8 @@ AbortTransaction(void) /* * Release any LW locks we might be holding as quickly as possible. * (Regular locks, however, must be held till we finish aborting.) - * Releasing LW locks is critical since we might try to grab them again - * while cleaning up! + * Releasing LW locks is critical since we might try to grab them + * again while cleaning up! */ LWLockReleaseAll(); @@ -1105,7 +1097,7 @@ AbortTransaction(void) AtEOXact_Files(); AtAbort_Locks(); - SharedBufferChanged = false;/* safest place to do it */ + SharedBufferChanged = false; /* safest place to do it */ /* Count transaction abort in statistics collector */ pgstat_count_xact_rollback(); @@ -1155,7 +1147,6 @@ StartTransactionCommand(void) switch (s->blockState) { - /* * if we aren't in a transaction block, we just do our usual * start transaction. @@ -1238,7 +1229,6 @@ CommitTransactionCommand(void) switch (s->blockState) { - /* * if we aren't in a transaction block, we just do our usual * transaction commit @@ -1313,7 +1303,6 @@ AbortCurrentTransaction(void) switch (s->blockState) { - /* * if we aren't in a transaction block, we just do the basic * abort & cleanup transaction. @@ -1429,7 +1418,6 @@ EndTransactionBlock(void) */ if (s->blockState == TBLOCK_INPROGRESS) { - /* * here we are in a transaction block which should commit when we * get to the upcoming CommitTransactionCommand() so we set the @@ -1442,7 +1430,6 @@ EndTransactionBlock(void) if (s->blockState == TBLOCK_ABORT) { - /* * here, we are in a transaction block which aborted and since the * AbortTransaction() was already done, we do whatever is needed @@ -1480,7 +1467,6 @@ AbortTransactionBlock(void) */ if (s->blockState == TBLOCK_INPROGRESS) { - /* * here we were inside a transaction block something screwed up * inside the system so we enter the abort state, do the abort @@ -1502,7 +1488,6 @@ AbortTransactionBlock(void) AbortTransaction(); s->blockState = TBLOCK_ENDABORT; } - #endif /* -------------------------------- @@ -1527,7 +1512,6 @@ UserAbortTransactionBlock(void) if (s->blockState == TBLOCK_INPROGRESS) { - /* * here we were inside a transaction block and we got an abort * command from the user, so we move to the abort state, do the diff --git a/src/backend/access/transam/xid.c b/src/backend/access/transam/xid.c index babe7c9a48..cde2713b0f 100644 --- a/src/backend/access/transam/xid.c +++ b/src/backend/access/transam/xid.c @@ -6,7 +6,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: xid.c,v 1.33 2001/08/26 16:55:59 tgl Exp $ + * $Id: xid.c,v 1.34 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -34,6 +34,7 @@ Datum xidout(PG_FUNCTION_ARGS) { TransactionId transactionId = PG_GETARG_TRANSACTIONID(0); + /* maximum 32 bit unsigned integer representation takes 10 chars */ char *str = palloc(11); @@ -64,7 +65,7 @@ xid_age(PG_FUNCTION_ARGS) TransactionId now = GetCurrentTransactionId(); /* Permanent XIDs are always infinitely old */ - if (! TransactionIdIsNormal(xid)) + if (!TransactionIdIsNormal(xid)) PG_RETURN_INT32(INT_MAX); PG_RETURN_INT32((int32) (now - xid)); diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 057ee72d55..8c162ab3f6 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.78 2001/09/29 04:02:21 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.79 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -97,7 +97,7 @@ char XLOG_archive_dir[MAXPGPATH]; /* null string means * delete 'em */ /* - * XLOGfileslop is used in the code as the allowed "fuzz" in the number of + * XLOGfileslop is used in the code as the allowed "fuzz" in the number of * preallocated XLOG segments --- we try to have at least XLOGfiles advance * segments but no more than XLOGfiles+XLOGfileslop segments. This could * be made a separate GUC variable, but at present I think it's sufficient @@ -215,13 +215,13 @@ typedef struct XLogwrtRqst { XLogRecPtr Write; /* last byte + 1 to write out */ XLogRecPtr Flush; /* last byte + 1 to flush */ -} XLogwrtRqst; +} XLogwrtRqst; typedef struct XLogwrtResult { XLogRecPtr Write; /* last byte + 1 written out */ XLogRecPtr Flush; /* last byte + 1 flushed */ -} XLogwrtResult; +} XLogwrtResult; /* * Shared state data for XLogInsert. @@ -260,8 +260,9 @@ typedef struct XLogCtlData /* * These values do not change after startup, although the pointed-to - * pages and xlblocks values certainly do. Permission to read/write the - * pages and xlblocks values depends on WALInsertLock and WALWriteLock. + * pages and xlblocks values certainly do. Permission to read/write + * the pages and xlblocks values depends on WALInsertLock and + * WALWriteLock. */ char *pages; /* buffers for unwritten XLOG pages */ XLogRecPtr *xlblocks; /* 1st byte ptr-s + BLCKSZ */ @@ -428,8 +429,8 @@ static void XLogWrite(XLogwrtRqst WriteRqst); static int XLogFileInit(uint32 log, uint32 seg, bool *use_existent, bool use_lock); static bool InstallXLogFileSegment(uint32 log, uint32 seg, char *tmppath, - bool find_free, int max_advance, - bool use_lock); + bool find_free, int max_advance, + bool use_lock); static int XLogFileOpen(uint32 log, uint32 seg, bool econt); static void PreallocXlogFiles(XLogRecPtr endptr); static void MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr); @@ -621,8 +622,8 @@ begin:; SpinLockRelease_NoHoldoff(&XLogCtl->info_lck); /* - * If cache is half filled then try to acquire write lock and - * do XLogWrite. Ignore any fractional blocks in performing this check. + * If cache is half filled then try to acquire write lock and do + * XLogWrite. Ignore any fractional blocks in performing this check. */ LogwrtRqst.Write.xrecoff -= LogwrtRqst.Write.xrecoff % BLCKSZ; if (LogwrtRqst.Write.xlogid != LogwrtResult.Write.xlogid || @@ -939,9 +940,7 @@ AdvanceXLInsertBuffer(void) NewPageEndPtr.xrecoff = BLCKSZ; } else - { NewPageEndPtr.xrecoff += BLCKSZ; - } XLogCtl->xlblocks[nextidx] = NewPageEndPtr; NewPage = (XLogPageHeader) (XLogCtl->pages + nextidx * BLCKSZ); Insert->curridx = nextidx; @@ -956,7 +955,7 @@ AdvanceXLInsertBuffer(void) /* And fill the new page's header */ NewPage->xlp_magic = XLOG_PAGE_MAGIC; - /* NewPage->xlp_info = 0; */ /* done by memset */ + /* NewPage->xlp_info = 0; *//* done by memset */ NewPage->xlp_sui = ThisStartUpID; NewPage->xlp_pageaddr.xlogid = NewPageEndPtr.xlogid; NewPage->xlp_pageaddr.xrecoff = NewPageEndPtr.xrecoff - BLCKSZ; @@ -985,7 +984,6 @@ XLogWrite(XLogwrtRqst WriteRqst) while (XLByteLT(LogwrtResult.Write, WriteRqst.Write)) { - /* * Make sure we're not ahead of the insert process. This could * happen if we're passed a bogus WriteRqst.Write that is past the @@ -1004,7 +1002,6 @@ XLogWrite(XLogwrtRqst WriteRqst) if (!XLByteInPrevSeg(LogwrtResult.Write, openLogId, openLogSeg)) { - /* * Switch to new logfile segment. */ @@ -1114,7 +1111,6 @@ XLogWrite(XLogwrtRqst WriteRqst) if (XLByteLT(LogwrtResult.Flush, WriteRqst.Flush) && XLByteLT(LogwrtResult.Flush, LogwrtResult.Write)) { - /* * Could get here without iterating above loop, in which case we * might have no open file or the wrong one. However, we do not @@ -1174,11 +1170,11 @@ XLogFlush(XLogRecPtr record) if (XLOG_DEBUG) { elog(DEBUG, "XLogFlush%s%s: request %X/%X; write %X/%X; flush %X/%X\n", - (IsBootstrapProcessingMode()) ? "(bootstrap)" : "", - (InRedo) ? "(redo)" : "", - record.xlogid, record.xrecoff, - LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff, - LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff); + (IsBootstrapProcessingMode()) ? "(bootstrap)" : "", + (InRedo) ? "(redo)" : "", + record.xlogid, record.xrecoff, + LogwrtResult.Write.xlogid, LogwrtResult.Write.xrecoff, + LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff); fflush(stderr); } @@ -1240,7 +1236,7 @@ XLogFlush(XLogRecPtr record) if (XLByteLT(LogwrtResult.Flush, record)) elog(STOP, "XLogFlush: request %X/%X is not satisfied --- flushed only to %X/%X", record.xlogid, record.xrecoff, - LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff); + LogwrtResult.Flush.xlogid, LogwrtResult.Flush.xrecoff); } LWLockRelease(WALWriteLock); } @@ -1565,8 +1561,8 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr) { /* * Before deleting the file, see if it can be recycled as - * a future log segment. We allow recycling segments up to - * XLOGfiles + XLOGfileslop segments beyond the current + * a future log segment. We allow recycling segments up + * to XLOGfiles + XLOGfileslop segments beyond the current * XLOG location. */ if (InstallXLogFileSegment(endlogId, endlogSeg, path, @@ -1719,7 +1715,6 @@ ReadRecord(XLogRecPtr *RecPtr, int emode, char *buffer) if (readBuf == NULL) { - /* * First time through, permanently allocate readBuf. We do it * this way, rather than just making a static array, for two @@ -1767,7 +1762,7 @@ ReadRecord(XLogRecPtr *RecPtr, int emode, char *buffer) readFile = XLogFileOpen(readId, readSeg, (emode == LOG)); if (readFile < 0) goto next_record_is_invalid; - readOff = (uint32) (-1);/* force read to occur below */ + readOff = (uint32) (-1); /* force read to occur below */ } targetPageOff = ((RecPtr->xrecoff % XLogSegSize) / BLCKSZ) * BLCKSZ; @@ -2022,7 +2017,6 @@ WriteControlFile(void) #ifdef USE_LOCALE char *localeptr; - #endif /* @@ -2054,10 +2048,10 @@ WriteControlFile(void) "\n\tsuch queries, you may wish to set LC_COLLATE to \"C\" and" "\n\tre-initdb. For more information see the Administrator's Guide.", ControlFile->lc_collate); -#else /* not USE_LOCALE */ +#else /* not USE_LOCALE */ strcpy(ControlFile->lc_collate, "C"); strcpy(ControlFile->lc_ctype, "C"); -#endif /* not USE_LOCALE */ +#endif /* not USE_LOCALE */ /* Contents are protected with a CRC */ INIT_CRC64(ControlFile->crc); @@ -2156,7 +2150,7 @@ ReadControlFile(void) if (ControlFile->catalog_version_no != CATALOG_VERSION_NO) elog(STOP, "The database cluster was initialized with CATALOG_VERSION_NO %d,\n" - "\tbut the backend was compiled with CATALOG_VERSION_NO %d.\n" + "\tbut the backend was compiled with CATALOG_VERSION_NO %d.\n" "\tIt looks like you need to initdb.", ControlFile->catalog_version_no, CATALOG_VERSION_NO); if (ControlFile->blcksz != BLCKSZ) @@ -2174,7 +2168,7 @@ ReadControlFile(void) #ifdef USE_LOCALE if (setlocale(LC_COLLATE, ControlFile->lc_collate) == NULL) elog(STOP, - "The database cluster was initialized with LC_COLLATE '%s',\n" + "The database cluster was initialized with LC_COLLATE '%s',\n" "\twhich is not recognized by setlocale().\n" "\tIt looks like you need to initdb.", ControlFile->lc_collate); @@ -2184,15 +2178,15 @@ ReadControlFile(void) "\twhich is not recognized by setlocale().\n" "\tIt looks like you need to initdb.", ControlFile->lc_ctype); -#else /* not USE_LOCALE */ +#else /* not USE_LOCALE */ if (strcmp(ControlFile->lc_collate, "C") != 0 || strcmp(ControlFile->lc_ctype, "C") != 0) elog(STOP, - "The database cluster was initialized with LC_COLLATE '%s' and\n" + "The database cluster was initialized with LC_COLLATE '%s' and\n" "\tLC_CTYPE '%s', but the server was compiled without locale support.\n" "\tIt looks like you need to initdb or recompile.", ControlFile->lc_collate, ControlFile->lc_ctype); -#endif /* not USE_LOCALE */ +#endif /* not USE_LOCALE */ } void @@ -2536,7 +2530,7 @@ StartupXLOG(void) { /* nextXid must be beyond record's xid */ if (TransactionIdFollowsOrEquals(record->xl_xid, - ShmemVariableCache->nextXid)) + ShmemVariableCache->nextXid)) { ShmemVariableCache->nextXid = record->xl_xid; TransactionIdAdvance(ShmemVariableCache->nextXid); @@ -2585,8 +2579,8 @@ StartupXLOG(void) Insert->PrevRecord = LastRec; /* - * If the next record will go to the new page - * then initialize for that one. + * If the next record will go to the new page then initialize for that + * one. */ if ((BLCKSZ - EndOfLog.xrecoff % BLCKSZ) < SizeOfXLogRecord) EndOfLog.xrecoff += (BLCKSZ - EndOfLog.xrecoff % BLCKSZ); @@ -2602,9 +2596,7 @@ StartupXLOG(void) NewPageEndPtr.xrecoff = BLCKSZ; } else - { NewPageEndPtr.xrecoff += BLCKSZ; - } XLogCtl->xlblocks[0] = NewPageEndPtr; Insert->currpage->xlp_magic = XLOG_PAGE_MAGIC; if (InRecovery) @@ -2621,9 +2613,10 @@ StartupXLOG(void) XLogCtl->xlblocks[0].xlogid = openLogId; XLogCtl->xlblocks[0].xrecoff = ((EndOfLog.xrecoff - 1) / BLCKSZ + 1) * BLCKSZ; + /* * Tricky point here: readBuf contains the *last* block that the - * LastRec record spans, not the one it starts in. The last block + * LastRec record spans, not the one it starts in. The last block * is indeed the one we want to use. */ Assert(readOff == (XLogCtl->xlblocks[0].xrecoff - BLCKSZ) % XLogSegSize); @@ -2670,7 +2663,6 @@ StartupXLOG(void) if (InRecovery) { - /* * In case we had to use the secondary checkpoint, make sure that * it will still be shown as the secondary checkpoint after this @@ -2748,8 +2740,8 @@ ReadCheckpointRecord(XLogRecPtr RecPtr, if (record->xl_rmid != RM_XLOG_ID) { elog(LOG, (whichChkpt == 1 ? - "invalid resource manager id in primary checkpoint record" : - "invalid resource manager id in secondary checkpoint record")); + "invalid resource manager id in primary checkpoint record" : + "invalid resource manager id in secondary checkpoint record")); return NULL; } if (record->xl_info != XLOG_CHECKPOINT_SHUTDOWN && @@ -2845,11 +2837,11 @@ CreateCheckPoint(bool shutdown) /* * The CheckpointLock can be held for quite a while, which is not good - * because we won't respond to a cancel/die request while waiting for an - * LWLock. (But the alternative of using a regular lock won't work for - * background checkpoint processes, which are not regular backends.) - * So, rather than use a plain LWLockAcquire, use this kluge to allow - * an interrupt to be accepted while we are waiting: + * because we won't respond to a cancel/die request while waiting for + * an LWLock. (But the alternative of using a regular lock won't work + * for background checkpoint processes, which are not regular + * backends.) So, rather than use a plain LWLockAcquire, use this + * kluge to allow an interrupt to be accepted while we are waiting: */ while (!LWLockConditionalAcquire(CheckpointLock, LW_EXCLUSIVE)) { @@ -2996,7 +2988,8 @@ CreateCheckPoint(bool shutdown) * but watch out for case that undo = 0. * * Without UNDO support: just use the redo pointer. This allows xlog - * space to be freed much faster when there are long-running transactions. + * space to be freed much faster when there are long-running + * transactions. */ #ifdef NOT_USED if (ControlFile->checkPointCopy.undo.xrecoff != 0 && @@ -3230,7 +3223,6 @@ assign_xlog_sync_method(const char *method) if (sync_method != new_sync_method || open_sync_bit != new_sync_bit) { - /* * To ensure that no blocks escape unsynced, force an fsync on the * currently open log segment (if any). Also, if the open flag is @@ -3264,7 +3256,7 @@ issue_xlog_fsync(void) { switch (sync_method) { - case SYNC_METHOD_FSYNC: + case SYNC_METHOD_FSYNC: if (pg_fsync(openLogFile) != 0) elog(STOP, "fsync of log file %u, segment %u failed: %m", openLogId, openLogSeg); diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c index 2394060a67..e49d543ac8 100644 --- a/src/backend/access/transam/xlogutils.c +++ b/src/backend/access/transam/xlogutils.c @@ -6,7 +6,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.20 2001/10/05 17:28:11 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.21 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -247,7 +247,7 @@ _xl_remove_hash_entry(XLogRelDesc *rdesc) rdesc->moreRecently->lessRecently = rdesc->lessRecently; hentry = (XLogRelCacheEntry *) hash_search(_xlrelcache, - (void *) &(rdesc->reldata.rd_node), HASH_REMOVE, NULL); + (void *) &(rdesc->reldata.rd_node), HASH_REMOVE, NULL); if (hentry == NULL) elog(STOP, "_xl_remove_hash_entry: file was not found in cache"); @@ -304,9 +304,7 @@ XLogCloseRelationCache(void) hash_seq_init(&status, _xlrelcache); while ((hentry = (XLogRelCacheEntry *) hash_seq_search(&status)) != NULL) - { _xl_remove_hash_entry(hentry->rdesc); - } hash_destroy(_xlrelcache); diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c index 817ed4c8c8..076b31fb17 100644 --- a/src/backend/bootstrap/bootstrap.c +++ b/src/backend/bootstrap/bootstrap.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.118 2001/10/19 17:03:08 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.119 2001/10/25 05:49:22 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -188,7 +188,7 @@ usage(void) { fprintf(stderr, gettext("Usage:\n" - " postgres -boot [-d] [-D datadir] [-F] [-o file] [-x num] dbname\n" + " postgres -boot [-d] [-D datadir] [-F] [-o file] [-x num] dbname\n" " -d debug mode\n" " -D datadir data directory\n" " -F turn off fsync\n" @@ -293,7 +293,7 @@ BootstrapMain(int argc, char *argv[]) { if (!potential_DataDir) { - fprintf(stderr, + fprintf(stderr, gettext("%s does not know where to find the database system data.\n" "You must specify the directory that contains the database system\n" "either by specifying the -D invocation option or by setting the\n" @@ -377,7 +377,7 @@ BootstrapMain(int argc, char *argv[]) case BS_XLOG_CHECKPOINT: if (IsUnderPostmaster) - InitDummyProcess(); /* needed to get LWLocks */ + InitDummyProcess(); /* needed to get LWLocks */ CreateDummyCaches(); CreateCheckPoint(false); SetRedoRecPtr(); @@ -996,7 +996,6 @@ FindStr(char *str, int length, hashnode *mderef) node = hashtable[CompHash(str, length)]; while (node != NULL) { - /* * We must differentiate between string constants that might have * the same value as a identifier and the identifier itself. diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c index 35352be16b..123dbdd247 100644 --- a/src/backend/catalog/aclchk.c +++ b/src/backend/catalog/aclchk.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.51 2001/06/18 16:13:21 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.52 2001/10/25 05:49:22 momjian Exp $ * * NOTES * See acl.h. @@ -61,8 +61,7 @@ dumpacl(Acl *acl) DatumGetCString(DirectFunctionCall1(aclitemout, PointerGetDatum(aip + i)))); } - -#endif /* ACLDEBUG */ +#endif /* ACLDEBUG */ /* @@ -115,8 +114,8 @@ ExecuteGrantStmt(GrantStmt *stmt) relname); /* - * If there's no ACL, create a default using the - * pg_class.relowner field. + * If there's no ACL, create a default using the pg_class.relowner + * field. */ aclDatum = SysCacheGetAttr(RELNAME, tuple, Anum_pg_class_relacl, &isNull); @@ -133,10 +132,10 @@ ExecuteGrantStmt(GrantStmt *stmt) foreach(j, stmt->grantees) { - PrivGrantee *grantee = (PrivGrantee *)lfirst(j); + PrivGrantee *grantee = (PrivGrantee *) lfirst(j); char *granteeString; char *aclString; - AclItem aclitem; + AclItem aclitem; unsigned modechg; if (grantee->username) @@ -162,7 +161,8 @@ ExecuteGrantStmt(GrantStmt *stmt) { replaces[i] = ' '; nulls[i] = ' '; /* ignored if replaces[i]==' ' anyway */ - values[i] = (Datum) NULL; /* ignored if replaces[i]==' ' anyway */ + values[i] = (Datum) NULL; /* ignored if replaces[i]==' ' + * anyway */ } replaces[Anum_pg_class_relacl - 1] = 'r'; values[Anum_pg_class_relacl - 1] = PointerGetDatum(new_acl); @@ -175,6 +175,7 @@ ExecuteGrantStmt(GrantStmt *stmt) { /* keep the catalog indexes up to date */ Relation idescs[Num_pg_class_indices]; + CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices, idescs); CatalogIndexInsert(idescs, Num_pg_class_indices, relation, newtuple); @@ -322,8 +323,8 @@ aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode) } /* - * "World" rights are applicable regardless of the passed-in ID, - * and since they're much the cheapest to check, check 'em first. + * "World" rights are applicable regardless of the passed-in ID, and + * since they're much the cheapest to check, check 'em first. */ if (aidat->ai_idtype != ACL_IDTYPE_WORLD) elog(ERROR, "aclcheck: first entry in ACL is not 'world' entry"); @@ -376,7 +377,7 @@ aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode) for (i = 1, aip = aidat + 1; /* skip world entry */ i < num && aip->ai_idtype == ACL_IDTYPE_UID; ++i, ++aip) - /* skip UID entry */; + /* skip UID entry */ ; for (; i < num && aip->ai_idtype == ACL_IDTYPE_GID; ++i, ++aip) diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index 89d3072f7b..f78ac28693 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.178 2001/10/22 22:47:57 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.179 2001/10/25 05:49:22 momjian Exp $ * * * INTERFACE ROUTINES @@ -64,10 +64,10 @@ static void AddNewRelationTuple(Relation pg_class_desc, - Relation new_rel_desc, - Oid new_rel_oid, Oid new_type_oid, - char relkind, bool relhasoids, - char *temp_relname); + Relation new_rel_desc, + Oid new_rel_oid, Oid new_type_oid, + char relkind, bool relhasoids, + char *temp_relname); static void DeleteAttributeTuples(Relation rel); static void DeleteRelationTuple(Relation rel); static void DeleteTypeTuple(Relation rel); @@ -156,7 +156,7 @@ static Form_pg_attribute SysAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6, &a7}; Form_pg_attribute SystemAttributeDefinition(AttrNumber attno, bool relhasoids) { - if (attno >= 0 || attno < - (int) lengthof(SysAtt)) + if (attno >= 0 || attno < -(int) lengthof(SysAtt)) elog(ERROR, "SystemAttributeDefinition: invalid attribute number %d", attno); if (attno == ObjectIdAttributeNumber && !relhasoids) @@ -167,12 +167,12 @@ SystemAttributeDefinition(AttrNumber attno, bool relhasoids) /* * If the given name is a system attribute name, return a Form_pg_attribute - * pointer for a prototype definition. If not, return NULL. + * pointer for a prototype definition. If not, return NULL. */ Form_pg_attribute SystemAttributeByName(const char *attname, bool relhasoids) { - int j; + int j; for (j = 0; j < (int) lengthof(SysAtt); j++) { @@ -237,8 +237,8 @@ heap_create(char *relname, /* * Real ugly stuff to assign the proper relid in the relation - * descriptor follows. Note that only "bootstrapped" relations - * whose OIDs are hard-coded in pg_class.h need be listed here. + * descriptor follows. Note that only "bootstrapped" relations whose + * OIDs are hard-coded in pg_class.h need be listed here. */ if (relname && IsSystemRelationName(relname)) { @@ -541,7 +541,11 @@ AddNewAttributeTuples(Oid new_rel_oid, /* Fill in the correct relation OID in the copied tuple */ attStruct = (Form_pg_attribute) GETSTRUCT(tup); attStruct->attrelid = new_rel_oid; - /* Unneeded since they should be OK in the constant data anyway */ + + /* + * Unneeded since they should be OK in the constant data + * anyway + */ /* attStruct->attstattarget = 0; */ /* attStruct->attcacheoff = -1; */ @@ -613,7 +617,7 @@ AddNewRelationTuple(Relation pg_class_desc, case RELKIND_RELATION: case RELKIND_INDEX: case RELKIND_TOASTVALUE: - new_rel_reltup->relpages = 10; /* bogus estimates */ + new_rel_reltup->relpages = 10; /* bogus estimates */ new_rel_reltup->reltuples = 1000; break; case RELKIND_SEQUENCE: @@ -653,7 +657,6 @@ AddNewRelationTuple(Relation pg_class_desc, if (!IsIgnoringSystemIndexes()) { - /* * First, open the catalog indices and insert index tuples for the * new relation. @@ -1735,27 +1738,35 @@ AddRelationRawConstraints(Relation rel, { int i; int j; - bool success; + bool success; List *listptr2; + ccname = (char *) palloc(NAMEDATALEN); /* Loop until we find a non-conflicting constraint name */ /* What happens if this loops forever? */ j = numchecks + 1; - do { + do + { success = true; snprintf(ccname, NAMEDATALEN, "$%d", j); /* Check against old constraints */ for (i = 0; i < numoldchecks; i++) { - if (strcmp(oldchecks[i].ccname, ccname) == 0) { + if (strcmp(oldchecks[i].ccname, ccname) == 0) + { success = false; break; } } - /* Check against other new constraints, if the check hasn't already failed */ - if (success) { + + /* + * Check against other new constraints, if the check + * hasn't already failed + */ + if (success) + { foreach(listptr2, rawConstraints) { Constraint *cdef2 = (Constraint *) lfirst(listptr2); @@ -1765,7 +1776,8 @@ AddRelationRawConstraints(Relation rel, cdef2->raw_expr == NULL || cdef2->name == NULL) continue; - if (strcmp(cdef2->name, ccname) == 0) { + if (strcmp(cdef2->name, ccname) == 0) + { success = false; break; } @@ -1914,59 +1926,60 @@ RemoveRelCheck(Relation rel) int RemoveCheckConstraint(Relation rel, const char *constrName, bool inh) { - Oid relid; - Relation rcrel; - Relation relrel; - Relation inhrel; - Relation relidescs[Num_pg_class_indices]; - TupleDesc tupleDesc; - TupleConstr *oldconstr; - int numoldchecks; - int numchecks; - HeapScanDesc rcscan; - ScanKeyData key[2]; - HeapTuple rctup; - HeapTuple reltup; - Form_pg_class relStruct; - int rel_deleted = 0; - int all_deleted = 0; - - /* Find id of the relation */ - relid = RelationGetRelid(rel); - - /* Process child tables and remove constraints of the - same name. */ - if (inh) - { - List *child, - *children; - - /* This routine is actually in the planner */ - children = find_all_inheritors(relid); - - /* - * find_all_inheritors does the recursive search of the - * inheritance hierarchy, so all we have to do is process all - * of the relids in the list that it returns. - */ - foreach(child, children) - { - Oid childrelid = lfirsti(child); - - if (childrelid == relid) - continue; - inhrel = heap_open(childrelid, AccessExclusiveLock); - all_deleted += RemoveCheckConstraint(inhrel, constrName, false); - heap_close(inhrel, NoLock); - } - } + Oid relid; + Relation rcrel; + Relation relrel; + Relation inhrel; + Relation relidescs[Num_pg_class_indices]; + TupleDesc tupleDesc; + TupleConstr *oldconstr; + int numoldchecks; + int numchecks; + HeapScanDesc rcscan; + ScanKeyData key[2]; + HeapTuple rctup; + HeapTuple reltup; + Form_pg_class relStruct; + int rel_deleted = 0; + int all_deleted = 0; + + /* Find id of the relation */ + relid = RelationGetRelid(rel); + + /* + * Process child tables and remove constraints of the same name. + */ + if (inh) + { + List *child, + *children; + + /* This routine is actually in the planner */ + children = find_all_inheritors(relid); + + /* + * find_all_inheritors does the recursive search of the + * inheritance hierarchy, so all we have to do is process all of + * the relids in the list that it returns. + */ + foreach(child, children) + { + Oid childrelid = lfirsti(child); + + if (childrelid == relid) + continue; + inhrel = heap_open(childrelid, AccessExclusiveLock); + all_deleted += RemoveCheckConstraint(inhrel, constrName, false); + heap_close(inhrel, NoLock); + } + } /* Grab an exclusive lock on the pg_relcheck relation */ rcrel = heap_openr(RelCheckRelationName, RowExclusiveLock); /* - * Create two scan keys. We need to match on the oid of the table - * the CHECK is in and also we need to match the name of the CHECK + * Create two scan keys. We need to match on the oid of the table the + * CHECK is in and also we need to match the name of the CHECK * constraint. */ ScanKeyEntryInitialize(&key[0], 0, Anum_pg_relcheck_rcrelid, @@ -1979,14 +1992,15 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh) rcscan = heap_beginscan(rcrel, 0, SnapshotNow, 2, key); /* - * Scan over the result set, removing any matching entries. Note - * that this has the side-effect of removing ALL CHECK constraints - * that share the specified constraint name. + * Scan over the result set, removing any matching entries. Note that + * this has the side-effect of removing ALL CHECK constraints that + * share the specified constraint name. */ - while (HeapTupleIsValid(rctup = heap_getnext(rcscan, 0))) { + while (HeapTupleIsValid(rctup = heap_getnext(rcscan, 0))) + { simple_heap_delete(rcrel, &rctup->t_self); ++rel_deleted; - ++all_deleted; + ++all_deleted; } /* Clean up after the scan */ @@ -2001,7 +2015,7 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh) * message, but for ALTER TABLE ADD ATTRIBUTE this'd be important.) */ - /* + /* * Get number of existing constraints. */ @@ -2020,7 +2034,7 @@ RemoveCheckConstraint(Relation rel, const char *constrName, bool inh) relrel = heap_openr(RelationRelationName, RowExclusiveLock); reltup = SearchSysCacheCopy(RELOID, - ObjectIdGetDatum(RelationGetRelid(rel)), 0, 0, 0); + ObjectIdGetDatum(RelationGetRelid(rel)), 0, 0, 0); if (!HeapTupleIsValid(reltup)) elog(ERROR, "cache lookup of relation %u failed", diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index b53eab8652..0afb9cf7e4 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.165 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.166 2001/10/25 05:49:22 momjian Exp $ * * * INTERFACE ROUTINES @@ -64,19 +64,19 @@ static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName, bool istemp); static TupleDesc BuildFuncTupleDesc(Oid funcOid, - Oid *classObjectId); + Oid *classObjectId); static TupleDesc ConstructTupleDescriptor(Relation heapRelation, - int numatts, AttrNumber *attNums, - Oid *classObjectId); + int numatts, AttrNumber *attNums, + Oid *classObjectId); static void ConstructIndexReldesc(Relation indexRelation, Oid amoid); static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname); static void InitializeAttributeOids(Relation indexRelation, int numatts, Oid indexoid); static void AppendAttributeTuples(Relation indexRelation, int numatts); static void UpdateIndexRelation(Oid indexoid, Oid heapoid, - IndexInfo *indexInfo, - Oid *classOids, - bool primary); + IndexInfo *indexInfo, + Oid *classOids, + bool primary); static Oid IndexGetRelation(Oid indexId); static bool activate_index(Oid indexId, bool activate, bool inplace); @@ -255,7 +255,7 @@ ConstructTupleDescriptor(Relation heapRelation, * here we are indexing on a system attribute (-1...-n) */ from = SystemAttributeDefinition(atnum, - heapRelation->rd_rel->relhasoids); + heapRelation->rd_rel->relhasoids); } else { @@ -319,11 +319,11 @@ ConstructTupleDescriptor(Relation heapRelation, elog(ERROR, "Type %u does not exist", keyType); typeTup = (Form_pg_type) GETSTRUCT(tuple); - to->atttypid = keyType; - to->atttypmod = -1; - to->attlen = typeTup->typlen; - to->attbyval = typeTup->typbyval; - to->attalign = typeTup->typalign; + to->atttypid = keyType; + to->atttypmod = -1; + to->attlen = typeTup->typlen; + to->attbyval = typeTup->typbyval; + to->attalign = typeTup->typalign; to->attstorage = typeTup->typstorage; ReleaseSysCache(tuple); @@ -405,14 +405,15 @@ ConstructIndexReldesc(Relation indexRelation, Oid amoid) * Fill in a copy of relevant pg_am entry */ indexRelation->rd_am = AccessMethodObjectIdGetForm(amoid, - CacheMemoryContext); + CacheMemoryContext); + /* - * Set up some additional fields of the index' pg_class entry. - * In particular, initialize knowledge of whether the index is shared. + * Set up some additional fields of the index' pg_class entry. In + * particular, initialize knowledge of whether the index is shared. */ indexRelation->rd_rel->relowner = GetUserId(); indexRelation->rd_rel->relam = amoid; - indexRelation->rd_rel->relisshared = + indexRelation->rd_rel->relisshared = IsSharedSystemRelationName(RelationGetPhysicalRelationName(indexRelation)); indexRelation->rd_rel->relkind = RELKIND_INDEX; indexRelation->rd_rel->relhasoids = false; @@ -521,10 +522,10 @@ AppendAttributeTuples(Relation indexRelation, int numatts) for (i = 0; i < numatts; i++) { /* - * There used to be very grotty code here to set these fields, - * but I think it's unnecessary. They should be set already. + * There used to be very grotty code here to set these fields, but + * I think it's unnecessary. They should be set already. */ - Assert(indexTupDesc->attrs[i]->attnum == i+1); + Assert(indexTupDesc->attrs[i]->attnum == i + 1); Assert(indexTupDesc->attrs[i]->attcacheoff == -1); new_tuple = heap_addheader(Natts_pg_attribute, @@ -592,7 +593,7 @@ UpdateIndexRelation(Oid indexoid, indexForm->indexrelid = indexoid; indexForm->indrelid = heapoid; indexForm->indproc = indexInfo->ii_FuncOid; - indexForm->indisclustered = false; /* not used */ + indexForm->indisclustered = false; /* not used */ indexForm->indisunique = indexInfo->ii_Unique; indexForm->indisprimary = primary; memcpy((char *) &indexForm->indpred, (char *) predText, predLen); @@ -678,7 +679,7 @@ index_create(char *heapRelationName, elog(ERROR, "must index at least one column"); if (heapRelationName && !allow_system_table_mods && - IsSystemRelationName(heapRelationName) && IsNormalProcessingMode()) + IsSystemRelationName(heapRelationName) && IsNormalProcessingMode()) elog(ERROR, "User-defined indexes on system catalogs are not supported"); /* @@ -700,7 +701,7 @@ index_create(char *heapRelationName, else indexTupDesc = ConstructTupleDescriptor(heapRelation, indexInfo->ii_NumKeyAttrs, - indexInfo->ii_KeyAttrNumbers, + indexInfo->ii_KeyAttrNumbers, classObjectId); if (istemp) @@ -825,12 +826,13 @@ index_drop(Oid indexId) * To drop an index safely, we must grab exclusive lock on its parent * table; otherwise there could be other backends using the index! * Exclusive lock on the index alone is insufficient because another - * backend might be in the midst of devising a query plan that will use - * the index. The parser and planner take care to hold an appropriate - * lock on the parent table while working, but having them hold locks on - * all the indexes too seems overly complex. We do grab exclusive lock - * on the index too, just to be safe. Both locks must be held till end of - * transaction, else other backends will still see this index in pg_index. + * backend might be in the midst of devising a query plan that will + * use the index. The parser and planner take care to hold an + * appropriate lock on the parent table while working, but having them + * hold locks on all the indexes too seems overly complex. We do grab + * exclusive lock on the index too, just to be safe. Both locks must + * be held till end of transaction, else other backends will still see + * this index in pg_index. */ heapId = IndexGetRelation(indexId); userHeapRelation = heap_open(heapId, AccessExclusiveLock); @@ -873,8 +875,8 @@ index_drop(Oid indexId) * ensure other backends update their relcache lists of indexes. So, * unconditionally do setRelhasindex(true). * - * Possible future improvement: skip the physical tuple update and - * just send out an invalidation message. + * Possible future improvement: skip the physical tuple update and just + * send out an invalidation message. */ setRelhasindex(heapId, true, false, InvalidOid); @@ -950,7 +952,7 @@ index_drop(Oid indexId) * just once per command, and then use it for (potentially) many tuples. * ---------------- */ -IndexInfo * +IndexInfo * BuildIndexInfo(HeapTuple indexTuple) { Form_pg_index indexStruct = (Form_pg_index) GETSTRUCT(indexTuple); @@ -974,8 +976,8 @@ BuildIndexInfo(HeapTuple indexTuple) * Handle functional index. * * If we have a functional index then the number of attributes defined in - * the index must be 1 (the function's single return value). - * Otherwise it's same as number of keys. + * the index must be 1 (the function's single return value). Otherwise + * it's same as number of keys. */ ii->ii_FuncOid = indexStruct->indproc; @@ -1041,7 +1043,6 @@ FormIndexDatum(IndexInfo *indexInfo, if (OidIsValid(indexInfo->ii_FuncOid)) { - /* * Functional index --- compute the single index attribute */ @@ -1076,7 +1077,6 @@ FormIndexDatum(IndexInfo *indexInfo, } else { - /* * Plain index --- for each attribute we need from the heap tuple, * get the attribute and stick it into the datum and nullv arrays. @@ -1198,7 +1198,7 @@ IndexesAreActive(Oid relid, bool confirmCommitted) * set relhasindex of relation's pg_class entry * * If isprimary is TRUE, we are defining a primary index, so also set - * relhaspkey to TRUE. Otherwise, leave relhaspkey alone. + * relhaspkey to TRUE. Otherwise, leave relhaspkey alone. * * If reltoastidxid is not InvalidOid, also set reltoastidxid to that value. * This is only used for TOAST relations. @@ -1390,7 +1390,7 @@ UpdateStats(Oid relid, double reltuples) Relation pg_class; HeapTuple tuple; HeapTuple newtup; - BlockNumber relpages; + BlockNumber relpages; int i; Form_pg_class rd_rel; Relation idescs[Num_pg_class_indices]; @@ -1473,8 +1473,8 @@ UpdateStats(Oid relid, double reltuples) * when it is actually sizable. See also CREATE TABLE in heap.c. * * Note: this path is also taken during bootstrap, because bootstrap.c - * passes reltuples = 0 after loading a table. We have to estimate some - * number for reltuples based on the actual number of pages. + * passes reltuples = 0 after loading a table. We have to estimate + * some number for reltuples based on the actual number of pages. */ relpages = RelationGetNumberOfBlocks(whichRel); @@ -1492,7 +1492,7 @@ UpdateStats(Oid relid, double reltuples) reltuples = 1000; } else - reltuples = (double) relpages * NTUPLES_PER_PAGE(whichRel->rd_rel->relnatts); + reltuples = (double) relpages *NTUPLES_PER_PAGE(whichRel->rd_rel->relnatts); } /* @@ -1508,7 +1508,6 @@ UpdateStats(Oid relid, double reltuples) */ if (in_place_upd) { - /* * At bootstrap time, we don't need to worry about concurrency or * visibility of changes, so we cheat. Also cheat if REINDEX. @@ -1599,8 +1598,8 @@ index_build(Relation heapRelation, * build procedure does whatever cleanup is needed; in particular, it should * close the heap and index relations. * - * The total count of heap tuples is returned. This is for updating pg_class - * statistics. (It's annoying not to be able to do that here, but we can't + * The total count of heap tuples is returned. This is for updating pg_class + * statistics. (It's annoying not to be able to do that here, but we can't * do it until after the relation is closed.) Note that the index AM itself * must keep track of the number of index tuples; we don't do so here because * the AM might reject some of the tuples for its own reasons, such as being @@ -1658,7 +1657,8 @@ IndexBuildHeapScan(Relation heapRelation, /* * Ok, begin our scan of the base relation. We use SnapshotAny - * because we must retrieve all tuples and do our own time qual checks. + * because we must retrieve all tuples and do our own time qual + * checks. */ if (IsBootstrapProcessingMode()) { @@ -1673,7 +1673,7 @@ IndexBuildHeapScan(Relation heapRelation, scan = heap_beginscan(heapRelation, /* relation */ 0, /* start at end */ - snapshot, /* seeself */ + snapshot, /* seeself */ 0, /* number of keys */ (ScanKey) NULL); /* scan key */ @@ -1689,14 +1689,14 @@ IndexBuildHeapScan(Relation heapRelation, if (snapshot == SnapshotAny) { /* do our own time qual check */ - bool indexIt; - uint16 sv_infomask; + bool indexIt; + uint16 sv_infomask; /* - * HeapTupleSatisfiesVacuum may update tuple's hint status bits. - * We could possibly get away with not locking the buffer here, - * since caller should hold ShareLock on the relation, but let's - * be conservative about it. + * HeapTupleSatisfiesVacuum may update tuple's hint status + * bits. We could possibly get away with not locking the + * buffer here, since caller should hold ShareLock on the + * relation, but let's be conservative about it. */ LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE); sv_infomask = heapTuple->t_data->t_infomask; @@ -1712,6 +1712,7 @@ IndexBuildHeapScan(Relation heapRelation, tupleIsAlive = true; break; case HEAPTUPLE_RECENTLY_DEAD: + /* * If tuple is recently deleted then we must index it * anyway to keep VACUUM from complaining. @@ -1720,32 +1721,36 @@ IndexBuildHeapScan(Relation heapRelation, tupleIsAlive = false; break; case HEAPTUPLE_INSERT_IN_PROGRESS: + /* - * Since caller should hold ShareLock or better, we should - * not see any tuples inserted by open transactions --- - * unless it's our own transaction. (Consider INSERT - * followed by CREATE INDEX within a transaction.) + * Since caller should hold ShareLock or better, we + * should not see any tuples inserted by open + * transactions --- unless it's our own transaction. + * (Consider INSERT followed by CREATE INDEX within a + * transaction.) */ - if (! TransactionIdIsCurrentTransactionId(heapTuple->t_data->t_xmin)) + if (!TransactionIdIsCurrentTransactionId(heapTuple->t_data->t_xmin)) elog(ERROR, "IndexBuildHeapScan: concurrent insert in progress"); indexIt = true; tupleIsAlive = true; break; case HEAPTUPLE_DELETE_IN_PROGRESS: + /* - * Since caller should hold ShareLock or better, we should - * not see any tuples deleted by open transactions --- - * unless it's our own transaction. (Consider DELETE - * followed by CREATE INDEX within a transaction.) + * Since caller should hold ShareLock or better, we + * should not see any tuples deleted by open + * transactions --- unless it's our own transaction. + * (Consider DELETE followed by CREATE INDEX within a + * transaction.) */ - if (! TransactionIdIsCurrentTransactionId(heapTuple->t_data->t_xmax)) + if (!TransactionIdIsCurrentTransactionId(heapTuple->t_data->t_xmax)) elog(ERROR, "IndexBuildHeapScan: concurrent delete in progress"); indexIt = true; tupleIsAlive = false; break; default: elog(ERROR, "Unexpected HeapTupleSatisfiesVacuum result"); - indexIt = tupleIsAlive = false; /* keep compiler quiet */ + indexIt = tupleIsAlive = false; /* keep compiler quiet */ break; } @@ -1755,7 +1760,7 @@ IndexBuildHeapScan(Relation heapRelation, LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK); - if (! indexIt) + if (!indexIt) continue; } else @@ -1776,7 +1781,7 @@ IndexBuildHeapScan(Relation heapRelation, */ if (predicate != NIL) { - if (! tupleIsAlive) + if (!tupleIsAlive) continue; ExecStoreTuple(heapTuple, slot, InvalidBuffer, false); if (!ExecQual(predicate, econtext, false)) @@ -1785,7 +1790,7 @@ IndexBuildHeapScan(Relation heapRelation, /* * For the current heap tuple, extract all the attributes we use - * in this index, and note which are null. This also performs + * in this index, and note which are null. This also performs * evaluation of the function, if this is a functional index. */ FormIndexDatum(indexInfo, @@ -1797,8 +1802,8 @@ IndexBuildHeapScan(Relation heapRelation, /* * You'd think we should go ahead and build the index tuple here, - * but some index AMs want to do further processing on the - * data first. So pass the attdata and nulls arrays, instead. + * but some index AMs want to do further processing on the data + * first. So pass the attdata and nulls arrays, instead. */ /* Call the AM's callback routine to process the tuple */ @@ -1919,7 +1924,6 @@ reindex_index(Oid indexId, bool force, bool inplace) if (inplace) { - /* * Release any buffers associated with this index. If they're * dirty, they're just dropped without bothering to flush to disk. @@ -2002,11 +2006,12 @@ reindex_relation(Oid relid, bool force) upd_pg_class_inplace = true; /* - * Ensure to hold an exclusive lock throughout the - * transaction. The lock could be less intensive - * but now it's AccessExclusiveLock for simplicity. + * Ensure to hold an exclusive lock throughout the transaction. The + * lock could be less intensive but now it's AccessExclusiveLock for + * simplicity. */ rel = heap_open(relid, AccessExclusiveLock); + /* * ignore the indexes of the target system relation while processing * reindex. @@ -2045,8 +2050,9 @@ reindex_relation(Oid relid, bool force) else elog(ERROR, "the target relation %u is shared", relid); } + /* - * Continue to hold the lock. + * Continue to hold the lock. */ heap_close(rel, NoLock); @@ -2087,7 +2093,6 @@ reindex_relation(Oid relid, bool force) heap_close(indexRelation, AccessShareLock); if (reindexed) { - /* * Ok,we could use the reindexed indexes of the target system * relation now. @@ -2096,7 +2101,6 @@ reindex_relation(Oid relid, bool force) { if (!overwrite && relid == RelOid_pg_class) { - /* * For pg_class, relhasindex should be set to true here in * place. diff --git a/src/backend/catalog/pg_aggregate.c b/src/backend/catalog/pg_aggregate.c index 119e125402..f037852bb5 100644 --- a/src/backend/catalog/pg_aggregate.c +++ b/src/backend/catalog/pg_aggregate.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.39 2001/08/10 15:49:39 petere Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.40 2001/10/25 05:49:23 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -167,7 +167,6 @@ AggregateCreate(char *aggName, } else { - /* * If no finalfn, aggregate result type is type of the state value */ diff --git a/src/backend/catalog/pg_operator.c b/src/backend/catalog/pg_operator.c index 97e0b87b9c..efd98b546f 100644 --- a/src/backend/catalog/pg_operator.c +++ b/src/backend/catalog/pg_operator.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.62 2001/10/22 19:34:13 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.63 2001/10/25 05:49:23 momjian Exp $ * * NOTES * these routines moved here from commands/define.c and somewhat cleaned up. @@ -74,7 +74,7 @@ static void OperatorUpd(Oid baseId, Oid commId, Oid negId); static bool validOperatorName(const char *name) { - size_t len = strlen(name); + size_t len = strlen(name); /* Can't be empty or too long */ if (len == 0 || len >= NAMEDATALEN) @@ -90,20 +90,19 @@ validOperatorName(const char *name) return false; /* - * For SQL92 compatibility, '+' and '-' cannot be the - * last char of a multi-char operator unless the operator - * contains chars that are not in SQL92 operators. - * The idea is to lex '=-' as two operators, but not - * to forbid operator names like '?-' that could not be - * sequences of SQL92 operators. + * For SQL92 compatibility, '+' and '-' cannot be the last char of a + * multi-char operator unless the operator contains chars that are not + * in SQL92 operators. The idea is to lex '=-' as two operators, but + * not to forbid operator names like '?-' that could not be sequences + * of SQL92 operators. */ if (len > 1 && - (name[len-1] == '+' || - name[len-1] == '-')) + (name[len - 1] == '+' || + name[len - 1] == '-')) { - int ic; + int ic; - for (ic = len-2; ic >= 0; ic--) + for (ic = len - 2; ic >= 0; ic--) { if (strchr("~!@#^&|`?$%", name[ic])) break; @@ -143,7 +142,7 @@ OperatorGetWithOpenRelation(Relation pg_operator_desc, HeapScanDesc pg_operator_scan; Oid operatorObjectId; HeapTuple tup; - ScanKeyData opKey[3]; + ScanKeyData opKey[3]; /* * form scan key @@ -495,7 +494,7 @@ OperatorDef(char *operatorName, int nargs; NameData oname; TupleDesc tupDesc; - ScanKeyData opKey[3]; + ScanKeyData opKey[3]; operatorObjectId = OperatorGet(operatorName, leftTypeName, @@ -743,7 +742,6 @@ OperatorDef(char *operatorName, } else { - /* * self-linkage to this operator; will fix below. Note * that only self-linkage for commutation makes sense. @@ -867,7 +865,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId) char nulls[Natts_pg_operator]; char replaces[Natts_pg_operator]; Datum values[Natts_pg_operator]; - ScanKeyData opKey[1]; + ScanKeyData opKey[1]; for (i = 0; i < Natts_pg_operator; ++i) { diff --git a/src/backend/catalog/pg_proc.c b/src/backend/catalog/pg_proc.c index e83d35edbf..016b9c1d98 100644 --- a/src/backend/catalog/pg_proc.c +++ b/src/backend/catalog/pg_proc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.61 2001/10/06 23:21:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.62 2001/10/25 05:49:23 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -125,7 +125,6 @@ ProcedureCreate(char *procedureName, if (languageObjectId == SQLlanguageId) { - /* * If this call is defining a set, check if the set is already * defined by looking to see whether this call's function text @@ -230,7 +229,7 @@ ProcedureCreate(char *procedureName, prosrc = procedureName; if (fmgr_internal_function(prosrc) == InvalidOid) elog(ERROR, - "there is no built-in function named \"%s\"", + "there is no built-in function named \"%s\"", prosrc); } @@ -246,7 +245,7 @@ ProcedureCreate(char *procedureName, if (languageObjectId == ClanguageId) { - void *libraryhandle; + void *libraryhandle; /* If link symbol is specified as "-", substitute procedure name */ if (strcmp(prosrc, "-") == 0) @@ -303,7 +302,7 @@ ProcedureCreate(char *procedureName, if (HeapTupleIsValid(oldtup)) { /* There is one; okay to replace it? */ - Form_pg_proc oldproc = (Form_pg_proc) GETSTRUCT(oldtup); + Form_pg_proc oldproc = (Form_pg_proc) GETSTRUCT(oldtup); if (!replace) elog(ERROR, "function %s already exists with same argument types", @@ -311,6 +310,7 @@ ProcedureCreate(char *procedureName, if (GetUserId() != oldproc->proowner && !superuser()) elog(ERROR, "ProcedureCreate: you do not have permission to replace function %s", procedureName); + /* * Not okay to change the return type of the existing proc, since * existing rules, views, etc may depend on the return type. @@ -321,8 +321,8 @@ ProcedureCreate(char *procedureName, "\n\tUse DROP FUNCTION first."); /* Okay, do it... */ - tup = heap_modifytuple(oldtup, rel, values, nulls, replaces); - simple_heap_update(rel, &tup->t_self, tup); + tup = heap_modifytuple(oldtup, rel, values, nulls, replaces); + simple_heap_update(rel, &tup->t_self, tup); ReleaseSysCache(oldtup); } @@ -412,8 +412,8 @@ checkretval(Oid rettype, List *queryTreeList) /* * For base-type returns, the target list should have exactly one - * entry, and its type should agree with what the user declared. - * (As of Postgres 7.2, we accept binary-compatible types too.) + * entry, and its type should agree with what the user declared. (As + * of Postgres 7.2, we accept binary-compatible types too.) */ typerelid = typeidTypeRelid(rettype); if (typerelid == InvalidOid) @@ -433,9 +433,9 @@ checkretval(Oid rettype, List *queryTreeList) /* * If the target list is of length 1, and the type of the varnode in * the target list matches the declared return type, this is okay. - * This can happen, for example, where the body of the function - * is 'SELECT func2()', where func2 has the same return type as - * the function that's calling it. + * This can happen, for example, where the body of the function is + * 'SELECT func2()', where func2 has the same return type as the + * function that's calling it. */ if (tlistlen == 1) { diff --git a/src/backend/catalog/pg_type.c b/src/backend/catalog/pg_type.c index b79bd7068f..f14d06e0e2 100644 --- a/src/backend/catalog/pg_type.c +++ b/src/backend/catalog/pg_type.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.64 2001/10/12 00:07:14 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.65 2001/10/25 05:49:23 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -318,13 +318,13 @@ TypeCreate(char *typeName, } /* - * validate size specifications: either positive (fixed-length) or - * -1 (variable-length). + * validate size specifications: either positive (fixed-length) or -1 + * (variable-length). */ - if (! (internalSize > 0 || internalSize == -1)) + if (!(internalSize > 0 || internalSize == -1)) elog(ERROR, "TypeCreate: invalid type internal size %d", internalSize); - if (! (externalSize > 0 || externalSize == -1)) + if (!(externalSize > 0 || externalSize == -1)) elog(ERROR, "TypeCreate: invalid type external size %d", externalSize); @@ -382,7 +382,6 @@ TypeCreate(char *typeName, if (!OidIsValid(procOid)) { - /* * For array types, the input procedures may take 3 args (data * value, element OID, atttypmod); the pg_proc argtype @@ -434,7 +433,7 @@ TypeCreate(char *typeName, */ if (defaultTypeValue) values[i] = DirectFunctionCall1(textin, - CStringGetDatum(defaultTypeValue)); + CStringGetDatum(defaultTypeValue)); else nulls[i] = 'n'; i++; /* 17 */ diff --git a/src/backend/commands/_deadcode/recipe.c b/src/backend/commands/_deadcode/recipe.c index 15a1d0a564..3cc26fa51c 100644 --- a/src/backend/commands/_deadcode/recipe.c +++ b/src/backend/commands/_deadcode/recipe.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.13 2001/03/22 06:16:12 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.14 2001/10/25 05:49:27 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -431,7 +431,6 @@ tg_replaceNumberedParam(Node *expression, { case T_Param: { - /* * the node is a parameter, substitute the entry from the * target list of the child that corresponds to the @@ -445,7 +444,6 @@ tg_replaceNumberedParam(Node *expression, if (p->param_tlist) { - /* * we have a parameter with an attribute like * $N.foo so replace it with a new var node @@ -506,7 +504,6 @@ tg_replaceNumberedParam(Node *expression, break; case T_Expr: { - /* * the node is an expression, we need to recursively call * ourselves until we find parameter nodes @@ -578,7 +575,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist) { case T_Param: { - /* * the node is a parameter, substitute the entry from the * target list of the child that corresponds to the @@ -594,7 +590,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist) if (p->param_tlist) { - /* * we have a parameter with an attribute like * $N.foo so match the resname "foo" against the @@ -634,7 +629,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist) break; case T_Expr: { - /* * the node is an expression, we need to recursively call * ourselves until we find parameter nodes @@ -834,7 +828,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) { case TG_SQL: { - /* * for SQL ingredients, the SQL query is contained in * the 'src' field @@ -940,7 +933,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) } else if (n->nodeType == TG_EYE_NODE) { - /* * if we hit an eye, we need to stop and make what we have into a * subrecipe query block @@ -949,7 +941,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) } else if (n->nodeType == TG_TEE_NODE) { - /* * if we hit a tee, check to see if the parsing has been done for * this tee already by the other parent @@ -958,7 +949,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) rel = RelationNameGetRelation(n->nodeName); if (RelationIsValid(rel)) { - /* * this tee has already been visited, no need to do any * further processing @@ -1014,7 +1004,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) if (RelationIsValid(rel)) { - /* * for complex types, create new relation with the same * tuple descriptor as the output table type @@ -1028,7 +1017,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo) } else { - /* * we have to create a relation with one attribute of the * simple base type. That attribute will have an attr @@ -1197,7 +1185,6 @@ replaceSeqScan(Plan *plan, Plan *parent, snode = (Scan *) plan; if (snode->scanrelid == rt_ind) { - /* * found the sequential scan that should be replaced with the * tplan. @@ -1328,5 +1315,4 @@ replaceTeeScans(Plan *plan, Query *parsetree, TeeInfo * teeInfo) } - #endif /* TIOGA */ diff --git a/src/backend/commands/_deadcode/recipe.h b/src/backend/commands/_deadcode/recipe.h index 7ac908fa7c..11dafaefa7 100644 --- a/src/backend/commands/_deadcode/recipe.h +++ b/src/backend/commands/_deadcode/recipe.h @@ -6,7 +6,7 @@ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: recipe.h,v 1.3 2001/01/24 19:42:53 momjian Exp $ + * $Id: recipe.h,v 1.4 2001/10/25 05:49:27 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -16,5 +16,4 @@ #include "nodes/parsenodes.h" extern void beginRecipe(RecipeStmt *stmt); - #endif /* RECIPE_H */ diff --git a/src/backend/commands/_deadcode/version.c b/src/backend/commands/_deadcode/version.c index 2b8b3b6345..3a5170e86a 100644 --- a/src/backend/commands/_deadcode/version.c +++ b/src/backend/commands/_deadcode/version.c @@ -10,7 +10,7 @@ * doesn't work! - jolly 8/19/95 * * - * $Id: version.c,v 1.26 2001/03/23 04:49:52 momjian Exp $ + * $Id: version.c,v 1.27 2001/10/25 05:49:27 momjian Exp $ * * NOTES * At the point the version is defined, 2 physical relations are created @@ -87,7 +87,6 @@ eval_as_new_xact(char *query) CommandCounterIncrement(); pg_exec_query(query); } - #endif /* * Define a version. @@ -129,7 +128,6 @@ DefineVersion(char *name, char *fromRelname, char *date) VersionReplace(name, saved_basename, saved_snapshot); VersionRetrieve(name, saved_basename, saved_snapshot); } - #endif /* @@ -162,7 +160,6 @@ VersionCreate(char *vname, char *bname) sprintf(query_buf, "CREATE TABLE %s_del (DOID oid)", vname); eval_as_new_xact(query_buf); } - #endif @@ -210,7 +207,6 @@ setAttrList(char *bname) return; } - #endif /* @@ -228,7 +224,6 @@ VersionAppend(char *vname, char *bname) eval_as_new_xact(rule_buf); } - #endif /* @@ -257,7 +252,6 @@ where _%s.oid !!= '%s_del.DOID'", /* printf("%s\n",rule_buf); */ } - #endif /* @@ -295,7 +289,6 @@ VersionDelete(char *vname, char *bname, char *snapshot) eval_as_new_xact(rule_buf); #endif /* OLD_REWRITE */ } - #endif /* @@ -349,5 +342,4 @@ VersionReplace(char *vname, char *bname, char *snapshot) /* printf("%s\n",rule_buf); */ } - #endif diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index e7a7d5c066..41c863a5ba 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.22 2001/07/05 19:33:35 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.23 2001/10/25 05:49:23 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -37,9 +37,11 @@ /* * Analysis algorithms supported */ -typedef enum { +typedef enum +{ ALG_MINIMAL = 1, /* Compute only most-common-values */ - ALG_SCALAR /* Compute MCV, histogram, sort correlation */ + ALG_SCALAR /* Compute MCV, histogram, sort + * correlation */ } AlgCode; /* @@ -70,7 +72,10 @@ typedef struct Oid eqfunc; /* and associated function */ Oid ltopr; /* '<' operator for datatype, if any */ - /* These fields are filled in by the actual statistics-gathering routine */ + /* + * These fields are filled in by the actual statistics-gathering + * routine + */ bool stats_valid; float4 stanullfrac; /* fraction of entries that are NULL */ int4 stawidth; /* average width */ @@ -101,7 +106,7 @@ typedef struct #define swapDatum(a,b) do {Datum _tmp; _tmp=a; a=b; b=_tmp;} while(0) -static int MESSAGE_LEVEL; +static int MESSAGE_LEVEL; /* context information for compare_scalars() */ static FmgrInfo *datumCmpFn; @@ -111,19 +116,19 @@ static int *datumCmpTupnoLink; static VacAttrStats *examine_attribute(Relation onerel, int attnum); static int acquire_sample_rows(Relation onerel, HeapTuple *rows, - int targrows, double *totalrows); + int targrows, double *totalrows); static double random_fract(void); static double init_selection_state(int n); static double select_next_random_record(double t, int n, double *stateptr); -static int compare_rows(const void *a, const void *b); -static int compare_scalars(const void *a, const void *b); -static int compare_mcvs(const void *a, const void *b); +static int compare_rows(const void *a, const void *b); +static int compare_scalars(const void *a, const void *b); +static int compare_mcvs(const void *a, const void *b); static void compute_minimal_stats(VacAttrStats *stats, - TupleDesc tupDesc, double totalrows, - HeapTuple *rows, int numrows); + TupleDesc tupDesc, double totalrows, + HeapTuple *rows, int numrows); static void compute_scalar_stats(VacAttrStats *stats, - TupleDesc tupDesc, double totalrows, - HeapTuple *rows, int numrows); + TupleDesc tupDesc, double totalrows, + HeapTuple *rows, int numrows); static void update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats); @@ -154,8 +159,8 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt) * Begin a transaction for analyzing this relation. * * Note: All memory allocated during ANALYZE will live in - * TransactionCommandContext or a subcontext thereof, so it will - * all be released by transaction commit at the end of this routine. + * TransactionCommandContext or a subcontext thereof, so it will all + * be released by transaction commit at the end of this routine. */ StartTransactionCommand(); @@ -191,14 +196,14 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt) ReleaseSysCache(tuple); /* - * Open the class, getting only a read lock on it, and check permissions. - * Permissions check should match vacuum's check! + * Open the class, getting only a read lock on it, and check + * permissions. Permissions check should match vacuum's check! */ onerel = heap_open(relid, AccessShareLock); - if (! (pg_ownercheck(GetUserId(), RelationGetRelationName(onerel), - RELNAME) || - (is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared))) + if (!(pg_ownercheck(GetUserId(), RelationGetRelationName(onerel), + RELNAME) || + (is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared))) { /* No need for a notice if we already com |